Unity协程（Coroutine）原理深入剖析再续
By D.S.Qiu
尊重他人的劳动，支持原创，转载请注明出处：http.dsqiu.iteye.com
前面已经介绍过对协程（Coroutine）的认识和理解，主要讲到了Unity引擎在执行协程（Coroutine）的原理（Unity协程（Coroutine）原理深入剖析）和对协程（Coroutine）状态的控制（Unity协程(Coroutine)管理类——TaskManager工具分享），到这使用Coroutine的疑问就没有了，但是D.S.Qiu还是有点没嚼烂，所以觉得很有必要再续。
本文主要分为三部分：
1）yield return， IEnumerator 和 Unity StartCoroutine 的关系和理解
2）Cortoutine 扩展——Extending Coroutines: Return Values and Error Handling
3）Cortountine Locking
总之，引用③的一句话：Coroutines – More than you want to know.
1）yield return， IEnumerator 和 Unity StartCoroutine 的关系和理解
yield 和 IEnumerator都是C#的东西，前者是一个关键字，后者是枚举类的接口。对于IEnumerator 只引用②对 IEnumerable与IEnumerator区别 的论述：
先贴出 IEnumerable 和 IEnumerator的定义：
public interface IEnumerable
{
IEnumerator GetEnumerator();
}
public interface IEnumerator
{
bool MoveNext();
void Reset();
Object Current { get; }
}
IEnumerable和IEnumerator有什么区别？这是一个很让人困惑的问题（在很多forum里都看到有人在问这个问题）。研究了半天，得到以下几点认识：
1、一个Collection要支持foreach方式的遍历，必须实现IEnumerable接口（亦即，必须以某种方式返回IEnumerator object）。
2、IEnumerator object具体实现了iterator（通过MoveNext()，Reset()，Current）。
3、从这两个接口的用词选择上，也可以看出其不同：IEnumerable是一个声明式的接口，声明实现该接口的class是“可枚举（enumerable）”的，但并没有说明如何实现枚举器（iterator）；IEnumerator是一个实现式的接口，IEnumerator object就是一个iterator。
4、IEnumerable和IEnumerator通过IEnumerable的GetEnumerator()方法建立了连接，client可以通过IEnumerable的GetEnumerator()得到IEnumerator object，在这个意义上，将GetEnumerator()看作IEnumerator object的factory method也未尝不可。
IEnumerator 是所有枚举数的基接口。
枚举数只允许读取集合中的数据。枚举数无法用于修改基础集合。
最初，枚举数被定位于集合中第一个元素的前面。Reset 也将枚举数返回到此位置。在此位置，调用 Current 会引发异常。因此，在读取 Current 的值之前，必须调用 MoveNext 将枚举数提前到集合的第一个元素。
在调用 MoveNext 或 Reset 之前，Current 返回同一对象。MoveNext 将 Current 设置为下一个元素。
在传递到集合的末尾之后，枚举数放在集合中最后一个元素后面，且调用 MoveNext 会返回 false。如果最后一次调用 MoveNext 返回 false，则调用 Current 会引发异常。若要再次将 Current 设置为集合的第一个元素，可以调用 Reset，然后再调用 MoveNext。
只要集合保持不变，枚举数就将保持有效。如果对集合进行了更改（例如添加、修改或删除元素），则该枚举数将失效且不可恢复，并且下一次对 MoveNext 或 Reset 的调用将引发 InvalidOperationException。如果在 MoveNext 和 Current 之间修改集合，那么即使枚举数已经无效，Current 也将返回它所设置成的元素。
枚举数没有对集合的独占访问权；因此，枚举一个集合在本质上不是一个线程安全的过程。甚至在对集合进行同步处理时，其他线程仍可以修改该集合，这会导致枚举数引发异常。若要在枚举过程中保证线程安全，可以在整个枚举过程中锁定集合，或者捕捉由于其他线程进行的更改而引发的异常。
Yield关键字
在迭代器块中用于向枚举数对象提供值或发出迭代结束信号。它的形式为下列之一⑥：
yield return <expression_r>;
yield break;
备注 :
计算表达式并以枚举数对象值的形式返回；expression_r 必须可以隐式转换为迭代器的 yield 类型。
yield 语句只能出现在 iterator 块中，该块可用作方法、运算符或访问器的体。这类方法、运算符或访问器的体受以下约束的控制：
不允许不安全块。
方法、运算符或访问器的参数不能是 ref 或 out。
yield 语句不能出现在匿名方法中。
当和 expression_r 一起使用时，yield return 语句不能出现在 catch 块中或含有一个或多个 catch 子句的 try 块中。
yield return 提供了迭代器一个比较重要的功能，即取到一个数据后马上返回该数据，不需要全部数据装入数列完毕，这样有效提高了遍历效率。
Unity StartCoroutine
Unity使用 StartCoroutine(routine: IEnumerator): Coroutine 启动协程，参数必须是 IEnumerator 对象。那么Unity在背后做什么神奇的处理呢？
StartCoroutine函数的参数我一般都是通过传入一个返回值为 IEnumerator的函数得到的：
IEnumerator WaitAndPrint(float waitTime) {
yield return new WaitForSeconds(waitTime);
print("WaitAndPrint " + Time.time);
}
在函数内使用前面介绍 yield 关键字返回 IEnumerator 对象，Unity 中实现了 YieldInstruction 作为 yield 返回的基类，有 Cortoutine, WaitForSecondes, WaitForEndOfFrame, WaitForFixedUpdate, WWW 几个子类实现。StartCoroutine 将 传入的 IEnumerator 封装为 Coroutine 返回，引擎会对 Corountines 存储和检查 IEnumerator 的 Current值。
③枚举了 WWW ,WaitForSeconds , null 和 WaitForEndOfFrame 检查 Current值在MonoBebaviour生存周期的时间（没有WaitForFixedUpdate ，D.S.Qiu猜测是其作者成文是Unity引擎还没有提供这个实现）：
WWW - after Updates happen for all game objects; check the isDone flag. If true, call the IEnumerator's MoveNext() function;
WaitForSeconds - after Updates happen for all game objects; check if the time has elapsed, if it has, call MoveNext();
null or some unknown value - after Updates happen for all game objects; Call MoveNext();
WaitForEndOfFrame - after Render happens for all cameras; Call MoveNext().
如果最后一个 yield return 的 IEnumerator 已经迭代到最后一个是，MoveNext 就会 返回 false 。这时，Unity就会将这个 IEnumerator 从 cortoutines list 中移除。
所以很容易一个出现的误解：协程 Coroutines 并不是并行的，它和你的其他代码都运行在同一个线程中，所以才会在Update 和 Coroutine中使用 同一个值时才会变得线程安全。这就是Unity对线程安全的解决策略——直接不使用线程，最近Unity 5 将要发布说的很热，看到就有完全多线程的支持，不知道是怎么实现的，从技术的角度，还是很期待的哈。
总结下： 在协程方法中使用 yield return 其实就是为了返回 IEnumerator对象，只有当这个对象的 MoveNext() 返回 false 时，即该 IEnumertator 的 Current 已经迭代到最后一个元素了，才会执行 yield return 后面的语句。也就是说， yield return 被会“翻译”为一个 IEnmerator 对象，要想深入了解这方面的更多细节，可以猛击⑤查看。
根据⑤ C# in depth 的理解——C# 编译器会生成一个 IEnumerator 对象，这个对象实现的 MoveNext() 包含函数内所有 yield return 的处理，这里仅附上一个例子：
using System;
using System.Collections;
class Test
{
static IEnumerator GetCounter()
{
for (int count = 0; count < 10; count++)
{
yield return count;
}
}
}
C#编译器对应生成：
internal class Test
{
// Note how this doesn't execute any of our original code
private static IEnumerator GetCounter()
{
return new <GetCounter>d__0(0);
}
// Nested type automatically created by the compiler to implement the iterator
[CompilerGenerated]
private sealed class <GetCounter>d__0 : IEnumerator<object>, IEnumerator, IDisposable
{
// Fields: there'll always be a "state" and "current", but the "count"
// comes from the local variable in our iterator block.
private int <>1__state;
private object <>2__current;
public int <count>5__1;
[DebuggerHidden]
public <GetCounter>d__0(int <>1__state)
{
this.<>1__state = <>1__state;
}
// Almost all of the real work happens here
private bool MoveNext()
{
switch (this.<>1__state)
{
case 0:
this.<>1__state = -1;
this.<count>5__1 = 0;
while (this.<count>5__1 < 10) //这里针对循环处理
{
this.<>2__current = this.<count>5__1;
this.<>1__state = 1;
return true;
Label_004B:
this.<>1__state = -1;
this.<count>5__1++;
}
break;
case 1:
goto Label_004B;
}
return false;
}
[DebuggerHidden]
void IEnumerator.Reset()
{
throw new NotSupportedException();
}
void IDisposable.Dispose()
{
}
object IEnumerator<object>.Current
{
[DebuggerHidden]
get
{
return this.<>2__current;
}
}
object IEnumerator.Current
{
[DebuggerHidden]
get
{
return this.<>2__current;
}
}
}
}
从上面的C#实现可以知道：函数内有多少个 yield return 在对应的 MoveNext() 就会返回多少次 true （不包含嵌套）。另外非常重要的一点的是：同一个函数内的其他代码（不是 yield return 语句）会被移到 MoveNext 中去，也就是说，每次 MoveNext 都会顺带执行同一个函数中 yield return 之前，之后 和两个 yield return 之间的代码。
对于Unity 引擎的 YieldInstruction 实现，其实就可以看着一个 函数体，这个函数体每帧会实现去 check MoveNext 是否返回 false 。 例如：
yield retrun new WaitForSeconds(2f);
上面这行代码的伪代码实现:
private float elapsedTime;
private float time;
private void MoveNext()
{
elapesedTime += Time.deltaTime;
if(time <= elapsedTime)
return false;
else return true;
}
增补于： 2014年04月22日 8:00
2）Cortoutine 扩展——Extending Coroutines: Return Values and Error Handling
不知道你们调用 StartCortoutine 的时候有没有注意到 StartCortoutine 返回了 YieldInstruction 的子类 Cortoutine 对象，这个返回除了嵌套使用 StartCortoutine 在 yiled retrun StartCortoutine 有用到，其他情况机会就没有考虑它的存在，反正D.S.Qiu是这样的，一直认为物“极”所用，所以每次调用 StartCortoutine 都很纠结，好吧，有点强迫症。
Unity引擎讲 StartCoroutine 传入的参数 IEnumerator 封装为一个 Coroutine 对象中，而 Coroutine 对象其实也是 IEnumerator 枚举对象。yield return 的 IEnumerator 对象都存储在这个 Coroutine 中，只有当上一个yield return 的 IEnumerator 迭代完成，才会运行下一个。这个在猜测下Unity底层对Cortountine 的统一管理（也就是上面说的检查 Current 值）：Unity底层应该有一个 正在运行的 Cortoutine 的 list 然后在每帧的不同时间去 Check。
还是回归到主题，上面介绍 yield 关键字有说不允许不安全块，也就是说不能出现在 try catch 块中，就不能在 yield return 执行是进行错误检查。③利用 StartCortoutine 返回值 Cortoutine 得到了当前的 Current 值和进行错误捕获处理。
先定义封装包裹返回值和错误信息的类：
public class Coroutine<T>{
public T Value {
get{
if(e != null){
throw e;
}
return returnVal;
}
}
private T returnVal; //当前迭代器的Current 值
private Exception e; //抛出的错误信息
public Coroutine coroutine;
public IEnumerator InternalRoutine(IEnumerator coroutine){
//先省略这部分的处理
}
}
InteralRoutine是对返回 Current 值和抛出的异常信息（如果有的话）：
public IEnumerator InternalRoutine(IEnumerator coroutine){
while(true){
try{
if(!coroutine.MoveNext()){
yield break;
}
}
catch(Exception e){
this.e = e;
yield break;
}
object yielded = coroutine.Current;
if(yielded != null && yielded.GetType() == typeof(T)){
returnVal = (T)yielded;
yield break;
}
else{
yield return coroutine.Current;
}
}
下面为这个类扩展MonoBehavior：
public static class MonoBehaviorExt{
public static Coroutine<T> StartCoroutine<T>(this MonoBehaviour obj, IEnumerator coroutine){
Coroutine<T> coroutineObject = new Coroutine<T>();
coroutineObject.coroutine = obj.StartCoroutine(coroutineObject.InternalRoutine(coroutine));
return coroutineObject;
}
}
最后给出一个 Example：
IEnumerator Start () {
var routine = StartCoroutine<int>(TestNewRoutine()); //Start our new routine
yield return routine.coroutine; // wait as we normally can
Debug.Log(routine.Value); // print the result now that it is finished.
}
IEnumerator TestNewRoutine(){
yield return null;
yield return new WaitForSeconds(2f);
yield return 10;
yield return 5;
}
最后输出是10,因为Cortoutine<T> 遇到满足条件的 T 类型就 执行 yield break;就不执行 yield return 5; 这条语句了。
如果将中 yield break; 语句去掉的话，最后输出的是 5 而不是10。
if(yielded != null && yielded.GetType() == typeof(T)){
returnVal = (T)yielded;
yield break;
}
其实就是Unity引擎每帧去 check yield return 后面的表达式，如果满足就继续向下执行。
下面在测试一个例子：连续两次调用 yield return coroutine;
private Coroutine routine1;
void Start ()
{
routine1 = StartCoroutine(TestCoroutineExtention1()); //Start our new routine
StartCoroutine(TestCortoutine());
}
IEnumerator TestCoroutineExtention1()
{
yield return new WaitForSeconds(1);
yield return 10;
Debug.Log("Run 10!");
yield return new WaitForSeconds(5);
yield return 5;
Debug.Log("Run 5!");
}
IEnumerator TestCortoutine()
{
//wwwState = true;
yield return routine1; // wait as we normally can
Debug.Log(" routine1");
yield return routine1; // wait as we normally can
Debug.Log(" routine2");
}
测试运行会发现只会输出：
Run 10!
Run 5!
routine1
总结下： yield return expression 只有表达式完全执行结束才会继续执行后面的代码，连续两次执行 yield return StartCortoutine() 的返回值是不会满足的，说明 yield return 有区分开始和结束的两种状态。
3）Cortoutine Locking
虽然Cortoutine不是多线程机制，但仍会“并发”问题——同时多次调用 StartCortoutine ，当然通过Unity提供的api也能得到解决方案，每次StartCoroutine 之前先调用 StopCortoutine 方法停止，但这利用的是反射，显然效率不好。④对③的方案进行了扩展提供了 Cortoutine Locking 的支持，使用字符串（方法名）来标记同一个 Coroutine 方法，对于同一个方法如果等待时间超过 timeout 就会终止前面一个 Coroutine 方法，下面直接贴出代码：
using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;
/// <summary>
/// Extending MonoBehaviour to add some extra functionality
/// Exception handling from: http://twistedoakstudios.com/blog/Post83_coroutines-more-than-you-want-to-know
///
/// 2013 Tim Tregubov
/// </summary>
public class TTMonoBehaviour : MonoBehaviour
{
private LockQueue LockedCoroutineQueue { get; set; }
/// <summary>
/// Coroutine with return value AND exception handling on the return value.
/// </summary>
public Coroutine<T> StartCoroutine<T>(IEnumerator coroutine)
{
Coroutine<T> coroutineObj = new Coroutine<T>();
coroutineObj.coroutine = base.StartCoroutine(coroutineObj.InternalRoutine(coroutine));
return coroutineObj;
}
/// <summary>
/// Lockable coroutine. Can either wait for a previous coroutine to finish or a timeout or just bail if previous one isn't done.
/// Caution: the default timeout is 10 seconds. Coroutines that timeout just drop so if its essential increase this timeout.
/// Set waitTime to 0 for no wait
/// </summary>
public Coroutine<T> StartCoroutine<T>(IEnumerator coroutine, string lockID, float waitTime = 10f)
{
if (LockedCoroutineQueue == null) LockedCoroutineQueue = new LockQueue();
Coroutine<T> coroutineObj = new Coroutine<T>(lockID, waitTime, LockedCoroutineQueue);
coroutineObj.coroutine = base.StartCoroutine(coroutineObj.InternalRoutine(coroutine));
return coroutineObj;
}
/// <summary>
/// Coroutine with return value AND exception handling AND lockable
/// </summary>
public class Coroutine<T>
{
private T returnVal;
private Exception e;
private string lockID;
private float waitTime;
private LockQueue lockedCoroutines; //reference to objects lockdict
private bool lockable;
public Coroutine coroutine;
public T Value
{
get
{
if (e != null)
{
throw e;
}
return returnVal;
}
}
public Coroutine() { lockable = false; }
public Coroutine(string lockID, float waitTime, LockQueue lockedCoroutines)
{
this.lockable = true;
this.lockID = lockID;
this.lockedCoroutines = lockedCoroutines;
this.waitTime = waitTime;
}
public IEnumerator InternalRoutine(IEnumerator coroutine)
{
if (lockable && lockedCoroutines != null)
{
if (lockedCoroutines.Contains(lockID))
{
if (waitTime == 0f)
{
//Debug.Log(this.GetType().Name + ": coroutine already running and wait not requested so exiting: " + lockID);
yield break;
}
else
{
//Debug.Log(this.GetType().Name + ": previous coroutine already running waiting max " + waitTime + " for my turn: " + lockID);
float starttime = Time.time;
float counter = 0f;
lockedCoroutines.Add(lockID, coroutine);
while (!lockedCoroutines.First(lockID, coroutine) && (Time.time - starttime) < waitTime)
{
yield return null;
counter += Time.deltaTime;
}
if (counter >= waitTime)
{
string error = this.GetType().Name + ": coroutine " + lockID + " bailing! due to timeout: " + counter;
Debug.LogError(error);
this.e = new Exception(error);
lockedCoroutines.Remove(lockID, coroutine);
yield break;
}
}
}
else
{
lockedCoroutines.Add(lockID, coroutine);
}
}
while (true)
{
try
{
if (!coroutine.MoveNext())
{
if (lockable) lockedCoroutines.Remove(lockID, coroutine);
yield break;
}
}
catch (Exception e)
{
this.e = e;
Debug.LogError(this.GetType().Name + ": caught Coroutine exception! " + e.Message + "\n" + e.StackTrace);
if (lockable) lockedCoroutines.Remove(lockID, coroutine);
yield break;
}
object yielded = coroutine.Current;
if (yielded != null && yielded.GetType() == typeof(T))
{
returnVal = (T)yielded;
if (lockable) lockedCoroutines.Remove(lockID, coroutine);
yield break;
}
else
{
yield return coroutine.Current;
}
}
}
}
/// <summary>
/// coroutine lock and queue
/// </summary>
public class LockQueue
{
private Dictionary<string, List<IEnumerator>> LockedCoroutines { get; set; }
public LockQueue()
{
LockedCoroutines = new Dictionary<string, List<IEnumerator>>();
}
/// <summary>
/// check if LockID is locked
/// </summary>
public bool Contains(string lockID)
{
return LockedCoroutines.ContainsKey(lockID);
}
/// <summary>
/// check if given coroutine is first in the queue
/// </summary>
public bool First(string lockID, IEnumerator coroutine)
{
bool ret = false;
if (Contains(lockID))
{
if (LockedCoroutines[lockID].Count > 0)
{
ret = LockedCoroutines[lockID][0] == coroutine;
}
}
return ret;
}
/// <summary>
/// Add the specified lockID and coroutine to the coroutine lockqueue
/// </summary>
public void Add(string lockID, IEnumerator coroutine)
{
if (!LockedCoroutines.ContainsKey(lockID))
{
LockedCoroutines.Add(lockID, new List<IEnumerator>());
}
if (!LockedCoroutines[lockID].Contains(coroutine))
{
LockedCoroutines[lockID].Add(coroutine);
}
}
/// <summary>
/// Remove the specified coroutine and queue if empty
/// </summary>
public bool Remove(string lockID, IEnumerator coroutine)
{
bool ret = false;
if (LockedCoroutines.ContainsKey(lockID))
{
if (LockedCoroutines[lockID].Contains(coroutine))
{
ret = LockedCoroutines[lockID].Remove(coroutine);
}
if (LockedCoroutines[lockID].Count == 0)
{
ret = LockedCoroutines.Remove(lockID);
}
}
return ret;
}
}
}
小结：
本文主要是对 Unity StartCoroutine 进行了理解，从C# 的yileld 和 IEnumerator 到 Unity 的 StartCoroutine，最后并对Cortoutine 进行了扩展，虽然感觉不是很实用（用到的情况非常至少），但还是有利于对Coroutine 的理解和思考。
对于第三部分的代码感觉有不妥，没有进行测试，附件里有代码，有需求的话请自取
如果您对D.S.Qiu有任何建议或意见可以在文章后面评论，或者发邮件（gd.s.qiu@gmail.com)交流，您的鼓励和支持是我前进的动力，希望能有更多更好的分享。
转载请在文首注明出处：http://dsqiu.iteye.com/blog/2049743
更多精彩请关注D.S.Qiu的博客和微博（ID：静水逐风）
参考：
①琪琪爸的程序学习笔记 :-P：http://www.cnblogs.com/easyfrog/archive/2011/12/29/IEnumerable_IEnumerator_yield.html
②杰仔：http://www.cnblogs.com/illele/archive/2008/04/21/1164696.html
③Twisted Oak Studios: http://twistedoakstudios.com/blog/Post83_coroutines-more-than-you-want-to-know
④tim tregubov：http://zingweb.com/blog/2013/02/05/unity-coroutine-wrapper/
⑤C# in Depth： http://csharpindepth.com/articles/chapter6/iteratorblockimplementation.aspx
⑥zhw1125： http://blog.sina.com.cn/s/blog_3e29b20b0100g6ix.html
相关推荐
Unity协程（Coroutine）原理深入剖析.pdf Unity协程（Coroutine）原理深入剖析.pdf Unity协程（Coroutine）原理深入剖析.pdf Unity协程（Coroutine）原理深入剖析.pdf Unity协程（Coroutine）原理深入剖析.pdf
本文将深入剖析Unity协程的工作原理，帮助开发者更好地理解和利用这一特性。 协程在Unity中的实现基于`yield`关键字。`yield`允许一个函数暂停执行，并在稍后恢复，而不是一次性执行完所有代码。`yield return`语句...
在Unity引擎中，协程（Coroutine）是一种独特的编程机制，它允许开发者在游戏逻辑中实现类似于异步操作的功能，而不必使用回调函数或线程。协程可以暂停执行并在稍后的时间点继续，这对于处理耗时操作如加载资源、...
本文将详细介绍 Unity3D 中的协程（Coroutine）技术，包括为什么需要协程、协程的定义和工作原理、如何使用协程等方面的知识点。 一、为什么需要协程 在游戏中，有许多过程需要花费多个逻辑帧去计算。如果我们不...
unity 协程详细说明。具体教程http://blog.csdn.net/fengya1/article/details/79380410
为了不阻塞游戏主循环，Unity3D引入了协程（Coroutine）的概念，允许开发者以非阻塞的方式处理长时间运行的任务，比如下载和加载资源。 **协程简介** 协程是一种轻量级的线程，它不像传统的多线程那样需要频繁地上...
Unity协程底层机制,嵌套协程原理,WaitForSeconds等YeildInstruction原理
本资料将深入探讨Unity协程的原理、使用方法以及常见应用场景。 一、协程基础 协程并非Unity独有，它是一种在多个执行点暂停和恢复的程序执行流。与线程不同，协程不会同时运行，它们是单线程的，但在同一时间片内...
Unity提供了一个Coroutine类，我们可以使用它来创建协程。 例如： ```csharp using UnityEngine; public class CoroutineExample : MonoBehaviour { void Start() { StartCoroutine(MyCoroutine()); } ...
在Unity3D游戏引擎中，协同程序（Coroutine）是一种强大的工具，它允许开发者在执行过程中暂停和恢复函数，实现非阻塞式的时间控制，比如延迟执行、动画播放、定时任务等。然而，有时我们需要在运行时终止这些协同...
在C#编程中，Unity3D引擎提供了一种独特的机制，称为协程（Coroutine），用于处理游戏中的异步操作和长时间运行的任务。协程在Unity中扮演着重要角色，允许开发者编写类似函数的序列，这些序列可以在不同的时间点...
unity协程优化插件
unity最新支持断点续传的方便，代码简单易懂。demo版本unity2021，参考文章：https://blog.csdn.net/chunyu90225/article/details/118545989
"Unity3d之截图方法" Unity3d中截图方法是游戏开发中常用的技术，以下是总结的三种截图方法： 方法一：使用Application类下的CaptureScreenshot方法 这个方法可以截取整个游戏的画面，也就是全屏截图。使用方法...
使用协程功能，使物体移动到预定位置，并通过协程返回到初始位置（返回位置可以任意设定）常用于完成循环动作的播放
Unity加载PPT是一种在Unity引擎中展示PowerPoint演示文稿的技术。这主要涉及到Unity与外部应用程序的交互，例如Microsoft PowerPoint，以及可能的数据交换格式，如XML或图片序列。以下是一些相关的知识点： 1. **...