Unity Loom 插件使用

我爱萨其马虞co

最近在做资源更新时，需要显示现在的进度调。我在Unity中开启了一个线程来做下载任务，然后实时刷新下载进度。然后Unity报了一个错误。get_isActiveAndEnabled can only be called from the main thread.
大体意思是Unity中的组件只能运行在Unity的主线程中，无法在我新开的线程中调用Unity的组件。百度了一下，找到了Loom这个插件。感觉真的很好用，错误不见了。
这里做下记录。
Loom插件就一个脚本导入到Unity中就行了。具体脚本内容如下

1. using UnityEngine;
2. using System.Collections;
3. using System.Collections.Generic;
4. using System;
5. using System.Threading;
6. using System.Linq;
8.     public class Loom :MonoBehaviour
9.     {
10.         public static int maxThreads = 8;
11.         static int numThreads;
13.         private static Loom _current;
14.         //private int _count;
15.         public static Loom Current
16.         {
17.             get
18.             {
19.                 Initialize();
20.                 return _current;
21.             }
22.         }
24.         void Awake()
25.         {
26.             _current = this;
27.             initialized = true;
28.         }
30.         static bool initialized;
32.         public static void Initialize()
33.         {
34.             if (!initialized)
35.             {
37.                 if (!Application.isPlaying)
38.                     return;
39.                 initialized = true;
40.                 var g = new GameObject("Loom");
41.                 _current = g.AddComponent<Loom>();
42. #if !ARTIST_BUILD
43.                 UnityEngine.Object.DontDestroyOnLoad(g);
44. #endif
45.             }
47.         }
48.         public struct NoDelayedQueueItem
49.         {
50.             public Action<object> action;
51.             public object param;
52.         }
54.         private List<NoDelayedQueueItem> _actions = new List<NoDelayedQueueItem>();
55.         public struct DelayedQueueItem
56.         {
57.             public float time;
58.             public Action<object> action;
59.             public object param;
60.         }
61.         private List<DelayedQueueItem> _delayed = new List<DelayedQueueItem>();
63.         List<DelayedQueueItem> _currentDelayed = new List<DelayedQueueItem>();
65.         public static void QueueOnMainThread(Action<object> taction, object tparam)
66.         {
67.             QueueOnMainThread(taction, tparam, 0f);
68.         }
69.         public static void QueueOnMainThread(Action<object> taction, object tparam, float time)
70.         {
71.             if (time != 0)
72.             {
73.                 lock (Current._delayed)
74.                 {
75.                     Current._delayed.Add(new DelayedQueueItem { time = Time.time + time, action = taction, param = tparam });
76.                 }
77.             }
78.             else
79.             {
80.                 lock (Current._actions)
81.                 {
82.                     Current._actions.Add(new NoDelayedQueueItem { action = taction, param = tparam });
83.                 }
84.             }
85.         }
87.         public static Thread RunAsync(Action a)
88.         {
89.             Initialize();
90.             while (numThreads >= maxThreads)
91.             {
92.                 Thread.Sleep(100);
93.             }
94.             Interlocked.Increment(ref numThreads);
95.             ThreadPool.QueueUserWorkItem(RunAction, a);
96.             return null;
97.         }
99.         private static void RunAction(object action)
100.         {
101.             try
102.             {
103.                 ((Action)action)();
104.             }
105.             catch
106.             {
107.             }
108.             finally
109.             {
110.                 Interlocked.Decrement(ref numThreads);
111.             }
113.         }
116.         void OnDisable()
117.         {
118.             if (_current == this)
119.             {
121.                 _current = null;
122.             }
123.         }
127.         // Use this for initialization
128.         void Start()
129.         {
131.         }
133.         List<NoDelayedQueueItem> _currentActions = new List<NoDelayedQueueItem>();
135.         // Update is called once per frame
136.         void Update()
137.         {
138.             if (_actions.Count > 0)
139.             {
140.                 lock (_actions)
141.                 {
142.                     _currentActions.Clear();
143.                     _currentActions.AddRange(_actions);
144.                     _actions.Clear();
145.                 }
146.                 for (int i = 0; i < _currentActions.Count; i++)
147.                 {
148.                     _currentActions[i].action(_currentActions[i].param);
149.                 }
150.             }
152.             if (_delayed.Count > 0)
153.             {
154.                 lock (_delayed)
155.                 {
156.                     _currentDelayed.Clear();
157.                     _currentDelayed.AddRange(_delayed.Where(d => d.time <= Time.time));
158.                     for (int i = 0; i < _currentDelayed.Count; i++)
159.                     {
160.                         _delayed.Remove(_currentDelayed[i]);
161.                     }
162.                 }
164.                 for (int i = 0; i < _currentDelayed.Count; i++)
165.                 {
166.                     _currentDelayed[i].action(_currentDelayed[i].param);
167.                 }
168.             }
169.         }
170.     }

复制代码

代码也就100多行，主要是两个比较主要的方法
RunAsync(Action a)和QueueOnMainThread(Action<object> taction, object tparam)

开启一个线程然后在Loom.RunAsyn()中调用需要回到Unity主线程更新界面时调用QueueOnMainThread（）即可。简单好用。
下面贴一下 不用Loom报错的代码和用Loom后的代码

1.     public Text mText;
2.         void Start ()
3.     {
4.         Thread thread = new Thread(RefreshText);
5.         thread.Start();
6.         }
7.        
8.         void Update ()
9.     {
10.        
11.         }
12.     private void RefreshText()
13.     {
14.         mText.text = "Hello Loom!";
15.     }

复制代码

运行这段代码Unity会报上面的错误，意思是我在我自己开的线程中调用了Unity组件。

1. using UnityEngine;
2. using System.Collections;
3. using UnityEngine.UI;
4. using System.Threading;
5. public class testLoom : MonoBehaviour
6. {
8.     public Text mText;
9.         void Start ()
10.     {
11.         
12.         // 用Loom的方法调用一个线程
13.         Loom.RunAsync(
14.             () =>
15.             {
16.                Thread thread = new Thread(RefreshText);
17.                 thread.Start();
18.             }
19.             );
20.         }
21.        
22.         void Update ()
23.     {
24.        
25.         }
26.     private void RefreshText()
27.     {  
28.         // 用Loom的方法在Unity主线程中调用Text组件
29.         Loom.QueueOnMainThread((param) =>
30.             {
31.                 mText.text = "Hello Loom!";
32.             },null);
33.     }
34. }

复制代码

这样就是不会报错。
短短的100多行代码就搞定了这个问题，不得不佩服大神们的思路，有时间可以好好研究下Loom的实现的方法。