Lua热更新框架差异

// UnityEngineVector3Wrap.cs Vector3构造函数
static int __CreateInstance(RealStatePtr L){
    ...
    float _x = (float)LuaAPI.lua_tonumber(L, 2);
    float _y = (float)LuaAPI.lua_tonumber(L, 3);
    float _z = (float)LuaAPI.lua_tonumber(L, 4);
                        
    UnityEngine.Vector3 gen_ret = new UnityEngine.Vector3(_x, _y, _z);
    translator.PushUnityEngineVector3(L, gen_ret);
    ...
}

//WrapPusher.cs  userdata
 void PushUnityEngineVector3(RealStatePtr L, UnityEngine.Vector3 val){
    IntPtr buff = LuaAPI.xlua_pushstruct(L, 12, UnityEngineVector3_TypeID);
    CopyByValue.Pack(buff, 0, val)
}

//PackUnPack.cs userdata
bool Pack(IntPtr buff, int offset, UnityEngine.Vector3 field){
    if(!LuaAPI.xlua_pack_float3(buff, offset, field.x, field.y, field.z)){
        return false;
    }     
    return true;
}

static int _s_set_x(RealStatePtr L){
    ...   
    UnityEngine.Vector3 gen_to_be_invoked;
    translator.Get(L, 1, out gen_to_be_invoked);
    gen_to_be_invoked.x = (float)LuaAPI.lua_tonumber(L, 2);      
    translator.UpdateUnityEngineVector3(L, 1, gen_to_be_invoked);
    ...  
}

//WrapPusher.cs  userdata
void UpdateUnityEngineVector3(RealStatePtr L, int index, UnityEngine.Vector3 val){
    IntPtr buff = LuaAPI.lua_touserdata(L, index);
    CopyByValue.Pack(buff, 0,  val);
}

//PackUnPack.cs  userdata
bool Pack(IntPtr buff, int offset, UnityEngine.Vector3 field){
    if(!LuaAPI.xlua_pack_float3(buff, offset, field.x, field.y, field.z)){
        return false;
    }     
    return true;
}

// UnityEngineVector3Wrap.cs
static int _s_set_position(RealStatePtr L){
    UnityEngine.Transform gen_to_be_invoked = (UnityEngine.Transform)translator.FastGetCSObj(L, 1);
    UnityEngine.Vector3 gen_value;
    translator.Get(L, 2, out gen_value);
    gen_to_be_invoked.position = gen_value;
}

//WrapPusher.cs 判断是userdata还是table
public void Get(RealStatePtr L, int index, out UnityEngine.Vector3 val)
{
    LuaTypes type = LuaAPI.lua_type(L, index);
    if (type == LuaTypes.LUA_TUSERDATA )
    {
	    if (LuaAPI.xlua_gettypeid(L, index) != UnityEngineVector3_TypeID)
		{
		    throw new Exception("invalid userdata for UnityEngine.Vector3");
		}
		
        IntPtr buff = LuaAPI.lua_touserdata(L, index);
        if (!CopyByValue.UnPack(buff, 0, out val))
        {
            throw new Exception("unpack fail for UnityEngine.Vector3");
        }
    }
    else if (type ==LuaTypes.LUA_TTABLE)
    {
	    CopyByValue.UnPack(this, L, index, out val);
    }
    else
    {
        val = (UnityEngine.Vector3)objectCasters.GetCaster(typeof(UnityEngine.Vector3))(L, index, null);
    }
}

//userdata
 public static bool UnPack(IntPtr buff, int offset, out UnityEngine.Vector3 field)
 {
     field = default(UnityEngine.Vector3);
    
     float x = default(float);
     float y = default(float);
     float z = default(float);
    
     if(!LuaAPI.xlua_unpack_float3(buff, offset, out x, out y, out z))
     {
         return false;
     }
     field.x = x;
     field.y = y;
     field.z = z;
    
    
     return true;
 }

//table
public static void UnPack(ObjectTranslator translator, RealStatePtr L, int idx, out UnityEngine.Vector3 val){
    val = new UnityEngine.Vector3();
    int top = LuaAPI.lua_gettop(L);

    if (Utils.LoadField(L, idx, "x")){
        translator.Get(L, top + 1, out val.x);
    }
    LuaAPI.lua_pop(L, 1);

    if (Utils.LoadField(L, idx, "y")){
        translator.Get(L, top + 1, out val.y);
    }
    LuaAPI.lua_pop(L, 1);

    if (Utils.LoadField(L, idx, "z")){
        translator.Get(L, top + 1, out val.z);
    }
    LuaAPI.lua_pop(L, 1);	
}

//table
public static bool LoadField(RealStatePtr L, int idx, string field_name)
{
    idx = idx > 0 ? idx : LuaAPI.lua_gettop(L) + idx + 1;// abs of index
    LuaAPI.xlua_pushasciistring(L, field_name);
    LuaAPI.lua_rawget(L, idx);
    return !LuaAPI.lua_isnil(L, -1);
}

//ReImplementInLua.cs--table
[GCOptimize(OptimizeFlag.PackAsTable)]
public struct PushAsTableStruct
{
    public int x;
    public int y;
}

//NoGc.cs -- userdata
[GCOptimize]
[LuaCallCSharp]
 public struct MyStruct
{
    public MyStruct(int p1, int p2)
    {
        a = p1;
        b = p2;
        c = p2;
        e.c = (byte)p1;
    }
    public int a;
    public int b;
    public decimal c;
    public Pedding e;
}

//UnityEngineGameObjectWrap.cs
 static int _g_get_transform(RealStatePtr L){
    try {
        ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
        //通过id(udata)在ObjectTranslator.objects(对象池Array)取c#对象，有boxing（装箱）行为
        UnityEngine.GameObject gen_to_be_invoked = (UnityEngine.GameObject)translator.FastGetCSObj(L, 1);
        //Push做了二步工作：
        //1.把transform push到objects中
        //2.transform对象id通过xlua_pushcsobj push到userdata
        translator.Push(L, gen_to_be_invoked.transform);
    } catch(System.Exception gen_e) {
        return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
    }
    return 1;
}
//ObjectTranslator.cs
internal object FastGetCSObj(RealStatePtr L,int index){
    return getCsObj(L, index, LuaAPI.xlua_tocsobj_fast(L,index));
}

/*xlua.c*/
/*通过userdata拿id*/
LUA_API int xlua_tocsobj_fast (lua_State *L,int index) {
	int *udata = (int *)lua_touserdata (L,index);

	if(udata!=NULL) 
		return *udata;
	return -1;
}

LUA_API void xlua_pushcsobj(lua_State *L, int key, int meta_ref, int need_cache, int cache_ref) {
	int* pointer = (int*)lua_newuserdata(L, sizeof(int));
	*pointer = key;
	
	if (need_cache) cacheud(L, key, cache_ref);

    lua_rawgeti(L, LUA_REGISTRYINDEX, meta_ref);//t[n] 的值压栈,t 是指索引LUA_REGISTRYINDEX的表

	lua_setmetatable(L, -2);
}

--lua
xxx:TestFunc(2008)

//c#函数
public void TestFunc(int i)
{
}

//按规则包装一个函数给C 
[UnmanagedFunctionPointer(CallingConvention.Cdecl)]
public delegate int lua_CSFunction(IntPtr L);
[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int _m_TestFunc(RealStatePtr L)
 {
    ....
    //函数参数：出栈取值   
    int _i = LuaAPI.xlua_tointeger(L, 2);
    //c#函数调用
    gen_to_be_invoked.TestFunc( _i );
    //返回值处理
    ...
    //返回值个数
    return 0;
    ....
 }

//注册函数,这样非托管代码就可以反向调用托管代码了
LuaAPI.xlua_pushasciistring(L, name);
IntPtr fn = Marshal.GetFunctionPointerForDelegate(function);
/*lua_pushcfunction*/
xlua_push_csharp_function(L, fn, n);
LuaAPI.lua_rawset(L, idx);

//c#
luaenv.Global.Get<int>("money")

lua_pushstring(L,"money")
lua_gettable(L,-2)
xlua_tointeger(L,-1);

--lua
function f(a, b)
    print('a', a, 'b', b)
    return 1, {f1 = 1024}
end

//用例CSCallLua.cs
[CSharpCallLua]
public delegate int FDelegate(int a, string b, out DClass c);

//在DelegatesGensBridge.cs里生成映射参数关系,调用大致做下面三个步骤
public int __Gen_Delegate_Imp13(int p0, string p1, out CSCallLua.DClass p2)
{
....
LuaAPI.xlua_pushXXX //参数处理
LuaAPI.lua_pcall //lua函数执行
LuaAPI.xlua_toXXX //返回值处理
....
}

//Lua_UnityEngine_Vector3.cs
static public int constructor(IntPtr l) {
    ...
    System.Single a1;
    checkType(l,2,out a1);
    System.Single a2;
    checkType(l,3,out a2);
    System.Single a3;
    checkType(l,4,out a3);
    o=new UnityEngine.Vector3(a1,a2,a3);
    pushValue(l,true);//lua_pushboolean 
    pushValue(l,o);//luaS_pushVector3
    ...
}

/*slua.c*/
LUA_API void luaS_pushVector3(lua_State *L, float x, float y, float z) {
	lua_newtable(L);
	lua_pushnumber(L, x);
	lua_rawseti(L, -2, 1);
	lua_pushnumber(L, y);
	lua_rawseti(L, -2, 2);
	lua_pushnumber(L, z);
	lua_rawseti(L, -2, 3);
	setmetatable(L, -2, MT_VEC3);
}

static public int get_transform(IntPtr l) {
    UnityEngine.GameObject self=(UnityEngine.GameObject)checkSelf(l);//c#映射表取
    pushValue(l,true);
    /*
    1.push到c#映射表 
    2.luaS_pushobject push映射到lua侧userdata
    */
    pushValue(l,self.transform);
    return 2;
}

/*slua.c*/
LUA_API int luaS_pushobject(lua_State *l, int index, const char* t, int gco, int cref) {

	int is_reflect = 0;

	luaS_newuserdata(l, index);
	if (gco) cacheud(l, index, cref);


	luaL_getmetatable(l, t);//t对应的原表入栈
	if (lua_isnil(l, -1))
	{
		lua_pop(l, 1);
		luaL_getmetatable(l, "LuaVarObject");
		is_reflect = 1;
	}

	lua_setmetatable(l, -2);
	return is_reflect;
}

//Deleg.cs
public static void testAction(Action<int, string> f)
{
	f(1998, "bob");
}

//
private SLua.LuaFunction _AppQuitCallback;
public void SetQuitCallback(SLua.LuaFunction func)
{
	_AppQuitCallback = func;
}

_AppQuitCallback.call();


LuaSvr.mainState.getFunction("foo").call(1, 2, 3)

[CustomLuaClass]
public delegate void GetMoneyDelegate(int x,int y);
GetMoneyDelegate ud;

LuaFunction getFunction;
getMoney = getFunction.cast<GetMoneyDelegate>();//实现不够简练
if (getMoney != null) getMoney(1,2);

[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int set_position(IntPtr L)
{
	object o = null;
	try
	{
		o = ToLua.ToObject(L, 1);
		UnityEngine.Transform obj = (UnityEngine.Transform)o;
		UnityEngine.Vector3 arg0 = ToLua.ToVector3(L, 2);
		obj.position = arg0;
		return 0;
	}
	catch(Exception e)
	{
		return LuaDLL.toluaL_exception(L, e, o, "attempt to index position on a nil value");
	}
}

public static Vector3 ToVector3(IntPtr L, int stackPos)
{
    float x = 0, y = 0, z = 0;
    LuaDLL.tolua_getvec3(L, stackPos, out x, out y, out z);
    return new Vector3(x, y, z);
}

//CallLuaFunction.cs
function luaFunc(num)                        
    return num + 1
end

test = {}
test.luaFunc = luaFunc

//映射了函数参数和返回值类型
luaFunc = lua.GetFunction("test.luaFunc");
int num = luaFunc.Invoke<int, int>(123456);
public R1 Invoke<T1, R1>(T1 arg1)
{
    BeginPCall();
    PushGeneric(arg1);//通用push
    PCall();
    R1 ret1 = CheckValue<R1>();
    EndPCall();
    return ret1;
}

//c# 直接硬编码方式调用，简化PushGeneric内部查找操作,榨干最后一丝性能
num = CallFunc();
int CallFunc(int value)
{        
        luaFunc.BeginPCall();                
        luaFunc.Push(value);
        luaFunc.PCall();        
        int num = (int)luaFunc.CheckNumber();
        luaFunc.EndPCall();
        return num;                
}
num = CallFunc();

//UIControlWrap.cs 对象交互完全是 int 传递
public static void SetActive(int wndHandle, int ctrlHandle, bool active)
{
     GameObject ctrl = GameWindow.GetWindowControl(wndHandle, ctrlHandle);
     if (ctrl == null || ctrl.activeSelf == active) return;
     if (ctrl.activeSelf != active)
     {
         ctrl.SetActive(active);
     }
}

//UIControlWrap.cs 这里设置对象属性Vector3，只是传递二个float。
//对象transform访问完全是在c#侧直接操作，很大程度提升性能。
public static void SetWorldPositionXY(int wndHandle, int ctrlHandle, float x, float y)
{
        GameObject ctrl = GameWindow.GetWindowControl(wndHandle, ctrlHandle);
        if (ctrl == null) return;
        //上面三个框架分析可知lua侧做这个操作代价有多高
        Vector3 pos = ctrl.transform.position;
        pos.x = x;
        pos.y = y;
        ctrl.transform.position = pos;
}