unity3d性能优化（lua委托事件）_skybeauty_新浪博客

最新推荐文章于 2022-05-03 10:32:29 发布
最新推荐文章于 2022-05-03 10:32:29 发布
阅读量1k 收藏 1
点赞数
文章标签： c# java js javascript redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42205596/article/details/90608478
版权
ugui中常用的监听事件的组件大致有，button，ScrollRect，toggle，InputField，Slider
在使用lua写逻辑功能的时候避免不了要有点击相关的交互，而这些交互的函数在c#中其实是通过委托实现的，下面就以常用的button为例介绍一下：

local button = UnityEngine.UI.Button()

local btnHandler = function() print("test click") end
button.onClick:AddListener(btnHandler)

以上代码可能是大家比较熟悉的，那么AddListener究竟做了哪些工作呢，我们看一下:
public class UnityEngine_UI_Button_ButtonClickedEventWrap
{
public static void Register(LuaState L)
{
L.BeginClass(typeof(UnityEngine.UI.Button.ButtonClickedEvent), typeof(UnityEngine.Events.UnityEvent));
L.RegFunction("New", _CreateUnityEngine_UI_Button_ButtonClickedEvent);
L.RegFunction("__tostring", ToLua.op_ToString);
L.EndClass();
}


在看一下UnityEngine_Events_UnityEventWrap这个类
public class UnityEngine_Events_UnityEventWrap
{
public static void Register(LuaState L)
{
L.BeginClass(typeof(UnityEngine.Events.UnityEvent), typeof(UnityEngine.Events.UnityEventBase));
L.RegFunction("AddListener", AddListener);
L.RegFunction("RemoveListener", RemoveListener);
L.RegFunction("Invoke", Invoke);
L.RegFunction("New", _CreateUnityEngine_Events_UnityEvent);
L.RegFunction("__tostring", ToLua.op_ToString);
L.EndClass();
}

[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
static int AddListener(IntPtr L)
{
try
{
ToLua.CheckArgsCount(L, 2);
UnityEngine.Events.UnityEvent obj = (UnityEngine.Events.UnityEvent)ToLua.CheckObject(L, 1);
UnityEngine.Events.UnityAction arg0 = (UnityEngine.Events.UnityAction)ToLua.CheckDelegate(L, 2);
obj.AddListener(arg0);
return 0;
}
catch (Exception e)
{
return LuaDLL.toluaL_exception(L, e);
}
}


继续往下看：
public static Delegate CheckDelegate(IntPtr L, int stackPos)
        {
            LuaTypes luatype = LuaDLL.lua_type(L, stackPos);

            switch (luatype)
            {
                case LuaTypes.LUA_TNIL:
                    return null;
                case LuaTypes.LUA_TFUNCTION:
                    LuaFunction func = ToLua.ToLuaFunction(L, stackPos);
                    return DelegateTraits.Create(func);
                case LuaTypes.LUA_TUSERDATA:
                    return (Delegate)ToLua.CheckObject(L, stackPos, typeof(T));
                default:
                    LuaDLL.luaL_typerror(L, stackPos, TypeTraits.GetTypeName());
                    return null;
            }
        }


class UnityEngine_Events_UnityAction_Event : LuaDelegate
{
public UnityEngine_Events_UnityAction_Event(LuaFunction func) : base(func) { }
public UnityEngine_Events_UnityAction_Event(LuaFunction func, LuaTable self) : base(func, self) { }

public void Call()
{
func.Call();
}

public void CallWithSelf()
{
func.BeginPCall();
func.Push(self);
func.PCall();
func.EndPCall();
}
}

接着就会走到这里：
public class LuaDelegate
    {
        public LuaFunction func = null;
        public LuaTable self = null;
        public MethodInfo method = null; 

        public LuaDelegate(LuaFunction func)
        {
            this.func = func;
        }

        public LuaDelegate(LuaFunction func, LuaTable self)
        {
            this.func = func;
            this.self = self;
        }

        //如果count不是1，说明还有其他人引用，只能等待gc来处理
        public virtual void Dispose()
        {
            method = null;

            if (func != null)
            {
                func.Dispose(true);
                func = null;
            }

            if (self != null)
            {
                self.Dispose(true);
                self = null;
            }
        }

 从上面看下来如果当button被删除之后如果onClick也就是UnityEngine.UI.Button.ButtonClickedEvent这个委托最后没有被删除的话，那么之前AddListener放进去的luafunc就永远不会删除
 那么他会存在哪里呢，看如下代码：
 public static LuaFunction ToLuaFunction(IntPtr L, int stackPos)
        {
            LuaTypes type = LuaDLL.lua_type(L, stackPos);

            if (type == LuaTypes.LUA_TNIL)
            {
                return null;
            }

            stackPos = LuaDLL.abs_index(L, stackPos);
            LuaDLL.lua_pushvalue(L, stackPos);
            int reference = LuaDLL.toluaL_ref(L);
            return LuaStatic.GetFunction(L, reference);
        }


 public static LuaFunction GetFunction(IntPtr L, int reference)
        {
            LuaState state = LuaState.Get(L);
            return state.GetFunction(reference);
        }


 public LuaFunction GetFunction(int reference)
        {
            LuaFunction func = TryGetLuaRef(reference) as LuaFunction;

            if (func == null)
            {                
                func = new LuaFunction(reference, this);
                funcRefMap.Add(reference, new WeakReference(func));
                if (LogGC) Debugger.Log("Alloc LuaFunction name , id {0}", reference);      
            }

            RemoveFromGCList(reference);
            return func;
        }

这样就很清晰的看到这个func被放到了funcRefMap中，而这个funcRefMap的话是在LuaState中，具体代码如下：
public class LuaState : LuaStatePtr, IDisposable
    {
        public ObjectTranslator translator = new ObjectTranslator();
        public LuaReflection reflection = new LuaReflection();

        public int ArrayMetatable { get; private set; }
        public int DelegateMetatable { get; private set; }
        public int TypeMetatable { get; private set; }
        public int EnumMetatable { get; private set; }
        public int IterMetatable { get; private set; }        
        public int EventMetatable { get; private set; }

        //function ref                
        public int PackBounds { get; private set; }
        public int UnpackBounds { get; private set; }
        public int PackRay { get; private set; }
        public int UnpackRay { get; private set; }
        public int PackRaycastHit { get; private set; }        
        public int PackTouch { get; private set; }

        public bool LogGC 
        {
            get
            {
                return beLogGC;
            }

            set
            {
                beLogGC = value;
                translator.LogGC = value;
            }
        }

        public Action OnDestroy = delegate { };
        
        Dictionary funcMap = new Dictionary();
        Dictionary funcRefMap = new Dictionary();
        Dictionary delegateMap = new Dictionary();

然而他们的释放却是在LuaState的Collect方法中：
protected void Collect(int reference, string name, bool beThread)
        {
            if (beThread)
            {
                WeakReference weak = null;

                if (name != null)
                {
                    funcMap.TryGetValue(name, out weak);

                    if (weak != null && !weak.IsAlive)
                    {
                        funcMap.Remove(name);
                        weak = null;
                    }
                }
                
                funcRefMap.TryGetValue(reference, out weak);

                if (weak != null && !weak.IsAlive)
                {
                    ToLuaUnRef(reference);
                    funcRefMap.Remove(reference);
                    delegateMap.Remove(reference);

                    if (LogGC)
                    {
                        string str = name == null ? "null" : name;
                        Debugger.Log("collect lua reference name {0}, id {1} in thread", str, reference);
                    }
                }
            }
            else
            {
                if (name != null)
                {
                    WeakReference weak = null;
                    funcMap.TryGetValue(name, out weak);
                    
                    if (weak != null && weak.IsAlive)
                    {
                        LuaBaseRef lbr = (LuaBaseRef)weak.self;

                        if (reference == lbr.GetReference())
                        {
                            funcMap.Remove(name);
                        }
                    }
                }

                ToLuaUnRef(reference);
                funcRefMap.Remove(reference);
                delegateMap.Remove(reference);

                if (LogGC)
                {
                    string str = name == null ? "null" : name;
                    Debugger.Log("collect lua reference name {0}, id {1} in main", str, reference);
                }
            }
        }
当然了，如果不满足gc条件那么这些func都会一直在内存中的，所以当使用完委托的时候一定要注意释放，不然如果luafun中包含其他的lua对象（lua闭包），那么都不会被释放掉的，当界面关闭的时候就要清理委托事件，如下：
button.onClick:RemoveAllListeners(),从逻辑上讲这就可以了，如果按钮不被点击，那么这是ok的，但是的我们在项目中发现了ugui有个bug，如果按钮被点击过，也就是说Invoke被触发了，那么这个委托怎么删除都删除不了，后来通过反编译工具看到UnityEventBase源码才发现，在执行invoke的时候委托会被缓存，只有下次再执行invoke的时候才被删除，具体源码如下：

namespace UnityEngine.Events
{
  internal class InvokableCallList
  {
    private readonly List m_PersistentCalls = new List();
    private readonly List m_RuntimeCalls = new List();
    private readonly List m_ExecutingCalls = new List();
    private bool m_NeedsUpdate = true;

    public int Count
    {
      get
      {
        return this.m_PersistentCalls.Count + this.m_RuntimeCalls.Count;
      }
    }

    public void AddPersistentInvokableCall(BaseInvokableCall call)
    {
      this.m_PersistentCalls.Add(call);
      this.m_NeedsUpdate = true;
    }

    public void AddListener(BaseInvokableCall call)
    {
      this.m_RuntimeCalls.Add(call);
      this.m_NeedsUpdate = true;
    }

    public void RemoveListener(object selfObj, MethodInfo method)
    {
      List baseInvokableCallList = new List();
      for (int index = 0; index < this.m_RuntimeCalls.Count; ++index)
      {
        if (this.m_RuntimeCalls[index].Find(selfObj, method))
          baseInvokableCallList.Add(this.m_RuntimeCalls[index]);
      }
      this.m_RuntimeCalls.RemoveAll(new Predicate(baseInvokableCallList.Contains));
      this.m_NeedsUpdate = true;
    }

    public void Clear()
    {
      this.m_RuntimeCalls.Clear();
      this.m_NeedsUpdate = true;
    }

    public void ClearPersistent()
    {
      this.m_PersistentCalls.Clear();
      this.m_NeedsUpdate = true;
    }

    public void Invoke(object[] parameters)
    {
      if (this.m_NeedsUpdate)
      {
        this.m_ExecutingCalls.Clear();
        this.m_ExecutingCalls.AddRange((IEnumerable) this.m_PersistentCalls);
        this.m_ExecutingCalls.AddRange((IEnumerable) this.m_RuntimeCalls);
        this.m_NeedsUpdate = false;
      }
      for (int index = 0; index < this.m_ExecutingCalls.Count; ++index)
        this.m_ExecutingCalls[index].Invoke(parameters);
    }
  }
}

从上面代码中可以看出m_ExecutingCalls从来没有被清楚过，除非再次调用invoke，于是我们就想出了一个方案就是，在执行完button.onClick:RemoveAllListeners()之后再调用一下button.onClick:Invoke()，这样可以完美解决，上面的bug导致的内存泄漏，后来笔者又发现了一个方法也是可以达到同样的效果:

监听的时候：
button.onClick:AddListener(UnityEngine.Events.UnityAction( btnHandler))

销毁的时候：
button.onClick:RemoveAllListeners()

剩下的其他组件也是有以上两种方法处理，我们项目是这样处理的，具体代码如下：

--清理按钮监听事件
   if self.__btnList then 
       for k,v in pairs(self.__btnList) do 
          if not tolua.isnull(v) then 
             v.onClick:RemoveAllListeners()
             v.onClick:Invoke()
          end
       end
   end

   --清理toggle相关事件
   if self.__toggleList then 
       for k,v in pairs(self.__toggleList) do 
          if not tolua.isnull(v) then 
             v.onValueChanged:RemoveAllListeners()
             v.onValueChanged:Invoke(false)
          end
       end
   end

   --清理scrollRect相关事件
   if self.__scrollList then 
       for k,v in pairs(self.__scrollList) do 
          if not tolua.isnull(v) then 
             v.onValueChanged:RemoveAllListeners()
             v.onValueChanged:Invoke(UnityEngine.Vector2.zero)
          end
       end
   end

   --清理InputField相关事件
   if self.__inputFieldList then 
       for k,v in pairs(self.__inputFieldList) do 
          if not tolua.isnull(v) then 
             v.onEndEdit:RemoveAllListeners()
             v.onValueChanged:RemoveAllListeners()
             v.onEndEdit:Invoke("")
             v.onValueChanged:Invoke("")
          end
       end
   end

   --清理slider相关事件
   if self.__sliderList then 
       for k,v in pairs(self.__sliderList) do 
          if not tolua.isnull(v) then 
             v.onValueChanged:RemoveAllListeners()
             v.onValueChanged:Invoke(0)
          end
       end
   end

最后再说一种情况，就是自定义的比如：
public Action onPointerClickEvent;

那么这一类属于系统的delegate，需要这样处理，
local luaClick= onPointerClickEvent

添加事件：
luaClick = btnHandler

销毁的时候：
luaClick:Destroy()

目前为止已经写完了，所有以上都可以通过打印验证，具体代码如下：

foreach (var item in funcMap)
            {
                LuaBaseRef temp = item.Value.Target as LuaBaseRef;
                if (temp != null)
                    Debugger.LogError("funcMap::::"+item.Key+"-----------"+ (temp.name != null ? temp.name : "null"));
            }

            foreach (var item in funcRefMap)
            {
                LuaBaseRef temp = item.Value.Target as LuaBaseRef;
                if (temp != null)
                    Debugger.LogError("funcRefMap::::" + item.Key + "-----------" + (temp.name != null ? temp.name : "null"));
            }

            foreach (var item in delegateMap)
            {
                LuaBaseRef temp = item.Value.Target as LuaBaseRef;
                if (temp != null)
                {
                    Debugger.LogError("delegateMap::::" + item.Key + "-----------" + (temp.name != null ? temp.name : "null"));
                }
            }








ttttttt...
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
lua协程 unity_Unity3d 协程、调用函数、委托
weixin_39687881的博客
02-26 170
(一)协程开启方法:StartCoroutine("函数名")；结束方法StopCoroutine("函数名")，StopAllCoroutines();IEnumeratorTestIEnumerator(){Debug.Log("协程");//等待游戏界面绘制完成yieldreturnnewWaitForEndOfFrame();Debug.Log("游戏界面绘制完成");//等待1秒...
Lua调用七C#语言（委托和事件）
赵某人
06-23 535
Lua代码 print("*****************Lua调用C# 委托相关知识点******************"); local obj = CS.Lesson7(); --委托是用来装函数的 --使用C#中的委托 就是用来装lua的函数 local fun = function() -- body print("Lua中的委托函数"); end --lua中没有复合运算符 不能+= --如果第一次往函数中加函数，因为是nil 不能直接+ --所有第一次要先= print("
学习ULua之委托
啊循的专栏
09-18 3093
ULua很不错的样子，不过对lua不太熟悉，就先不用它那个框架了 今天要实现的功能是用lua给UGUI的一个按钮添加一个点击响应~~~~ 因为我觉得在使用Lua与C#交互，委托是最重要的部分，这样可以很灵活的响应宿主的事件，其它的姿势都比较明确，也不用多说 首先是一个类似以前NGUI绑定事件的脚本，大部分来自momo研究院，我给加了一个OnPress的事件 using UnityEngin
Unity3D中的Button控件，绑定脚本OnClick函数的方法（我被一个操作坑惨了）
madaxin的博客
08-05 1万+
本来这是件无足轻重的小事情，很好解决。但是就因为是小事情，第一次接触的时候，居然没搞定差点到各种群里求助，于是决定还是记录下吧。 添加了Button节点到工程里后，加入 ButtonController 脚本后，在Inspector里呈现的界面是这样的。 这时候，我们在ButtonController 脚本中加入OnClick函数。 using System.Collections; using System.Collections.Generic; using UnityEngi...
Unity Button 基础
01-31 3544
来源： http://blog.csdn.net/qq992817263/article/details/51754381 http://blog.csdn.net/wkhabc/article/details/52389171 ----------------------------------------------------------------------   UGUI Bu...
build_xlua_with_libs-master_lua_Unity热更新_unity3D游戏_androidunity_
10-02
本项目"build_xlua_with_libs-master_lua_Unity热更新_unity3D游戏_androidunity_"提供了一个基于Lua的解决方案，用于实现Unity在Android和iOS平台上的热更新功能。 首先，我们要理解什么是Lua。Lua是一种轻量级的...
理解Lua中的__index和__newindex
09-22
总结起来，`__index` 和 `__newindex` 是 Lua 中实现面向对象编程、委托、动态属性和错误处理等高级特性的重要工具。它们允许开发者在运行时动态地改变表的行为，提供了一种强大的扩展性和灵活性。通过这两个元方法...
use_Lua.rar_c++ lua_lua_lua C++ 嵌入_lua vc
09-24
在C++编程中，有时我们需要在程序中引入脚本语言以实现动态行为或者提供更灵活的编程模型。...通过深入理解上述步骤和Lua的C API，开发者可以创建出强大的混合型应用，同时享受到C++的高性能和Lua的便捷脚本能力。
Lua的粒子群优化库_lua_代码_下载
06-20
标题和描述中提到的“Lua的粒子群优化库”是指使用Lua编程语言实现的一种算法库，该库主要用于实现粒子群优化（Particle Swarm Optimization, PSO）算法。粒子群优化是一种仿生优化算法，源自对鸟群或鱼群集体行为的...
lua_svr.rar_c++ lua_lua_lua c++_lua socket_服务器lua
09-20
在IT行业中，Lua被广泛用于游戏开发、脚本编写以及服务器端编程，因其简洁的语法和高效的性能而受到青睐。本教程将深入探讨如何利用C++与Lua进行交互，构建基于Lua的服务器，并重点关注Lua的socket编程技术。下面...
UnityEvent内存泄漏
TracyZly的专栏
07-03 1177
最近写UI单击事件时发现一个内存泄漏，经过反编译UnityEngine.dll查看源码，定位到了问题，总结一下。 过程重现： 按钮注册一个单击事件，当点击此按钮，触发此单击事件，并在执事件方行过程中再反注册此事件，就会造成事件所注册的对象实例不能被释放，再执行下委托的Invoke方法，才会释放对象实例。 反编译UnityEngine.dll发现了这段代码造成了内存泄漏：// UnityEng
Lua里实现Unity的拖拽、移入移出等响应事件
Le_Sam的博客
05-03 845
源码： C# namespace Game.Scripts.Listener { public class BaseEventListener : MonoBehaviour { public LuaFunction func = null; public void OnFunc(PointerEventData eventData) { if (func != null) {
unity游戏框架学习-资源管理
weixin_30411239的博客
07-17 1510
概述：https://www.cnblogs.com/wang-jin-fu/p/10975660.html 这篇只涉及基础原理，下篇会讲如何实现一个简单的资源管理框架。 一、Assets和Objects 资源(Asset)是存储在Unity项目的Assets文件夹中的磁盘文件。有些资源的数据格式是Unity原声支持的，有些资源则需要转换为源生的数据格式后才能被使用。 对象(...
toLua Framework之性能检测与优化
折羽
04-01 1308
toLua之性能检测与优化 https://zhuanlan.zhihu.com/p/57051520 https://blog.csdn.net/qq_30678451/article/details/88038813 http://luaprofiler.luaforge.net/index.html#download https://www.cnblogs.com/lightsong/p/...
Unity 使用xLua遇到的坑
kuangben2000的博客
01-27 1064
Unity 使用xLua遇到的坑 https://blog.csdn.net/qq3401247010/article/details/77132011 在我们使用xLua作为Unity中lua集成的解决方案时，遇到了一个问题，就是当我们使用在lua中把UI中的某个控件绑定相应的事件（如按钮的onClick事件），xLua绑定这个事件是用委托实现的，具体代码可以查看xLua的代码。而在程序退出...
关于UnityEngine.UI.Button.ButtonClickedEvent事件列表
A丶Knight 的博客
06-08 4511
UnityEngine.UI.Button.ButtonClickedEvent是一个Unity内部封装好的委托事件列表，最终基类是UnityEventBase， 常用函数： void RemoveListener(UnityAction call); // 移除一个事件，参数同上 AddListener(UnityAction call); // 添加一个事件，参数为事件名称
Unity 之 UGUI Button 点击无响应问题汇总
热门推荐
陈言必行 -- Unity游戏开发领域优质博主
11-27 2万+
Unity UGUI Button 点击不响应，遇到的8中情况和解决方案，总有一种适合你。
Tolua使用笔记六:在lua中操作C#的委托事件与在lua中对Unity的GameObject的操作
唐唐唐唐人的博客
05-26 1万+
原文地址：http://blog.csdn.net/qq_30168505/article/details/70555511案例十一： 该案例主要讲解的是再Unity中对于C#中的委托的一些操作的方法 相比之前的一些例子，如果细心完整的看下来，会发现较开始的例子，这个例子算是比较复杂的了 核心代码就不贴了，太长了，如果没有经验，直接看这个例子，可能你已经晕在这里了，现在我就开始为大家细细的解析这样一
lua_package_path
最新发布
05-10
lua_package_path 是 Nginx 的一个配置选项，用于指定 Nginx 在查找 Lua 模块时所用的搜索路径。它的语法如下： ``` lua_package_path "<Lua搜索路径>"; ``` 其中，<Lua搜索路径> 是一个由多个搜索路径组成的字符...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值