Unity开发者联盟收藏本站
发帖教程新人必读切换到宽版

 找回密码
 立即注册
Unity开发者联盟»论坛 › 3D Dev Asset 开发资源大全 › 学术研究 Scholarly › xLua源码解析——Lua调用C#
返回列表 发新帖
查看: 360|回复: 0

xLua源码解析——Lua调用C#

[复制链接]
发表于 2024-7-15 18:49 | 显示全部楼层 |阅读模式
Lua调用C#的类，实际上是访谒类型对应的table。该table会在初度调用的时候创建。以下面的代码为例来了解整个调用流程：
  1. CS.UnityEngine.GameObject(”Test”)// 实例化go对象
复制代码
如何触发创建

CS表在LuaEnv构造函数内执行init_xlua的Lua代码时候创建的，初度调用CS.UnityEngine时候，会执行CS元表的__index方式。
  1. local metatable = {}
  2. local import_type = xlua.import_type
  4. function metatable:__index(key)
  5.     local fqn = rawget(self, '.fqn')
  6.     fqn = ((fqn and fqn .. '.') or '') .. key
  8.     local obj = import_type(fqn)
  10.     if obj == nil then
  11.         -- It might be an assembly, so we load it too.
  12.         obj = { ['.fqn'] = fqn }
  13.         setmetatable(obj, metatable)
  14.     elseif obj == true then
  15.         return rawget(self, key)
  16.     end
  18.     -- Cache this lookup
  19.     rawset(self, key, obj)
  20.     return obj
  21. end
复制代码
这时的fqn是”UnityEngine”，调用import_type(fnq)导入类型，也就是创建类型对应的table。
obj为true暗示类型创建了table，否则可能是定名空间（或者不存在），所以也创建一个类似CS的表，用于后续的查询。最后缓存obj，下次访谒就能直接获取。
import_type函数是通过LuaEnv实例化代码中的translator.OpenLib(rawL)绑定的，实际调用的是XLua.StaticLuaCallbacks.ImportType方式。
  1. [MonoPInvokeCallback(typeof(LuaCSFunction))]
  2. public static int ImportType(RealStatePtr L)
  3. {
  4.     try
  5.     {
  6.         ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
  7.         string className = LuaAPI.lua_tostring(L, 1);
  8.         Type type = translator.FindType(className);
  9.         if (type != null)
  10.         {
  11.             if (translator.GetTypeId(L, type) >= 0)
  12.             {
  13.                 LuaAPI.lua_pushboolean(L, true);
  14.             }
  15.             else
  16.             {
  17.                 return LuaAPI.luaL_error(L, ”can not load type ” + type);
  18.             }
  19.         }
  20.         else
  21.         {
  22.             LuaAPI.lua_pushnil(L);
  23.         }
  24.         return 1;
  25.     }
  26.     catch (System.Exception e)
  27.     {
  28.         return LuaAPI.luaL_error(L, ”c# exception in xlua.import_type:” + e);
  29.     }
  30. }
复制代码
translator.FindType(className)确定是否是一个类，不是则返回nil。translator.GetTypeId(L,type)查找获创建table。
接下来继续看getTypeId方式。先判断是否数组或者委托，是就直接返回对应的meta，否则就要走创建流程。
  1. internal int getTypeId(RealStatePtr L, Type type, out bool is_first, LOGLEVEL log_level = LOGLEVEL.WARN)
  2. {
  3.     int type_id;
  4.     is_first = false;
  5.     if (!typeIdMap.TryGetValue(type, out type_id)) // no reference
  6.     {
  7.         if (type.IsArray)
  8.         {
  9.             if (common_array_meta == -1) throw new Exception(”Fatal Exception! Array Metatable not inited!”);
  10.             return common_array_meta;
  11.         }
  12.         if (typeof(MulticastDelegate).IsAssignableFrom(type))
  13.         {
  14.             if (common_delegate_meta == -1) throw new Exception(”Fatal Exception! Delegate Metatable not inited!”);
  15.             TryDelayWrapLoader(L, type);
  16.             return common_delegate_meta;
  17.         }
  19.         is_first = true;
  20.         Type alias_type = null;
  21.         aliasCfg.TryGetValue(type, out alias_type);
  22.         LuaAPI.luaL_getmetatable(L, alias_type == null ? type.FullName : alias_type.FullName);
  24.         if (LuaAPI.lua_isnil(L, -1)) //no meta yet, try to use reflection meta
  25.         {
  26.             LuaAPI.lua_pop(L, 1);
  28.             if (TryDelayWrapLoader(L, alias_type == null ? type : alias_type))
  29.             {
  30.                 LuaAPI.luaL_getmetatable(L, alias_type == null ? type.FullName : alias_type.FullName);
  31.             }
  32.             else
  33.             {
  34.                 throw new Exception(”Fatal: can not load metatable of type:” + type);
  35.             }
  36.         }
  38.         //循环依赖，自身依赖本身的class，比如有个自身类型的静态readonly对象。
  39.         if (typeIdMap.TryGetValue(type, out type_id))
  40.         {
  41.             LuaAPI.lua_pop(L, 1);
  42.         }
  43.         else
  44.         {
  45.             ......
  46.             typeIdMap.Add(type, type_id);
  47.         }
  48.     }
  49.     return type_id;
  50. }
复制代码
可以看出，创建的逻辑在TryDelayWrapLoader方式。
方式先判断是通过生成代码还是反射创建：有loader函数则调用loader函数创建table，否则调用Utils.ReflectionWrap通过反射生成。下面只分析生成代码流程，反射部门直接看Utils.ReflectionWrap方式即可。
  1. public bool TryDelayWrapLoader(RealStatePtr L, Type type)
  2. {
  3.     if (loaded_types.ContainsKey(type)) return true;
  4.     loaded_types.Add(type, true);
  6.     LuaAPI.luaL_newmetatable(L, type.FullName); //先建一个metatable，因为加载过程可能会需要用到
  7.     LuaAPI.lua_pop(L, 1);
  9.     Action<RealStatePtr> loader;
  10.     int top = LuaAPI.lua_gettop(L);
  11.     if (delayWrap.TryGetValue(type, out loader))
  12.     {
  13.         delayWrap.Remove(type);
  14.         loader(L);
  15.     }
  16.     else
  17.     {
  18.         ......
  19.         Utils.ReflectionWrap(L, type, privateAccessibleFlags.Contains(type));
  20.         ......
  21.     }
  22.     ......
  24.     return true;
  25. }
复制代码
关联table创建方式

delayWrap字典实际上存的是类型的代码，就例子来说，对应的是下面的方式：
  1. public class UnityEngineGameObjectWrap
  2. {
  3.     public static void __Register(RealStatePtr L)
  4.     {
  5.         ......
  6.     }
  7. }
复制代码
这些方式都是通过XLua_Gen_Initer_Register__类注册函数放到Initer，Initer在LueEnv构造函数内调用，最终放到上面的delayWrap字典里。
  1. public class XLua_Gen_Initer_Register__
  2. {
  3.     static void wrapInit0(LuaEnv luaenv, ObjectTranslator translator)
  4.     {
  5.         ......
  6.         translator.DelayWrapLoader(typeof(UnityEngine.Debug), UnityEngineDebugWrap.__Register);
  7.         ......
  8.     }
  10.     static void Init(LuaEnv luaenv, ObjectTranslator translator)
  11.     {
  12.         wrapInit0(luaenv, translator);
  13.         ......
  14.     }
  16.     static XLua_Gen_Initer_Register__()
  17.     {
  18.         XLua.LuaEnv.AddIniter(Init);
  19.     }
  20. }
复制代码
如何创建类的table

在分析如何生成table之前，先把类的组成分成2部门：

  • 实例（对象）部门：function、field、property
  • 静态（类）部门：function、field、property
对于Lua来说，模拟function、field是没问题的，property实际上也可以拆分为getter和setter两个方式。在实例化之前，无法知道对象field的值，所以不需要考虑。那么其他部门其实都能通过Lua的元表模拟。
table的生成就是按照上面的分类进行划分，把一个类分为Object和Class两个表。此中Object只是一个元表，因为实际的Field要等实例化的时候才设置，而类的静态部门就是一个完整的表。看看UnityEngine.Debug的__register方式。
  1. // 源码有删减，每个类型注册只保留一条
  2. public class UnityEngineGameObjectWrap
  3. {
  4.     public static void __Register(RealStatePtr L)
  5.     {
  6.         ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
  7.         System.Type type = typeof(UnityEngine.GameObject);
  8.         // 动态部门
  9.         Utils.BeginObjectRegister(type, L, translator, 0, 13, 9, 3);
  10.         Utils.RegisterFunc(L, Utils.METHOD_IDX, ”GetComponent”, _m_GetComponent);
  11.         ......
  12.         Utils.RegisterFunc(L, Utils.GETTER_IDX, ”transform”, _g_get_transform);
  13.         ......
  14.         Utils.RegisterFunc(L, Utils.SETTER_IDX, ”layer”, _s_set_layer);
  15.         ......
  16.         Utils.EndObjectRegister(type, L, translator, null, null,
  17.             null, null, null);
  18.         // 静态部门
  19.         Utils.BeginClassRegister(type, L, __CreateInstance, 6, 0, 0);
  20.         Utils.RegisterFunc(L, Utils.CLS_IDX, ”Find”, _m_Find_xlua_st_);
  21.         ......
  22.         Utils.EndClassRegister(type, L, translator);
  23.     }
  24. }
复制代码
无论动态和静态部门，实际上都是3个函数调用，下面分隔静态和动态两部门进行分析。
创建静态部门table

BeginClassRegister


  • 创建cls_table、meta_table、getter_table、setter_table 4个表，
  • cls_table设置到CS.UnityEngine.Debug和CS[type]下。
  • meta_table设置为cls_table的元表
  1. public static void BeginClassRegister(Type type, RealStatePtr L, LuaCSFunction creator, int class_field_count,
  2.     int static_getter_count, int static_setter_count)
  3. {
  4.     ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
  5.     LuaAPI.lua_createtable(L, 0, class_field_count);
  6.     // cls_table[UnderlyingSystemType]=type，用于typeof方式访谒获取类型
  7.     LuaAPI.xlua_pushasciistring(L, ”UnderlyingSystemType”);
  8.     translator.PushAny(L, type);
  9.     LuaAPI.lua_rawset(L, -3);
  11.     int cls_table = LuaAPI.lua_gettop(L);
  12.     // CS.UnityEngine.Debug = cls_table
  13.     // CS[type] = cls_table
  14.     SetCSTable(L, type, cls_table);
  16.     // 创建meta_table = {__call = creator}
  17.     LuaAPI.lua_createtable(L, 0, 3);
  18.     int meta_table = LuaAPI.lua_gettop(L);
  19.     if (creator != null)
  20.     {
  21.         LuaAPI.xlua_pushasciistring(L, ”__call”);
  22.         LuaAPI.lua_pushstdcallcfunction(L, creator);
  23.         LuaAPI.lua_rawset(L, -3);
  24.     }
  25.     // getter_table = {}
  26.     if (static_getter_count == 0)
  27.     {
  28.         LuaAPI.lua_pushnil(L);
  29.     }
  30.     else
  31.     {
  32.         LuaAPI.lua_createtable(L, 0, static_getter_count);
  33.     }
  34.     // setter_table = {}
  35.     if (static_setter_count == 0)
  36.     {
  37.         LuaAPI.lua_pushnil(L);
  38.     }
  39.     else
  40.     {
  41.         LuaAPI.lua_createtable(L, 0, static_setter_count);
  42.     }
  43.     // setmetetable(cls_table, mete_table)
  44.     LuaAPI.lua_pushvalue(L, meta_table);
  45.     LuaAPI.lua_setmetatable(L, cls_table);
  46. }
复制代码
重点看SetCSTable方式，此方式把cls_table设置到CS.UnityEngine.GameObject和CS[type]下。这就是为什么能够在前面local obj = import_type(fqn)，成果为true的时，能直接rawget(self, key)得到table的原因。
  1. public static void SetCSTable(RealStatePtr L, Type type, int cls_table)
  2. {
  3.     int oldTop = LuaAPI.lua_gettop(L);
  4.     cls_table = abs_idx(oldTop, cls_table);
  5.     LuaAPI.xlua_pushasciistring(L, LuaEnv.CSHARP_NAMESPACE);
  6.     LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
  7.     // path = {`UnityEngine`, `Debug`}
  8.     List<string> path = getPathOfType(type);
  9.     // 查抄除最后一个table外的其他table是否存在，不存在则创建
  10.     for (int i = 0; i < path.Count - 1; ++i)
  11.     {
  12.         LuaAPI.xlua_pushasciistring(L, path[i]);
  13.         if (0 != LuaAPI.xlua_pgettable(L, -2))
  14.         {
  15.             var err = LuaAPI.lua_tostring(L, -1);
  16.             LuaAPI.lua_settop(L, oldTop);
  17.             throw new Exception(”SetCSTable for [” + type + ”] error: ” + err);
  18.         }
  19.         if (LuaAPI.lua_isnil(L, -1))
  20.         {
  21.             LuaAPI.lua_pop(L, 1);
  22.             LuaAPI.lua_createtable(L, 0, 0);
  23.             LuaAPI.xlua_pushasciistring(L, path[i]);
  24.             LuaAPI.lua_pushvalue(L, -2);
  25.             LuaAPI.lua_rawset(L, -4);
  26.         }
  27.         else if (!LuaAPI.lua_istable(L, -1))
  28.         {
  29.             LuaAPI.lua_settop(L, oldTop);
  30.             throw new Exception(”SetCSTable for [” + type + ”] error: ancestors is not a table!”);
  31.         }
  32.         LuaAPI.lua_remove(L, -2);
  33.     }
  34.     // 设置CS.UnityEngine.Debug = cls_table
  35.     LuaAPI.xlua_pushasciistring(L, path[path.Count - 1]);
  36.     LuaAPI.lua_pushvalue(L, cls_table);
  37.     LuaAPI.lua_rawset(L, -3);
  38.     LuaAPI.lua_pop(L, 1);
  39.     // 设置CS[type] = cls_table
  40.     LuaAPI.xlua_pushasciistring(L, LuaEnv.CSHARP_NAMESPACE);
  41.     LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
  42.     ObjectTranslatorPool.Instance.Find(L).PushAny(L, type);
  43.     LuaAPI.lua_pushvalue(L, cls_table);
  44.     LuaAPI.lua_rawset(L, -3);
  45.     LuaAPI.lua_pop(L, 1);
  46. }
复制代码
BeginClassRegister调用完毕后，数据栈上是这样的：


RegisterFunc

把方式注册到对应的表上，第二个参数就是对应表在仓库上的位置。
  1. public static void RegisterFunc(RealStatePtr L, int idx, string name, LuaCSFunction func)
  2. {
  3.     idx = abs_idx(LuaAPI.lua_gettop(L), idx);
  4.     LuaAPI.xlua_pushasciistring(L, name);
  5.     LuaAPI.lua_pushstdcallcfunction(L, func);
  6.     LuaAPI.lua_rawset(L, idx);
  7. }
复制代码
对于静态部门，idx的定义如下，也就是BeginClassRegister调用后仓库上对应表的索引：
  1. public const int CLS_IDX = -4;
  2. public const int CLS_META_IDX = -3;
  3. public const int CLS_GETTER_IDX = -2;
  4. public const int CLS_SETTER_IDX = -1;
复制代码
EndClassRegister


  • 将getter_table、cls_table、baseType、cls_indexers、nil(占位)作为upvalue创建cls_indexer闭包函数
  • 将setter_table、baseType、cls_newindexers、nil(占位)作为upvalue创建cls_newindexer闭包函数
  • meta_table[”__index”] = cls_indexer，meta_table[”__newindex”] = cls_newindexer
  • 保留到调集：LuaIndexs[type] = cls_indexer
  • 保留到调集：LuaNewIndexs[type] = cls_newindexer
  • 数据栈弹出前面的4个table。
  1. public static void EndClassRegister(Type type, RealStatePtr L, ObjectTranslator translator)
  2. {
  3.     int top = LuaAPI.lua_gettop(L);
  4.     int cls_idx = abs_idx(top, CLS_IDX);
  5.     int cls_getter_idx = abs_idx(top, CLS_GETTER_IDX);
  6.     int cls_setter_idx = abs_idx(top, CLS_SETTER_IDX);
  7.     int cls_meta_idx = abs_idx(top, CLS_META_IDX);
  9.     //begin cls index
  10.     LuaAPI.xlua_pushasciistring(L, ”__index”);
  11.     LuaAPI.lua_pushvalue(L, cls_getter_idx);// p1
  12.     LuaAPI.lua_pushvalue(L, cls_idx);// p2
  13.     translator.Push(L, type.BaseType());// p3
  14.     LuaAPI.xlua_pushasciistring(L, LuaClassIndexsFieldName);
  15.     LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);// p4
  16.     // 将p1~4和函数内部新增的p5共5个参数作为upvalue，创建闭包函数cls_indexer
  17.     LuaAPI.gen_cls_indexer(L);
  19.     // 设置cls_indexers[type] = cls_indexer
  20.     LuaAPI.xlua_pushasciistring(L, LuaClassIndexsFieldName);
  21.     LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);//store in lua indexs function tables
  22.     translator.Push(L, type);
  23.     LuaAPI.lua_pushvalue(L, -3);
  24.     LuaAPI.lua_rawset(L, -3);
  25.     LuaAPI.lua_pop(L, 1);
  26.     // 设置meta_table[__index] = cls_indexer
  27.     LuaAPI.lua_rawset(L, cls_meta_idx);
  28.     //end cls index
  30.     // newindex逻辑类似，不再此外注释
  31.     //begin cls newindex
  32.     LuaAPI.xlua_pushasciistring(L, ”__newindex”);
  33.     LuaAPI.lua_pushvalue(L, cls_setter_idx);
  34.     translator.Push(L, type.BaseType());
  35.     LuaAPI.xlua_pushasciistring(L, LuaClassNewIndexsFieldName);
  36.     LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
  37.     LuaAPI.gen_cls_newindexer(L);
  39.     LuaAPI.xlua_pushasciistring(L, LuaClassNewIndexsFieldName);
  40.     LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);//store in lua newindexs function tables
  41.     translator.Push(L, type);
  42.     LuaAPI.lua_pushvalue(L, -3);
  43.     LuaAPI.lua_rawset(L, -3);
  44.     LuaAPI.lua_pop(L, 1);
  46.     LuaAPI.lua_rawset(L, cls_meta_idx);
  47.     //end cls newindex
  49.     LuaAPI.lua_pop(L, 4);
  50. }
复制代码
这个函数的重点其实是创建出来的cls_indexer和cls_newindexer闭包函数，后续访谒类的属性或者方式，城市调用到这个函数。这里以gen_cls_indexer为例看具体实现。
  1. LUA_API int gen_obj_indexer(lua_State *L) {
  2.     lua_pushnil(L);// 第5个upvalue，用来存放基类的cls_indexer闭包函数
  3.     lua_pushcclosure(L, obj_indexer, 5);
  4.     return 0;
  5. }
  7. //upvalue --- [1]:getters, [2]:feilds, [3]:base, [4]:indexfuncs, [5]:baseindex
  8. //param   --- [1]: obj, [2]: key
  9. LUA_API int cls_indexer(lua_State *L) {
  10.     // 从getter_table中查找
  11.     if (!lua_isnil(L, lua_upvalueindex(1))) {
  12.         lua_pushvalue(L, 2);
  13.         lua_gettable(L, lua_upvalueindex(1));
  14.         if (!lua_isnil(L, -1)) {//has getter
  15.             lua_call(L, 0, 1);
  16.             return 1;
  17.         }
  18.         lua_pop(L, 1);
  19.     }
  20.     // 从cls_table中查找
  21.     if (!lua_isnil(L, lua_upvalueindex(2))) {
  22.         lua_pushvalue(L, 2);
  23.         lua_rawget(L, lua_upvalueindex(2));
  24.         if (!lua_isnil(L, -1)) {//has feild
  25.             return 1;
  26.         }
  27.         lua_pop(L, 1);
  28.     }
  29.     // 初度访谒，查找按照upvalue[3]的基类类型和upvalue[4]的cls_indexers调集，
  30.     // 查找cls_indexer闭包函数，设置到第5个upvalue的位置。然后清空upvalue[3]。
  31.     if (!lua_isnil(L, lua_upvalueindex(3))) {
  32.         lua_pushvalue(L, lua_upvalueindex(3));
  33.         while(!lua_isnil(L, -1)) {
  34.             lua_pushvalue(L, -1);
  35.             lua_gettable(L, lua_upvalueindex(4));
  36.             if (!lua_isnil(L, -1)) // found
  37.             {
  38.                 lua_replace(L, lua_upvalueindex(5)); //baseindex = indexfuncs[base]
  39.                 lua_pop(L, 1);
  40.                 break;
  41.             }
  42.             lua_pop(L, 1);
  43.             lua_getfield(L, -1, ”BaseType”);
  44.             lua_remove(L, -2);
  45.         }
  46.         lua_pushnil(L);
  47.         lua_replace(L, lua_upvalueindex(3));//base = nil
  48.     }
  49.     // 执行基类的cls_indexer闭包函数继续查找
  50.     if (!lua_isnil(L, lua_upvalueindex(5))) {
  51.         lua_settop(L, 2);
  52.         lua_pushvalue(L, lua_upvalueindex(5));
  53.         lua_insert(L, 1);
  54.         lua_call(L, 2, 1);
  55.         return 1;
  56.     } else {
  57.         lua_pushnil(L);
  58.         return 1;
  59.     }
  60. }
复制代码
gen_cls_newindexer的实现思路是一致的，具体不再赘述。
Lua模拟实现

使用Lua代码模拟类的静态部弟子成table的行为。
  1. -- BeginClassRegister
  2. local cls_table = {}
  3. local meta_table = {__call = __CreateInstance}
  4. local getter_table = {}
  5. local setter_table = {}
  6. CS.UnityEngine.Debug = cls_table
  7. CS[type] = cls_table
  8. setmetatable(cls_table, meta_table)
  10. -- RegisterFunc 只模拟一条
  11. cls_table[”Find”] = _m_Find_xlua_st_
  13. -- EndClassRegister
  14. local clsIndexer = gen_cls_indexer()
  15. local clsNewIndexer = gen_cls_newindexer()
  16. meta_table[”__index”] = clsIndexer
  17. meta_table[”__newindex”] = clsNewIndexer
  18. register[”LuaClassIndexs”][type] = clsIndexer
  19. register[”LuaClassNewIndexs”][type] = clsNewIndexer
复制代码
创建动态部门table

动态部门的创建逻辑与静态部门长短常接近的，斗劲大的差异是，动态部门table是一个元表，在实例化的时候设置为对象的元表。下面主要通过注释说明，最后结合Lua模拟代码去理解。
BeginObjectRegister

创建meta、method、getter、setter四个元表放在数据栈上：
  1. //meta: -4, method:-3, getter: -2, setter: -1
  2. public static void BeginObjectRegister(Type type, RealStatePtr L, ObjectTranslator translator, int meta_count, int method_count, int getter_count,
  3.     int setter_count, int type_id = -1)
  4. {
  5.     if (type == null)
  6.     {
  7.         if (type_id == -1) throw new Exception(”Fatal: must provide a type of type_id”);
  8.         LuaAPI.xlua_rawgeti(L, LuaIndexes.LUA_REGISTRYINDEX, type_id);
  9.     }
  10.     else
  11.     {
  12.         // 按照类型名获取元表meta_table，没有就创建一个放栈上
  13.         LuaAPI.luaL_getmetatable(L, type.FullName);
  14.         if (LuaAPI.lua_isnil(L, -1))
  15.         {
  16.             LuaAPI.lua_pop(L, 1);
  17.             LuaAPI.luaL_newmetatable(L, type.FullName);
  18.         }
  19.     }
  20.     // 设置标识，meta_table[0] = 1
  21.     LuaAPI.lua_pushlightuserdata(L, LuaAPI.xlua_tag());
  22.     LuaAPI.lua_pushnumber(L, 1);
  23.     LuaAPI.lua_rawset(L, -3);
  25.     if ((type == null || !translator.HasCustomOp(type)) && type != typeof(decimal))
  26.     {
  27.         LuaAPI.xlua_pushasciistring(L, ”__gc”);
  28.         LuaAPI.lua_pushstdcallcfunction(L, translator.metaFunctions.GcMeta);
  29.         LuaAPI.lua_rawset(L, -3);
  30.     }
  31.     // meta_table[__tostring] = translator.metaFunctions.ToStringMeta
  32.     LuaAPI.xlua_pushasciistring(L, ”__tostring”);
  33.     LuaAPI.lua_pushstdcallcfunction(L, translator.metaFunctions.ToStringMeta);
  34.     LuaAPI.lua_rawset(L, -3);
  36.     // 创建method_table放到数据栈上，没有也放nil占位
  37.     if (method_count == 0)
  38.     {
  39.         LuaAPI.lua_pushnil(L);
  40.     }
  41.     else
  42.     {
  43.         LuaAPI.lua_createtable(L, 0, method_count);
  44.     }
  45.     // 创建getter_table放到数据栈上，没有也放nil占位
  46.     if (getter_count == 0)
  47.     {
  48.         LuaAPI.lua_pushnil(L);
  49.     }
  50.     else
  51.     {
  52.         LuaAPI.lua_createtable(L, 0, getter_count);
  53.     }
  54.     // 创建getter_table放到数据栈上，没有也放nil占位
  55.     if (setter_count == 0)
  56.     {
  57.         LuaAPI.lua_pushnil(L);
  58.     }
  59.     else
  60.     {
  61.         LuaAPI.lua_createtable(L, 0, setter_count);
  62.     }
  63. }
复制代码
BeginObjectRegister调用后，4个表在数据栈上的位置就是：


RegisterFunc

和静态部门独一的差异，idx的定义变为：
  1. public const int OBJ_META_IDX = -4;
  2. public const int METHOD_IDX = -3;
  3. public const int GETTER_IDX = -2;
  4. public const int SETTER_IDX = -1;
复制代码
EndObjectRegister

创建obj_indexer和obj_newindexer闭包函数，设置meta_table的__index和__newindex。将包罗method_table、getter_table、setter_table等参数作为闭包函数的upvalue被使用。然后缓存两个闭包函数到注册表下对应的子表。最后弹出BeginObjectRegister创建的4个table。具体看源码：
  1. public static void EndObjectRegister(Type type, RealStatePtr L, ObjectTranslator translator, LuaCSFunction csIndexer,
  2.     LuaCSFunction csNewIndexer, Type base_type, LuaCSFunction arrayIndexer, LuaCSFunction arrayNewIndexer)
  3. {
  4.     int top = LuaAPI.lua_gettop(L);
  5.     int meta_idx = abs_idx(top, OBJ_META_IDX);
  6.     int method_idx = abs_idx(top, METHOD_IDX);
  7.     int getter_idx = abs_idx(top, GETTER_IDX);
  8.     int setter_idx = abs_idx(top, SETTER_IDX);
  10.     //begin index gen
  11.     LuaAPI.xlua_pushasciistring(L, ”__index”);
  12.     LuaAPI.lua_pushvalue(L, method_idx);// 参数1
  13.     LuaAPI.lua_pushvalue(L, getter_idx);// 参数2
  15.     // 参数3
  16.     if (csIndexer == null)
  17.     {
  18.         LuaAPI.lua_pushnil(L);
  19.     }
  20.     else
  21.     {
  22.         LuaAPI.lua_pushstdcallcfunction(L, csIndexer);
  23.     }
  24.     // 参数4
  25.     translator.Push(L, type == null ? base_type : type.BaseType());
  26.     // 参数5
  27.     LuaAPI.xlua_pushasciistring(L, LuaIndexsFieldName);
  28.     LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
  29.     // 参数6
  30.     if (arrayIndexer == null)
  31.     {
  32.         LuaAPI.lua_pushnil(L);
  33.     }
  34.     else
  35.     {
  36.         LuaAPI.lua_pushstdcallcfunction(L, arrayIndexer);
  37.     }
  38.     // 将上面6个参数 + 内部1个参数作为upvalue创建闭包函数
  39.     LuaAPI.gen_obj_indexer(L);
  41.     // register[LuaIndexsFieldName][type]=obj_indexer
  42.     if (type != null)
  43.     {
  44.         LuaAPI.xlua_pushasciistring(L, LuaIndexsFieldName);
  45.         LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);//store in lua indexs function tables
  46.         translator.Push(L, type);
  47.         LuaAPI.lua_pushvalue(L, -3);
  48.         LuaAPI.lua_rawset(L, -3);
  49.         LuaAPI.lua_pop(L, 1);
  50.     }
  52.     LuaAPI.lua_rawset(L, meta_idx);
  53.     //end index gen
  55.     //begin newindex gen
  56.     LuaAPI.xlua_pushasciistring(L, ”__newindex”);
  57.     LuaAPI.lua_pushvalue(L, setter_idx);
  59.     if (csNewIndexer == null)
  60.     {
  61.         LuaAPI.lua_pushnil(L);
  62.     }
  63.     else
  64.     {
  65.         LuaAPI.lua_pushstdcallcfunction(L, csNewIndexer);
  66.     }
  68.     translator.Push(L, type == null ? base_type : type.BaseType());
  70.     LuaAPI.xlua_pushasciistring(L, LuaNewIndexsFieldName);
  71.     LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);
  73.     if (arrayNewIndexer == null)
  74.     {
  75.         LuaAPI.lua_pushnil(L);
  76.     }
  77.     else
  78.     {
  79.         LuaAPI.lua_pushstdcallcfunction(L, arrayNewIndexer);
  80.     }
  82.     LuaAPI.gen_obj_newindexer(L);
  84.     // register[LuaNewIndexsFieldName][type] = obj_newindexer
  85.     if (type != null)
  86.     {
  87.         LuaAPI.xlua_pushasciistring(L, LuaNewIndexsFieldName);
  88.         LuaAPI.lua_rawget(L, LuaIndexes.LUA_REGISTRYINDEX);//store in lua newindexs function tables
  89.         translator.Push(L, type);
  90.         LuaAPI.lua_pushvalue(L, -3);
  91.         LuaAPI.lua_rawset(L, -3);
  92.         LuaAPI.lua_pop(L, 1);
  93.     }
  95.     LuaAPI.lua_rawset(L, meta_idx);
  96.     //end new index gen
  97.     LuaAPI.lua_pop(L, 4);
  98. }
复制代码
看看gen_obj_indexer的实现：
  1. //upvalue --- [1]: methods, [2]:getters, [3]:csindexer, [4]:base,
  2. //            [5]:indexfuncs, [6]:arrayindexer, [7]:baseindex
  3. //param   --- [1]: obj, [2]: key
  4. LUA_API int obj_indexer(lua_State *L) {   
  5.     // method有没有?
  6.     if (!lua_isnil(L, lua_upvalueindex(1))) {
  7.         lua_pushvalue(L, 2);
  8.         lua_gettable(L, lua_upvalueindex(1));
  9.         if (!lua_isnil(L, -1)) {//has method
  10.             return 1;
  11.         }
  12.         lua_pop(L, 1);
  13.     }
  14.     // getter有没有？
  15.     if (!lua_isnil(L, lua_upvalueindex(2))) {
  16.         lua_pushvalue(L, 2);
  17.         lua_gettable(L, lua_upvalueindex(2));
  18.         if (!lua_isnil(L, -1)) {//has getter
  19.             lua_pushvalue(L, 1);
  20.             lua_call(L, 1, 1);
  21.             return 1;
  22.         }
  23.         lua_pop(L, 1);
  24.     }
  26.     // arrayindexer方式存在，而且key是number，则调用arrayIndexer方式
  27.     if (!lua_isnil(L, lua_upvalueindex(6)) && lua_type(L, 2) == LUA_TNUMBER) {
  28.         lua_pushvalue(L, lua_upvalueindex(6));
  29.         lua_pushvalue(L, 1);
  30.         lua_pushvalue(L, 2);
  31.         lua_call(L, 2, 1);
  32.         return 1;
  33.     }
  34.     // csindexer存在，则调用方式看能否获取
  35.     if (!lua_isnil(L, lua_upvalueindex(3))) {
  36.         lua_pushvalue(L, lua_upvalueindex(3));
  37.         lua_pushvalue(L, 1);
  38.         lua_pushvalue(L, 2);
  39.         lua_call(L, 2, 2);
  40.         if (lua_toboolean(L, -2)) {
  41.             return 1;
  42.         }
  43.         lua_pop(L, 2);
  44.     }
  45.     // 如果有父类，则找到父类的obj_indexer函数，设置到第7个upvalue的位置，然后把自身置空。
  46.     // 可以理解为只是一个延迟设置基类obj_indexer的逻辑。
  47.     if (!lua_isnil(L, lua_upvalueindex(4))) {
  48.         lua_pushvalue(L, lua_upvalueindex(4));
  49.         while(!lua_isnil(L, -1)) {
  50.             lua_pushvalue(L, -1);
  51.             lua_gettable(L, lua_upvalueindex(5));
  52.             if (!lua_isnil(L, -1)) // found
  53.             {
  54.                 lua_replace(L, lua_upvalueindex(7)); //baseindex = indexfuncs[base]
  55.                 lua_pop(L, 1);
  56.                 break;
  57.             }
  58.             // 没找到则继续找父类的父类
  59.             lua_pop(L, 1);
  60.             lua_getfield(L, -1, ”BaseType”);
  61.             lua_remove(L, -2);
  62.         }
  63.         lua_pushnil(L);
  64.         lua_replace(L, lua_upvalueindex(4));//base = nil
  65.     }
  66.     // 调用父类的obj_indexer方式查找
  67.     if (!lua_isnil(L, lua_upvalueindex(7))) {
  68.         lua_settop(L, 2);
  69.         lua_pushvalue(L, lua_upvalueindex(7));
  70.         lua_insert(L, 1);
  71.         lua_call(L, 2, 1);
  72.         return 1;
  73.     } else {
  74.         return 0;
  75.     }
  76. }
复制代码
obj_newindexer和obj_indexer逻辑一样，这里不再赘述。
Lua模拟实现
  1. -- 1.BeginObjectRegister
  2. local meta_table = register[type.FullName] = {}
  3. mete_table[0] = 1
  4. mete_table[”__string”] = translator.metaFunctions.ToStringMeta
  5. local method_table = {}
  6. local getter_table = {}
  7. local setter_table = {}
  9. -- 2.RegisterFunc 只展示一条，其他表同样措置
  10. method_table[”GetComponent”] = _m_GetComponent
  12. -- 3.EndObjectRegister 只模拟index，newindex逻辑一样
  13. local obj_indexer = gen_obj_indexer()
  14. local obj_newindexer = gen_obj_newindexer()
  15. meta_table[”__index”] = obj_indexer
  16. mete_table[”__newindex”] = obj_newindexer
  17. register[”LuaIndexs”][type] = obj_indexer
  18. register[”LuaNewIndexs”][type] = obj_newindexer
复制代码
至此，一个C#类转换为table的流程就跑完了。
indexer和newindexer调集

看了上面的分析，能发现类创建table时生成的所有indexer和newindexer城市放入注册表register的4个字典里面缓存起来。后续可以通过类型type查找。
  1. // cs对象__index和__newindex表
  2. string LuaIndexsFieldName = ”LuaIndexs”;
  3. string LuaNewIndexsFieldName = ”LuaNewIndexs”;
  4. // cs类__index和__newindex表
  5. string LuaClassIndexsFieldName = ”LuaClassIndexs”;
  6. string LuaClassNewIndexsFieldName = ”LuaClassNewIndexs”;
  8. // 示例：
  9. // register[LuaIndexsFieldName][type] = obj_indexer
  10. // type是cs的Type类型，obj_indexer是闭包函数
复制代码
实例化对象

实例化GameObject对象，在Lua中实际上是调用元表的__call方式。
上面创建静态部门，就是生成的__CreateInstance作为BeginClassRegister的creater参数设置到元表的__call方式。
__CreateInstance方式就是按照参数的个数调用C#层的实例化逻辑。
  1. static int __CreateInstance(RealStatePtr L)
  2. {
  3.     try
  4.     {
  5.         ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
  6.         // 2个参数？
  7.         if (LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING))
  8.         {
  9.             string _name = LuaAPI.lua_tostring(L, 2);
  10.             var gen_ret = new UnityEngine.GameObject(_name);
  11.             translator.Push(L, gen_ret);
  12.             return 1;
  13.         }
  14.         // 1个参数？
  15.         if (LuaAPI.lua_gettop(L) == 1)
  16.         {
  17.             var gen_ret = new UnityEngine.GameObject();
  18.             translator.Push(L, gen_ret);
  19.             return 1;
  20.         }
  21.         // 大于2个参数？
  22.         if (LuaAPI.lua_gettop(L) >= 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING) && (LuaTypes.LUA_TNONE == LuaAPI.lua_type(L, 3) || translator.Assignable<System.Type>(L, 3)))
  23.         {
  24.             string _name = LuaAPI.lua_tostring(L, 2);
  25.             System.Type[] _components = translator.GetParams<System.Type>(L, 3);
  26.             var gen_ret = new UnityEngine.GameObject(_name, _components);
  27.             translator.Push(L, gen_ret);
  28.             return 1;
  29.         }
  30.     }
  31.     catch (System.Exception gen_e)
  32.     {
  33.         return LuaAPI.luaL_error(L, ”c# exception:” + gen_e);
  34.     }
  35.     return LuaAPI.luaL_error(L, ”invalid arguments to UnityEngine.GameObject constructor!”);
  36. }
复制代码
实例化C#对象后，需要创建userdata持有对象，并按照type找到前面创建的元表，把元表设置为userdata的元表。这部门逻辑在translator.Push内。
  1. public void Push(RealStatePtr L, object o)
  2. {
  3.     if (o == null)
  4.     {
  5.         LuaAPI.lua_pushnil(L);
  6.         return;
  7.     }
  9.     int index = -1;
  10.     Type type = o.GetType();
  11. #if !UNITY_WSA || UNITY_EDITOR
  12.     bool is_enum = type.IsEnum;
  13.     bool is_valuetype = type.IsValueType;
  14. #else
  15.     bool is_enum = type.GetTypeInfo().IsEnum;
  16.     bool is_valuetype = type.GetTypeInfo().IsValueType;
  17. #endif
  18.     bool needcache = !is_valuetype || is_enum;// 引用类型和枚举需要缓存
  19.     if (needcache && (is_enum ? enumMap.TryGetValue(o, out index) : reverseMap.TryGetValue(o, out index)))
  20.     {
  21.         if (LuaAPI.xlua_tryget_cachedud(L, index, cacheRef) == 1)
  22.         {
  23.             return;
  24.         }
  25.         //这里实在太经典了，weaktable先删除，然后GC会延迟调用，当index会循环操作的时候，不注释这行将会导致反复释放
  26.         //collectObject(index);
  27.     }
  29.     bool is_first;
  30.     int type_id = getTypeId(L, type, out is_first);
  32.     //如果一个type的定义含本身静态readonly实例时，getTypeId会push一个实例，这时候应该用这个实例
  33.     if (is_first && needcache && (is_enum ? enumMap.TryGetValue(o, out index) : reverseMap.TryGetValue(o, out index)))
  34.     {
  35.         if (LuaAPI.xlua_tryget_cachedud(L, index, cacheRef) == 1)
  36.         {
  37.             return;
  38.         }
  39.     }
  41.     index = addObject(o, is_valuetype, is_enum);
  42.     LuaAPI.xlua_pushcsobj(L, index, type_id, needcache, cacheRef);
  43. }
复制代码
前面判断了引用类型和枚举是否有缓存，有就从缓存获取即可，否则就通过type获取type_id。这个getTypeId的方式就是前面Lua访谒C#时，查抄或者创建table的方式。
addObject方式很简单，但是很重要，Lua用到的C#对象，要不被回收，就是在这放入了objects对象表，并返回索引index。
  1. int addObject(object obj, bool is_valuetype, bool is_enum)
  2. {
  3.     int index = objects.Add(obj);
  4.     if (is_enum)
  5.     {
  6.         enumMap[obj] = index;
  7.     }
  8.     else if (!is_valuetype)
  9.     {
  10.         reverseMap[obj] = index;
  11.     }
  12.     return index;
  13. }
复制代码
最后就是调用c实现的的xlua_pushcsobj方式，最后一个调用参数cacheRef是什么值？
在ObjectTranslator构造函数内，创建了一个弱value的Lua表，通过luaL_ref方式保留在注册表register下，cacheRef就保留了这个索引。也就是说，通过这个值，能够在注册表register下找到这个表。
  1. #define lua_newuserdata(L,s)    lua_newuserdatauv(L,s,1)
  3. LUA_API void xlua_pushcsobj(lua_State *L, int key, int meta_ref, int need_cache, int cache_ref) {
  4.     // 创建userdata，返回的是userdata memory块的指针，宏内设置memory块大小就是1个int
  5.     int* pointer = (int*)lua_newuserdata(L, sizeof(int));
  6.     *pointer = key;
  7.     // 把userdata缓存到cache_ref表中
  8.     if (need_cache) cacheud(L, key, cache_ref);
  9.     // 获取类型对应的元表
  10.     lua_rawgeti(L, LUA_REGISTRYINDEX, meta_ref);
  11.     // 设置userdata的元表
  12.     lua_setmetatable(L, -2);
  13. }
  15. static void cacheud(lua_State *L, int key, int cache_ref) {
  16.     lua_rawgeti(L, LUA_REGISTRYINDEX, cache_ref);
  17.     lua_pushvalue(L, -2);// push userdata
  18.     lua_rawseti(L, -2, key);// cache_ref[key] = userdata
  19.     lua_pop(L, 1);// pop cache_ref
  20. }
复制代码
至此，数据栈的栈顶就是GameObject实例的userdata。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

×
回复

使用道具 举报

返回列表 发新帖
懒得打字嘛，点击右侧快捷回复 【右侧内容，后台自定义】
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|手机版|Unity开发者联盟 ( 粤ICP备20003399号 )

GMT+8, 2024-12-4 01:29 , Processed in 0.106222 second(s), 27 queries .

Powered by Discuz! X3.5 Licensed

© 2001-2024 Discuz! Team.

快速回复 返回顶部 返回列表