Lua委托

TestDelegate.cs

  1.     using UnityEngine;
  2.     using System;
  3.     using System.Collections.Generic;
  4.     using LuaInterface;
  7.     public class TestDelegate: MonoBehaviour
  8.     {
  9.         private string script =
  10.         @"                              
  11.                 function DoClick1(go)                
  12.                     print('click1 gameObject is '..go.name)                    
  13.                 end
  15.                 function DoClick2(go)                
  16.                     print('click2 gameObject is '..go.name)                              
  17.                 end                       
  19.                 function AddClick1(listener)       
  20.                     if listener.onClick then
  21.                         listener.onClick = listener.onClick + DoClick1                                                    
  22.                     else
  23.                         listener.onClick = DoClick1                      
  24.                     end                
  25.                 end
  27.                 function AddClick2(listener)
  28.                     if listener.onClick then
  29.                         listener.onClick = listener.onClick + DoClick2                      
  30.                     else
  31.                         listener.onClick = DoClick2
  32.                     end                
  33.                 end
  35.                 function SetClick1(listener)
  36.                     if listener.onClick then
  37.                         listener.onClick:Destroy()
  38.                     end
  40.                     listener.onClick = DoClick1         
  41.                 end
  43.                 function RemoveClick1(listener)
  44.                     if listener.onClick then
  45.                         listener.onClick = listener.onClick - DoClick1      
  46.                     else
  47.                         print('empty delegate')
  48.                     end
  49.                 end
  51.                 function RemoveClick2(listener)
  52.                     if listener.onClick then
  53.                         listener.onClick = listener.onClick - DoClick2    
  54.                     else
  55.                         print('empty delegate')                                
  56.                     end
  57.                 end
  59.                 --测试重载问题
  60.                 function TestOverride(listener)
  61.                     listener:SetOnFinished(TestEventListener.OnClick(DoClick1))
  62.                     listener:SetOnFinished(TestEventListener.VoidDelegate(DoClick2))
  63.                 end
  65.                 function TestEvent()
  66.                     print('this is a event')
  67.                 end
  69.                 function AddEvent(listener)
  70.                     listener.onClickEvent = listener.onClickEvent + TestEvent
  71.                 end
  73.                 function RemoveEvent(listener)
  74.                     listener.onClickEvent = listener.onClickEvent - TestEvent
  75.                 end
  77.                 local t = {name = 'byself'}
  79.                 function t:TestSelffunc()
  80.                     print('callback with self: '..self.name)
  81.                 end       
  83.                 function AddSelfClick(listener)
  84.                     if listener.onClick then
  85.                         listener.onClick = listener.onClick + TestEventListener.OnClick(t.TestSelffunc, t)
  86.                     else
  87.                         listener.onClick = TestEventListener.OnClick(t.TestSelffunc, t)
  88.                     end   
  89.                 end     
  91.                 function RemoveSelfClick(listener)
  92.                     if listener.onClick then
  93.                         listener.onClick = listener.onClick - TestEventListener.OnClick(t.TestSelffunc, t)
  94.                     else
  95.                         print('empty delegate')
  96.                     end   
  97.                 end
  98.         ";
  100.         LuaState state = null;
  101.         TestEventListener listener = null;
  103.         LuaFunction SetClick1 = null;
  104.         LuaFunction AddClick1 = null;
  105.         LuaFunction AddClick2 = null;
  106.         LuaFunction RemoveClick1 = null;
  107.         LuaFunction RemoveClick2 = null;
  108.         LuaFunction TestOverride = null;
  109.         LuaFunction RemoveEvent = null;
  110.         LuaFunction AddEvent = null;
  111.         LuaFunction AddSelfClick = null;
  112.         LuaFunction RemoveSelfClick = null;
  114.         //需要删除的转LuaFunction为委托，不需要删除的直接加或者等于即可
  115.         void Awake()
  116.         {               
  117.             state = new LuaState();
  118.             state.Start();
  119.             LuaBinder.Bind(state);
  120.             Bind(state);
  122.             state.LogGC = true;
  123.             state.DoString(script);
  124.             GameObject go = new GameObject("TestGo");
  125.             listener = (TestEventListener)go.AddComponent(typeof(TestEventListener));
  127.             SetClick1 = state.GetFunction("SetClick1");
  128.             AddClick1 = state.GetFunction("AddClick1");
  129.             AddClick2 = state.GetFunction("AddClick2");
  130.             RemoveClick1 = state.GetFunction("RemoveClick1");
  131.             RemoveClick2 = state.GetFunction("RemoveClick2");
  132.             TestOverride = state.GetFunction("TestOverride");
  133.             AddEvent = state.GetFunction("AddEvent");
  134.             RemoveEvent = state.GetFunction("RemoveEvent");
  136.             AddSelfClick = state.GetFunction("AddSelfClick");
  137.             RemoveSelfClick = state.GetFunction("RemoveSelfClick");
  138.         }
  140.         void Bind(LuaState L)
  141.         {
  142.             L.BeginModule(null);
  143.             TestEventListenerWrap.Register(state);
  144.             L.EndModule();
  146.             DelegateFactory.dict.Add(typeof(TestEventListener.OnClick), TestEventListener_OnClick);
  147.             DelegateFactory.dict.Add(typeof(TestEventListener.VoidDelegate), TestEventListener_VoidDelegate);
  148.         }
  150.         void CallLuaFunction(LuaFunction func)
  151.         {        
  152.             func.BeginPCall();
  153.             func.Push(listener);
  154.             func.PCall();
  155.             func.EndPCall();                
  156.         }
  158.         //自动生成代码后拷贝过来
  159.         class TestEventListener_OnClick_Event : LuaDelegate
  160.         {
  161.             public TestEventListener_OnClick_Event(LuaFunction func) : base(func) { }
  163.             public void Call(UnityEngine.GameObject param0)
  164.             {
  165.                 func.BeginPCall();
  166.                 func.Push(param0);
  167.                 func.PCall();
  168.                 func.EndPCall();
  169.             }
  170.         }
  172.         public static Delegate TestEventListener_OnClick(LuaFunction func, LuaTable self, bool flag)
  173.         {
  174.             if (func == null)
  175.             {
  176.                 TestEventListener.OnClick fn = delegate { };
  177.                 return fn;
  178.             }
  180.             TestEventListener_OnClick_Event target = new TestEventListener_OnClick_Event(func);
  181.             TestEventListener.OnClick d = target.Call;
  182.             target.method = d.Method;
  183.             return d;
  184.         }
  186.         class TestEventListener_VoidDelegate_Event : LuaDelegate
  187.         {
  188.             public TestEventListener_VoidDelegate_Event(LuaFunction func) : base(func) { }
  190.             public void Call(UnityEngine.GameObject param0)
  191.             {
  192.                 func.BeginPCall();
  193.                 func.Push(param0);
  194.                 func.PCall();
  195.                 func.EndPCall();
  196.             }
  197.         }
  199.         public static Delegate TestEventListener_VoidDelegate(LuaFunction func, LuaTable self, bool flag)
  200.         {
  201.             if (func == null)
  202.             {
  203.                 TestEventListener.VoidDelegate fn = delegate { };
  204.                 return fn;
  205.             }
  207.             TestEventListener_VoidDelegate_Event target = new TestEventListener_VoidDelegate_Event(func);
  208.             TestEventListener.VoidDelegate d = target.Call;
  209.             target.method = d.Method;
  210.             return d;
  211.         }
  213.         void OnGUI()
  214.         {
  215.             if (GUI.Button(new Rect(10, 10, 120, 40), " = OnClick1"))
  216.             {
  217.                 CallLuaFunction(SetClick1);
  218.             }
  219.             else if (GUI.Button(new Rect(10, 60, 120, 40), " + Click1"))
  220.             {
  221.                 CallLuaFunction(AddClick1);
  222.             }
  223.             else if (GUI.Button(new Rect(10, 110, 120, 40), " + Click2"))
  224.             {
  225.                 CallLuaFunction(AddClick2);
  226.             }
  227.             else if (GUI.Button(new Rect(10, 160, 120, 40), " - Click1"))
  228.             {
  229.                 CallLuaFunction(RemoveClick1);
  230.             }
  231.             else if (GUI.Button(new Rect(10, 210, 120, 40), " - Click2"))
  232.             {
  233.                 CallLuaFunction(RemoveClick2);
  234.             }
  235.             else if (GUI.Button(new Rect(10, 260, 120, 40), "+ Click1 in C#"))
  236.             {
  237.                 LuaFunction func = state.GetFunction("DoClick1");
  238.                 TestEventListener.OnClick onClick = (TestEventListener.OnClick)DelegateFactory.CreateDelegate(typeof(TestEventListener.OnClick), func);
  239.                 listener.onClick += onClick;
  240.             }        
  241.             else if (GUI.Button(new Rect(10, 310, 120, 40), " - Click1 in C#"))
  242.             {
  243.                 LuaFunction func = state.GetFunction("DoClick1");
  244.                 listener.onClick = (TestEventListener.OnClick)DelegateFactory.RemoveDelegate(listener.onClick, func);
  245.                 func.Dispose();
  246.                 func = null;
  247.             }
  248.             else if (GUI.Button(new Rect(10, 360, 120, 40), "OnClick"))
  249.             {
  250.                 if (listener.onClick != null)
  251.                 {
  252.                     listener.onClick(gameObject);
  253.                 }
  254.                 else
  255.                 {
  256.                     Debug.Log("empty delegate!!");
  257.                 }
  258.             }
  259.             else if (GUI.Button(new Rect(10, 410, 120, 40), "Override"))
  260.             {
  261.                 CallLuaFunction(TestOverride);
  262.             }
  263.             else if (GUI.Button(new Rect(10, 460, 120, 40), "Force GC"))
  264.             {
  265.                 //自动gc log: collect lua reference name , id xxx in thread 
  266.                 state.LuaGC(LuaGCOptions.LUA_GCCOLLECT, 0);
  267.                 GC.Collect();
  268.             }
  269.             else if (GUI.Button(new Rect(10, 510, 120, 40), "event +"))
  270.             {
  271.                 CallLuaFunction(AddEvent);
  272.             }
  273.             else if (GUI.Button(new Rect(10, 560, 120, 40), "event -"))
  274.             {
  275.                 CallLuaFunction(RemoveEvent);
  276.             }
  277.             else if (GUI.Button(new Rect(10, 610, 120, 40), "event call"))
  278.             {
  279.                 listener.OnClickEvent(gameObject);
  280.             }
  281.             else if (GUI.Button(new Rect(200, 10, 120, 40), "+self call"))
  282.             {
  283.                 CallLuaFunction(AddSelfClick);
  284.             }
  285.             else if (GUI.Button(new Rect(200, 60, 120, 40), "-self call"))
  286.             {
  287.                 CallLuaFunction(RemoveSelfClick);
  288.             }
  289.         }
  291.         void Update()
  292.         {
  293.             state.Collect();
  294.             state.CheckTop();        
  295.         }
  297.         void SafeRelease(ref LuaFunction luaRef)
  298.         {
  299.             if (luaRef != null)
  300.             {
  301.                 luaRef.Dispose();
  302.                 luaRef = null;
  303.             }
  304.         }
  306.         void OnDestroy()
  307.         {
  308.             SafeRelease(ref AddClick1);
  309.             SafeRelease(ref AddClick2);
  310.             SafeRelease(ref RemoveClick1);
  311.             SafeRelease(ref RemoveClick2);
  312.             SafeRelease(ref SetClick1);
  313.             SafeRelease(ref TestOverride);
  314.             state.Dispose();
  315.             state = null;
  316.         }
  317.     }

 

TestEventListener.cs

  1.     using UnityEngine;
  2.     using System;
  3.     using System.Collections;
  4.     using LuaInterface;
  6.     public class TestEventListener : MonoBehaviour
  7.     {
  8.         public delegate void VoidDelegate(GameObject go);
  9.         public delegate void OnClick(GameObject go);    
  10.         public OnClick onClick = delegate { };
  12.         public event OnClick onClickEvent = delegate { };
  14.         public Func<bool> TestFunc = null;
  16.         public void SetOnFinished(OnClick click)
  17.         {
  18.             Debugger.Log("SetOnFinished OnClick");
  19.         }
  21.         public void SetOnFinished(VoidDelegate click)
  22.         {
  23.             Debugger.Log("SetOnFinished VoidDelegate");
  24.         }
  26.         [NoToLuaAttribute]
  27.         public void OnClickEvent(GameObject go)
  28.         {
  29.             onClickEvent(go);
  30.         }
  31.     }

 

TestEventListenerWrap.cs

  1.     //this source code was auto-generated by tolua#, do not modify it
  2.     using System;
  3.     using LuaInterface;
  5.     public class TestEventListenerWrap
  6.     {
  7.         public static void Register(LuaState L)
  8.         {
  9.             L.BeginClass(typeof(TestEventListener), typeof(UnityEngine.MonoBehaviour));
  10.             L.RegFunction("SetOnFinished", SetOnFinished);
  11.             L.RegFunction("__eq", op_Equality);
  12.             L.RegFunction("__tostring", Lua_ToString);
  13.             L.RegVar("onClick", get_onClick, set_onClick);
  14.             L.RegVar("onClickEvent", get_onClickEvent, set_onClickEvent);
  15.             L.RegFunction("OnClick", TestEventListener_OnClick);
  16.             L.RegFunction("VoidDelegate", TestEventListener_VoidDelegate);
  17.             L.EndClass();
  18.         }
  20.         [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
  21.         static int SetOnFinished(IntPtr L)
  22.         {
  23.             try
  24.             {
  25.                 int count = LuaDLL.lua_gettop(L);
  27.                 if (count == 2 && TypeChecker.CheckTypes(L, 1, typeof(TestEventListener), typeof(TestEventListener.VoidDelegate)))
  28.                 {
  29.                     TestEventListener obj = (TestEventListener)ToLua.ToObject(L, 1);
  30.                     TestEventListener.VoidDelegate arg0 = null;
  31.                     LuaTypes funcType2 = LuaDLL.lua_type(L, 2);
  33.                     if (funcType2 != LuaTypes.LUA_TFUNCTION)
  34.                     {
  35.                          arg0 = (TestEventListener.VoidDelegate)ToLua.ToObject(L, 2);
  36.                     }
  37.                     else
  38.                     {
  39.                         LuaFunction func = ToLua.ToLuaFunction(L, 2);
  40.                         arg0 = DelegateFactory.CreateDelegate(typeof(TestEventListener.VoidDelegate), func) as TestEventListener.VoidDelegate;
  41.                     }
  43.                     obj.SetOnFinished(arg0);
  44.                     return 0;
  45.                 }
  46.                 else if (count == 2 && TypeChecker.CheckTypes(L, 1, typeof(TestEventListener), typeof(TestEventListener.OnClick)))
  47.                 {
  48.                     TestEventListener obj = (TestEventListener)ToLua.ToObject(L, 1);
  49.                     TestEventListener.OnClick arg0 = null;
  50.                     LuaTypes funcType2 = LuaDLL.lua_type(L, 2);
  52.                     if (funcType2 != LuaTypes.LUA_TFUNCTION)
  53.                     {
  54.                          arg0 = (TestEventListener.OnClick)ToLua.ToObject(L, 2);
  55.                     }
  56.                     else
  57.                     {
  58.                         LuaFunction func = ToLua.ToLuaFunction(L, 2);
  59.                         arg0 = DelegateFactory.CreateDelegate(typeof(TestEventListener.OnClick), func) as TestEventListener.OnClick;
  60.                     }
  62.                     obj.SetOnFinished(arg0);
  63.                     return 0;
  64.                 }
  65.                 else
  66.                 {
  67.                     return LuaDLL.luaL_throw(L, "invalid arguments to method: TestEventListener.SetOnFinished");
  68.                 }
  69.             }
  70.             catch(Exception e)
  71.             {
  72.                 return LuaDLL.toluaL_exception(L, e);
  73.             }
  74.         }
  76.         [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
  77.         static int op_Equality(IntPtr L)
  78.         {
  79.             try
  80.             {
  81.                 ToLua.CheckArgsCount(L, 2);
  82.                 UnityEngine.Object arg0 = (UnityEngine.Object)ToLua.ToObject(L, 1);
  83.                 UnityEngine.Object arg1 = (UnityEngine.Object)ToLua.ToObject(L, 2);
  84.                 bool o = arg0 == arg1;
  85.                 LuaDLL.lua_pushboolean(L, o);
  86.                 return 1;
  87.             }
  88.             catch(Exception e)
  89.             {
  90.                 return LuaDLL.toluaL_exception(L, e);
  91.             }
  92.         }
  94.         [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
  95.         static int Lua_ToString(IntPtr L)
  96.         {
  97.             object obj = ToLua.ToObject(L, 1);
  99.             if (obj != null)
  100.             {
  101.                 LuaDLL.lua_pushstring(L, obj.ToString());
  102.             }
  103.             else
  104.             {
  105.                 LuaDLL.lua_pushnil(L);
  106.             }
  108.             return 1;
  109.         }
  111.         [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
  112.         static int get_onClick(IntPtr L)
  113.         {
  114.             object o = null;
  116.             try
  117.             {
  118.                 o = ToLua.ToObject(L, 1);
  119.                 TestEventListener obj = (TestEventListener)o;
  120.                 TestEventListener.OnClick ret = obj.onClick;
  121.                 ToLua.Push(L, ret);
  122.                 return 1;
  123.             }
  124.             catch(Exception e)
  125.             {
  126.                 return LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index onClick on a nil value" : e.Message);
  127.             }
  128.         }
  130.         [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
  131.         static int get_onClickEvent(IntPtr L)
  132.         {
  133.             ToLua.Push(L, new EventObject("TestEventListener.onClickEvent"));
  134.             return 1;
  135.         }
  137.         [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
  138.         static int set_onClick(IntPtr L)
  139.         {
  140.             object o = null;
  142.             try
  143.             {
  144.                 o = ToLua.ToObject(L, 1);
  145.                 TestEventListener obj = (TestEventListener)o;
  146.                 TestEventListener.OnClick arg0 = null;
  147.                 LuaTypes funcType2 = LuaDLL.lua_type(L, 2);
  149.                 if (funcType2 != LuaTypes.LUA_TFUNCTION)
  150.                 {
  151.                      arg0 = (TestEventListener.OnClick)ToLua.CheckObject(L, 2, typeof(TestEventListener.OnClick));
  152.                 }
  153.                 else
  154.                 {
  155.                     LuaFunction func = ToLua.ToLuaFunction(L, 2);
  156.                     arg0 = DelegateFactory.CreateDelegate(typeof(TestEventListener.OnClick), func) as TestEventListener.OnClick;
  157.                 }
  159.                 obj.onClick = arg0;
  160.                 return 0;
  161.             }
  162.             catch(Exception e)
  163.             {
  164.                 return LuaDLL.toluaL_exception(L, e, o == null ? "attempt to index onClick on a nil value" : e.Message);
  165.             }
  166.         }
  168.         [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
  169.         static int set_onClickEvent(IntPtr L)
  170.         {
  171.             try
  172.             {
  173.                 TestEventListener obj = (TestEventListener)ToLua.CheckObject(L, 1, typeof(TestEventListener));
  174.                 EventObject arg0 = null;
  176.                 if (LuaDLL.lua_isuserdata(L, 2) != 0)
  177.                 {
  178.                     arg0 = (EventObject)ToLua.ToObject(L, 2);
  179.                 }
  180.                 else
  181.                 {
  182.                     return LuaDLL.luaL_throw(L, "The event 'TestEventListener.onClickEvent' can only appear on the left hand side of += or -= when used outside of the type 'TestEventListener'");
  183.                 }
  185.                 if (arg0.op == EventOp.Add)
  186.                 {
  187.                     TestEventListener.OnClick ev = (TestEventListener.OnClick)DelegateFactory.CreateDelegate(typeof(TestEventListener.OnClick), arg0.func);
  188.                     obj.onClickEvent += ev;
  189.                 }
  190.                 else if (arg0.op == EventOp.Sub)
  191.                 {
  192.                     TestEventListener.OnClick ev = (TestEventListener.OnClick)LuaMisc.GetEventHandler(obj, typeof(TestEventListener), "onClickEvent");
  193.                     Delegate[] ds = ev.GetInvocationList();
  194.                     LuaState state = LuaState.Get(L);
  196.                     for (int i = 0; i < ds.Length; i++)
  197.                     {
  198.                         ev = (TestEventListener.OnClick)ds[i];
  199.                         LuaDelegate ld = ev.Target as LuaDelegate;
  201.                         if (ld != null && ld.func == arg0.func)
  202.                         {
  203.                             obj.onClickEvent -= ev;
  204.                             state.DelayDispose(ld.func);
  205.                             break;
  206.                         }
  207.                     }
  209.                     arg0.func.Dispose();
  210.                 }
  212.                 return 0;
  213.             }
  214.             catch(Exception e)
  215.             {
  216.                 return LuaDLL.toluaL_exception(L, e);
  217.             }
  218.         }
  220.         [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
  221.         static int TestEventListener_OnClick(IntPtr L)
  222.         {
  223.             try
  224.             {
  225.                 LuaFunction func = ToLua.CheckLuaFunction(L, 1);
  226.                 Delegate arg1 = DelegateFactory.CreateDelegate(typeof(TestEventListener.OnClick), func);
  227.                 ToLua.Push(L, arg1);
  228.                 return 1;
  229.             }
  230.             catch(Exception e)
  231.             {
  232.                 return LuaDLL.toluaL_exception(L, e);
  233.             }
  234.         }
  236.         [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
  237.         static int TestEventListener_VoidDelegate(IntPtr L)
  238.         {
  239.             try
  240.             {
  241.                 LuaFunction func = ToLua.CheckLuaFunction(L, 1);
  242.                 Delegate arg1 = DelegateFactory.CreateDelegate(typeof(TestEventListener.VoidDelegate), func);
  243.                 ToLua.Push(L, arg1);
  244.                 return 1;
  245.             }
  246.             catch(Exception e)
  247.             {
  248.                 return LuaDLL.toluaL_exception(L, e);
  249.             }
  250.         }
  251.     }

?