This commit is contained in:
puxuan 2025-11-03 15:00:43 +08:00
parent 1db0ebb9e3
commit c31ee9b2e6
583 changed files with 322768 additions and 14 deletions

View File

@ -146,16 +146,7 @@ namespace BFEditor.Build
PlayerSettings.SetScriptingDefineSymbolsForGroup(BuildTargetGroup.Android, 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;

View File

@ -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;

View File

@ -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!");
}
}
}

View File

@ -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!");
}
}
}

View File

@ -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<string> _callback = translator.GetDelegate<System.Action<string>>(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<System.Action<int>>(L, 2))
{
System.Action<int> _callback = translator.GetDelegate<System.Action<int>>(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<System.Action<int>>(L, 2))
{
System.Action<int> _callback = translator.GetDelegate<System.Action<int>>(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<System.Action<string>>(L, 2);
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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);
}
}
}
}

View File

@ -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<BF.AssetBundleConfig>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<BF.AssetBundleConfig>));
} 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<BF.LanguageConfig>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<BF.LanguageConfig>));
} 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<BF.AssetBundleConfig>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<BF.AssetBundleConfig>));
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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<BF.AssetObject>(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<System.Type>(L, 3)&& translator.Assignable<System.Action<string, UnityEngine.Object>>(L, 4))
{
string _assetPath = LuaAPI.lua_tostring(L, 2);
System.Type _type = (System.Type)translator.GetObject(L, 3, typeof(System.Type));
System.Action<string, UnityEngine.Object> _complete = translator.GetDelegate<System.Action<string, UnityEngine.Object>>(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<BF.AssetBundleObject> _complete = translator.GetDelegate<System.Action<BF.AssetBundleObject>>(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<BF.AssetBundleObject> _complete = translator.GetDelegate<System.Action<BF.AssetBundleObject>>(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<BF.AssetObject>(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<System.Type>(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<BF.AssetObject>(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<System.Action>(L, 4))
{
string _assetBundlePath = LuaAPI.lua_tostring(L, 2);
bool _immediately = LuaAPI.lua_toboolean(L, 3);
System.Action _unloadCallback = translator.GetDelegate<System.Action>(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<BF.AssetBundleObject> _complete = translator.GetDelegate<System.Action<BF.AssetBundleObject>>(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;
}
}
}

View File

@ -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<BF.AssetBundleConfig>(L, 2) && translator.Assignable<BF.AssetBundleLoader>(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<BF.AssetBundleObject> _callback = translator.GetDelegate<System.Action<BF.AssetBundleObject>>(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<System.Action>(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<string, string>)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary<string, string>));
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

View File

@ -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<string, UnityEngine.Object> _complete = translator.GetDelegate<System.Action<string, UnityEngine.Object>>(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<BF.AssetObject>(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<System.Type>(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<BF.AssetBundleObject> _complete = translator.GetDelegate<System.Action<BF.AssetBundleObject>>(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);
}
}
}
}

View File

@ -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;
}
}
}

View File

@ -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<System.Type>(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<System.Type>(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<string, UnityEngine.Object> _callback = translator.GetDelegate<System.Action<string, UnityEngine.Object>>(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);
}
}
}
}

View File

@ -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);
}
}
}
}

View File

@ -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<string>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<string>));
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

View File

@ -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<int> _callback = translator.GetDelegate<System.Action<int>>(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<int> _callback = translator.GetDelegate<System.Action<int>>(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<int, string> _callback = translator.GetDelegate<System.Action<int, string>>(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<System.Action<int>>(L, 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<System.Action<int>>(L, 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<System.Action<int, string>>(L, 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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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<System.Delegate>(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<System.Delegate>(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);
}
}
}
}

View File

@ -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<BF.BFEvent>(L, 1) && translator.Assignable<System.Action>(L, 2))
{
BF.BFEvent leftside = (BF.BFEvent)translator.GetObject(L, 1, typeof(BF.BFEvent));
System.Action rightside = translator.GetDelegate<System.Action>(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<BF.BFEvent>(L, 1) && translator.Assignable<System.Action>(L, 2))
{
BF.BFEvent leftside = (BF.BFEvent)translator.GetObject(L, 1, typeof(BF.BFEvent));
System.Action rightside = translator.GetDelegate<System.Action>(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);
}
}
}
}

View File

@ -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<System.Collections.Generic.List<BF.BFFinger>>);
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<System.Collections.Generic.List<BF.BFFinger>>();
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<System.Collections.Generic.List<BF.BFFinger>>(_length);
translator.Push(L, gen_ret);
return 1;
}
if(LuaAPI.lua_gettop(L) == 1)
{
var gen_ret = new BF.BFEvent<System.Collections.Generic.List<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.BFEvent<System.Collections.Generic.List<BF.BFFinger>> constructor!");
}
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int __AddMeta(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
if (translator.Assignable<BF.BFEvent<System.Collections.Generic.List<BF.BFFinger>>>(L, 1) && translator.Assignable<System.Action<System.Collections.Generic.List<BF.BFFinger>>>(L, 2))
{
BF.BFEvent<System.Collections.Generic.List<BF.BFFinger>> leftside = (BF.BFEvent<System.Collections.Generic.List<BF.BFFinger>>)translator.GetObject(L, 1, typeof(BF.BFEvent<System.Collections.Generic.List<BF.BFFinger>>));
System.Action<System.Collections.Generic.List<BF.BFFinger>> rightside = translator.GetDelegate<System.Action<System.Collections.Generic.List<BF.BFFinger>>>(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<System.Collections.Generic.List<BF.BFFinger>>!");
}
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int __SubMeta(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
if (translator.Assignable<BF.BFEvent<System.Collections.Generic.List<BF.BFFinger>>>(L, 1) && translator.Assignable<System.Action<System.Collections.Generic.List<BF.BFFinger>>>(L, 2))
{
BF.BFEvent<System.Collections.Generic.List<BF.BFFinger>> leftside = (BF.BFEvent<System.Collections.Generic.List<BF.BFFinger>>)translator.GetObject(L, 1, typeof(BF.BFEvent<System.Collections.Generic.List<BF.BFFinger>>));
System.Action<System.Collections.Generic.List<BF.BFFinger>> rightside = translator.GetDelegate<System.Action<System.Collections.Generic.List<BF.BFFinger>>>(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<System.Collections.Generic.List<BF.BFFinger>>!");
}
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int _m_Invoke(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
BF.BFEvent<System.Collections.Generic.List<BF.BFFinger>> gen_to_be_invoked = (BF.BFEvent<System.Collections.Generic.List<BF.BFFinger>>)translator.FastGetCSObj(L, 1);
{
System.Collections.Generic.List<BF.BFFinger> _t = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<BF.BFFinger>));
gen_to_be_invoked.Invoke( _t );
return 0;
}
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
}
}
}

View File

@ -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<BF.SelectEventType, BF.BFFinger>);
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<BF.SelectEventType, BF.BFFinger>();
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<BF.SelectEventType, BF.BFFinger>(_length);
translator.Push(L, gen_ret);
return 1;
}
if(LuaAPI.lua_gettop(L) == 1)
{
var gen_ret = new BF.BFEvent<BF.SelectEventType, 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.BFEvent<BF.SelectEventType, BF.BFFinger> constructor!");
}
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int __AddMeta(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
if (translator.Assignable<BF.BFEvent<BF.SelectEventType, BF.BFFinger>>(L, 1) && translator.Assignable<System.Action<BF.SelectEventType, BF.BFFinger>>(L, 2))
{
BF.BFEvent<BF.SelectEventType, BF.BFFinger> leftside = (BF.BFEvent<BF.SelectEventType, BF.BFFinger>)translator.GetObject(L, 1, typeof(BF.BFEvent<BF.SelectEventType, BF.BFFinger>));
System.Action<BF.SelectEventType, BF.BFFinger> rightside = translator.GetDelegate<System.Action<BF.SelectEventType, BF.BFFinger>>(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<BF.SelectEventType, BF.BFFinger>!");
}
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int __SubMeta(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
if (translator.Assignable<BF.BFEvent<BF.SelectEventType, BF.BFFinger>>(L, 1) && translator.Assignable<System.Action<BF.SelectEventType, BF.BFFinger>>(L, 2))
{
BF.BFEvent<BF.SelectEventType, BF.BFFinger> leftside = (BF.BFEvent<BF.SelectEventType, BF.BFFinger>)translator.GetObject(L, 1, typeof(BF.BFEvent<BF.SelectEventType, BF.BFFinger>));
System.Action<BF.SelectEventType, BF.BFFinger> rightside = translator.GetDelegate<System.Action<BF.SelectEventType, BF.BFFinger>>(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<BF.SelectEventType, BF.BFFinger>!");
}
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int _m_Invoke(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
BF.BFEvent<BF.SelectEventType, BF.BFFinger> gen_to_be_invoked = (BF.BFEvent<BF.SelectEventType, BF.BFFinger>)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);
}
}
}
}

View File

@ -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<BF.TouchEventType, BF.BFFinger>);
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<BF.TouchEventType, BF.BFFinger>();
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<BF.TouchEventType, BF.BFFinger>(_length);
translator.Push(L, gen_ret);
return 1;
}
if(LuaAPI.lua_gettop(L) == 1)
{
var gen_ret = new BF.BFEvent<BF.TouchEventType, 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.BFEvent<BF.TouchEventType, BF.BFFinger> constructor!");
}
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int __AddMeta(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
if (translator.Assignable<BF.BFEvent<BF.TouchEventType, BF.BFFinger>>(L, 1) && translator.Assignable<System.Action<BF.TouchEventType, BF.BFFinger>>(L, 2))
{
BF.BFEvent<BF.TouchEventType, BF.BFFinger> leftside = (BF.BFEvent<BF.TouchEventType, BF.BFFinger>)translator.GetObject(L, 1, typeof(BF.BFEvent<BF.TouchEventType, BF.BFFinger>));
System.Action<BF.TouchEventType, BF.BFFinger> rightside = translator.GetDelegate<System.Action<BF.TouchEventType, BF.BFFinger>>(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<BF.TouchEventType, BF.BFFinger>!");
}
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int __SubMeta(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
if (translator.Assignable<BF.BFEvent<BF.TouchEventType, BF.BFFinger>>(L, 1) && translator.Assignable<System.Action<BF.TouchEventType, BF.BFFinger>>(L, 2))
{
BF.BFEvent<BF.TouchEventType, BF.BFFinger> leftside = (BF.BFEvent<BF.TouchEventType, BF.BFFinger>)translator.GetObject(L, 1, typeof(BF.BFEvent<BF.TouchEventType, BF.BFFinger>));
System.Action<BF.TouchEventType, BF.BFFinger> rightside = translator.GetDelegate<System.Action<BF.TouchEventType, BF.BFFinger>>(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<BF.TouchEventType, BF.BFFinger>!");
}
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int _m_Invoke(RealStatePtr L)
{
try {
ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
BF.BFEvent<BF.TouchEventType, BF.BFFinger> gen_to_be_invoked = (BF.BFEvent<BF.TouchEventType, BF.BFFinger>)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);
}
}
}
}

View File

@ -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<BF.BFFingerSnapshot> _snapshots = (System.Collections.Generic.List<BF.BFFingerSnapshot>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFingerSnapshot>));
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<BF.BFFingerSnapshot> _snapshots = (System.Collections.Generic.List<BF.BFFingerSnapshot>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFingerSnapshot>));
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<BF.BFFingerSnapshot>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFingerSnapshot>));
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

File diff suppressed because it is too large Load Diff

View File

@ -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;
}
}
}

View File

@ -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<System.Collections.Generic.List<BF.BFFinger>>(L, 1))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
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<System.Collections.Generic.List<BF.BFFinger>>(L, 1))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
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<System.Collections.Generic.List<BF.BFFinger>>(L, 1))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
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<System.Collections.Generic.List<BF.BFFinger>>(L, 1))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
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<UnityEngine.Camera>(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<System.Collections.Generic.List<BF.BFFinger>>(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable<UnityEngine.Camera>(L, 3))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
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<System.Collections.Generic.List<BF.BFFinger>>(L, 1)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
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<System.Collections.Generic.List<BF.BFFinger>>(L, 1))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
var gen_ret = BF.BFGesture.GetScreenDistance( _fingers );
LuaAPI.lua_pushnumber(L, gen_ret);
return 1;
}
if(gen_param_count == 2&& translator.Assignable<System.Collections.Generic.List<BF.BFFinger>>(L, 1)&& translator.Assignable<UnityEngine.Vector2>(L, 2))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
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<System.Collections.Generic.List<BF.BFFinger>>(L, 1))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
var gen_ret = BF.BFGesture.GetLastScreenDistance( _fingers );
LuaAPI.lua_pushnumber(L, gen_ret);
return 1;
}
if(gen_param_count == 2&& translator.Assignable<System.Collections.Generic.List<BF.BFFinger>>(L, 1)&& translator.Assignable<UnityEngine.Vector2>(L, 2))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
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<System.Collections.Generic.List<BF.BFFinger>>(L, 1))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
var gen_ret = BF.BFGesture.GetStartScreenDistance( _fingers );
LuaAPI.lua_pushnumber(L, gen_ret);
return 1;
}
if(gen_param_count == 2&& translator.Assignable<System.Collections.Generic.List<BF.BFFinger>>(L, 1)&& translator.Assignable<UnityEngine.Vector2>(L, 2))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
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<System.Collections.Generic.List<BF.BFFinger>>(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
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<System.Collections.Generic.List<BF.BFFinger>>(L, 1))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
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<System.Collections.Generic.List<BF.BFFinger>>(L, 1))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
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<System.Collections.Generic.List<BF.BFFinger>>(L, 1))
{
System.Collections.Generic.List<BF.BFFinger> _fingers = (System.Collections.Generic.List<BF.BFFinger>)translator.GetObject(L, 1, typeof(System.Collections.Generic.List<BF.BFFinger>));
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!");
}
}
}

View File

@ -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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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<int> _callback = translator.GetDelegate<System.Action<int>>(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<int> _callback = translator.GetDelegate<System.Action<int>>(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<int, string> _callback = translator.GetDelegate<System.Action<int, string>>(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<System.Action<int>>(L, 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<System.Action<int>>(L, 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<System.Action<int, string>>(L, 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;
}
}
}

View File

@ -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<int, string> _callback = translator.GetDelegate<System.Action<int, string>>(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<int, string> _callback = translator.GetDelegate<System.Action<int, string>>(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<int> _callback = translator.GetDelegate<System.Action<int>>(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<int, string> _callback = translator.GetDelegate<System.Action<int, string>>(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<System.Action<int, string>>(L, 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<System.Action<int, string>>(L, 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<System.Action<int, string>>(L, 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<System.Action<int>>(L, 2);
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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<System.Collections.Generic.List<string>>(L, 2))
{
System.Collections.Generic.List<string> _languages = (System.Collections.Generic.List<string>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<string>));
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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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<object>(L, 3)))
{
string _color = LuaAPI.lua_tostring(L, 1);
string _text = LuaAPI.lua_tostring(L, 2);
object[] _par = translator.GetParams<object>(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<object>(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<object>(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<object>(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<object>(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<object>(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<object>(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;
}
}
}

View File

@ -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;
}
}
}

File diff suppressed because it is too large Load Diff

View File

@ -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;
}
}
}

File diff suppressed because it is too large Load Diff

View File

@ -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;
}
}
}

View File

@ -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!");
}
}
}

File diff suppressed because it is too large Load Diff

View File

@ -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<int, string> _callback = translator.GetDelegate<System.Action<int, string>>(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<int, string> _callback = translator.GetDelegate<System.Action<int, string>>(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<int> _callback = translator.GetDelegate<System.Action<int>>(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<int> _callback = translator.GetDelegate<System.Action<int>>(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<int, string> _callback = translator.GetDelegate<System.Action<int, string>>(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<int, string> _callback = translator.GetDelegate<System.Action<int, string>>(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<int, string> _callback = translator.GetDelegate<System.Action<int, string>>(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<System.Action<int, string>>(L, 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<System.Action<int, string>>(L, 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<System.Action<int, string>>(L, 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<System.Action<int, string>>(L, 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<System.Action<int, string>>(L, 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<System.Action<int>>(L, 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<System.Action<int>>(L, 2);
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

View File

@ -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<string, BF.BFLanguageInfo>)translator.GetObject(L, 1, typeof(System.Collections.Generic.Dictionary<string, BF.BFLanguageInfo>));
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

View File

@ -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<int, string> _callback = translator.GetDelegate<System.Action<int, string>>(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<int, string> _callback = translator.GetDelegate<System.Action<int, string>>(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<int> _callback = translator.GetDelegate<System.Action<int>>(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<int, string> _callback = translator.GetDelegate<System.Action<int, string>>(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<System.Action<int, string>>(L, 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<System.Action<int, string>>(L, 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<System.Action<int, string>>(L, 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<System.Action<int>>(L, 2);
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

View File

@ -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<int, int> _action = translator.GetDelegate<System.Action<int, int>>(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<UnityEngine.GameObject> _action = translator.GetDelegate<System.Action<UnityEngine.GameObject>>(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<bool, int> _action = translator.GetDelegate<System.Action<bool, int>>(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<float, float> _action = translator.GetDelegate<System.Action<float, float>>(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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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<int, int> _getCellIndex = translator.GetDelegate<System.Func<int, int>>(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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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<string, object> _properties = (System.Collections.Generic.Dictionary<string, object>)translator.GetObject(L, 3, typeof(System.Collections.Generic.Dictionary<string, object>));
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);
}
}
}
}

View File

@ -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<UnityEngine.Vector2>(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<UnityEngine.Vector2>(L, 2)&& translator.Assignable<UnityEngine.LayerMask>(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<BF.TouchEventType, BF.BFFinger>)translator.GetObject(L, 2, typeof(BF.BFEvent<BF.TouchEventType, BF.BFFinger>));
} 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<System.Collections.Generic.List<BF.BFFinger>>)translator.GetObject(L, 2, typeof(BF.BFEvent<System.Collections.Generic.List<BF.BFFinger>>));
} 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<BF.BFFinger>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<BF.BFFinger>));
} 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;
}
}
}

View File

@ -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<BF.SelectEventType, BF.BFFinger>)translator.GetObject(L, 2, typeof(BF.BFEvent<BF.SelectEventType, BF.BFFinger>));
} 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<System.Collections.Generic.List<BF.BFFinger>>)translator.GetObject(L, 2, typeof(BF.BFEvent<System.Collections.Generic.List<BF.BFFinger>>));
} 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;
}
}
}

View File

@ -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<System.Action>(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<System.Action>(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;
}
}
}

View File

@ -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<System.Action>(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<System.Action>(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);
}
}
}
}

View File

@ -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<System.Collections.Generic.Dictionary<string, string>>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<System.Collections.Generic.Dictionary<string, string>>));
} 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;
}
}
}

View File

@ -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<System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest>>(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4))
{
string _url = LuaAPI.lua_tostring(L, 2);
System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest> _callback = translator.GetDelegate<System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest>>(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<System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest>>(L, 3))
{
string _url = LuaAPI.lua_tostring(L, 2);
System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest> _callback = translator.GetDelegate<System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest>>(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<System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest>>(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<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest> _callback = translator.GetDelegate<System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest>>(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<System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest>>(L, 4))
{
string _url = LuaAPI.lua_tostring(L, 2);
string _fields = LuaAPI.lua_tostring(L, 3);
System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest> _callback = translator.GetDelegate<System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest>>(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<System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest>>(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<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest> _callback = translator.GetDelegate<System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest>>(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<System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest>>(L, 4))
{
string _url = LuaAPI.lua_tostring(L, 2);
string _fields = LuaAPI.lua_tostring(L, 3);
System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest> _callback = translator.GetDelegate<System.Action<BF.EDownloadCode, UnityEngine.Networking.UnityWebRequest>>(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!");
}
}
}

View File

@ -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<BestHTTP.HTTPRequest, BestHTTP.HTTPResponse> _callback = translator.GetDelegate<System.Action<BestHTTP.HTTPRequest, BestHTTP.HTTPResponse>>(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<BestHTTP.HTTPRequest, BestHTTP.HTTPResponse> _callback = translator.GetDelegate<System.Action<BestHTTP.HTTPRequest, BestHTTP.HTTPResponse>>(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<BestHTTP.HTTPRequest, BestHTTP.HTTPResponse> _callback = translator.GetDelegate<System.Action<BestHTTP.HTTPRequest, BestHTTP.HTTPResponse>>(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);
}
}
}
}

View File

@ -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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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<int> _getFunc = translator.GetDelegate<System.Action<int>>(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<System.Action<int>>(L, 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;
}
}
}

View File

@ -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<BF.GameLaunchProcessorBase>(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);
}
}
}
}

View File

@ -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;
}
}
}

View File

@ -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);
}
}
}
}

View File

@ -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<int, float, float> _func = translator.GetDelegate<System.Action<int, float, float>>(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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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<uint>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<uint>));
translator.Update(L, 1, gen_to_be_invoked);
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

View File

@ -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<BF.CharacterObjectInfo>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<BF.CharacterObjectInfo>));
} 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<BF.CharacterAnimationInfo>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<BF.CharacterAnimationInfo>));
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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<BF.CharacterSpineObjectInfo>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<BF.CharacterSpineObjectInfo>));
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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<System.Security.Cryptography.SymmetricAlgorithm>(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;
}
}
}

View File

@ -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);
}
}
}
}

View File

@ -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<string, string> _callback = translator.GetDelegate<System.Action<string, string>>(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<System.Action<string, string>>(L, 2);
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

View File

@ -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<System.Action>(L, 2);
translator.Update(L, 1, gen_to_be_invoked);
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

View File

@ -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<BF.GameLaunchProcessorBase>(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);
}
}
}
}

View File

@ -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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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<System.Action>(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);
}
}
}
}

View File

@ -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;
}
}
}

View File

@ -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<int, float, float> _func = translator.GetDelegate<System.Action<int, float, float>>(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);
}
}
}
}

View File

@ -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<BF.EmojiInfo> _emojiInfos = (System.Collections.Generic.List<BF.EmojiInfo>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<BF.EmojiInfo>));
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<UnityEngine.Vector3> _pos = (System.Collections.Generic.List<UnityEngine.Vector3>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<UnityEngine.Vector3>));
System.Collections.Generic.List<float> _uv = (System.Collections.Generic.List<float>)translator.GetObject(L, 3, typeof(System.Collections.Generic.List<float>));
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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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!");
}
}
}

View File

@ -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!");
}
}
}

View File

@ -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!");
}
}
}

View File

@ -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<BF.GameLaunchProcessorBase>(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);
}
}
}
}

View File

@ -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<BF.GameLaunchProcessorBase>(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);
}
}
}
}

View File

@ -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;
}
}
}

View File

@ -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;
}
}
}

View File

@ -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);
}
}
}
}

View File

@ -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!");
}
}
}

View File

@ -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;
}
}
}

View File

@ -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);
}
}
}
}

View File

@ -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<BF.GlobalInfo>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<BF.GlobalInfo>));
} catch(System.Exception gen_e) {
return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
}
return 0;
}
}
}

View File

@ -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;
}
}
}

Some files were not shown because too many files have changed in this diff Show More