unity3d 脚本参考-技术文档

一、 脚本概览
这是一个关于Unity内部脚本如何工作的简单概览。
Unity内部的脚本，是通过附加自定义脚本对象到游戏物体组成的。在脚本对象内部不同志的函数被特定的事件调用。最常用的列在下面：
Update：
这个函数在渲染一帧之前被调用，这里是大部分游戏行为代码被执行的地方，除了物理代码。
FixedUpdate：
这个函数在每个物理时间步被调用一次，这是处理基于物理游戏的地方。
在任何函数之外的代码：
在任何函数之外的代码在物体被加载的时候运行，这个可以用来初始化脚本状态。
注意：文档的这个部份假设你是用Javascript，参考用C#编写获取如何使用C#和Boo编写脚本的信息。
你也能定义事件句柄，它们的名称都以On开始，（例如OnCollisionEnter），为了查看完整的预定义事件的列表，参考MonoBehaviour 文档。

概览：常用操作
大多数游戏物体的操作是通过游戏物体的Transform或Rigidbody来做的，在行为脚本内部它们可以分别通过transform和rigidbody访问，因此如果你想绕着Y轴每帧旋转5度，你可以如下写：
function Update（）{
transform.Rotate(0,5,0);
}
如果你想向前移动一个物体，你应该如下写：
function Update（）{
transform.Translate(0,0,2);
}
概览：跟踪时间
Time类包含了一个非常重要的类变量，称为deltaTime，这个变量包含从上一次调用Update或FixedUpdate（根据你是在Update函数还是在FixedUpdate函数中）到现在的时间量。
所以对于上面的例子，修改它使这个物体以一个恒定的速度旋转而不依赖于帧率：
function Update（）{
transform.Rotate(0,5*Time.deltaTime,0);
}
移动物体：
function Update（）{
transform. Translate (0, ,0,2*Time.deltaTime);
}
如果你加或是减一个每帧改变的值，你应该将它与Time.deltaTime相乘。当你乘以Time.deltaTime时，你实际的表达：我想以10米/秒移动这个物体不是10米/帧。这不仅仅是因为你的游戏将独立于帧而运行，同时也是因为运动的单位容易理解。( 米/秒)
另一个例子，如果你想随着时间增加光照的范围。下面的表达式，以2单位/秒改变半 
径。
function Update (){
light.range += 2.0 * Time.deltaTime;
}
当通过力处理刚体的时候，你通常不必用Time.deltaTime，因为引擎已经为你考虑到了这一点。
概览：访问其他组件
组件被附加到游戏物体，附加Renderer到游戏物体使它在场景中渲染，附加一个Camera使它变为相机物体，所有的脚本都是组件，因为它们能被附加到游戏物体。
最常用的组件可以作为简单成员变量访问：
Component             可如下访问
Transform             transform
Rigidbody             rigidbody
Renderer              renderer
Camera                camera (only on camera objects)
Light                 light (only on light objects)
Animation             animation
Collider              collider
…等等。
对于完整的预定义成员变量的列表。查看Component，Behaviour和MonnoBehaviour类文档。如果游戏物体没有你想取的相同类型的组件，上面的变量将被设置为null。
任何附加到一个游戏物体的组件或脚本都可以通过GetComponent访问。
transform.Translate（0,3,0）;
//等同于
GetComponent(Transform).Translate(0, 1, 0);
注意transfom和Transform之间大小写的区别，前者是变量（小写），后者是类或脚本名称（大写）。大小写不同使你能够从类和脚本名中区分变量。
应用我们所学，你可以使用GetComponent找到任何附加在同一游戏物体上的脚本和组件，请注意要使用下面的例子能够工作，你需要有一个名为OtherScript的脚本，其中包含一个DoSomething函数。OtherScript脚本必须与下面的脚本附加到相同的物体上。
//这个在同一游戏物体桑找到名为OtherScript的脚本
//并调用它上加的DoSomething
function Update(){
otherScript = GetComponent(OtherScript);
otherScript.DoSomething();
}
概览：访问其它游戏物体
大多数高级的代码不仅需要操作一个物体，Unity脚本接口有各种方法来找到并访问其他游戏物体和组件。在下面，我们假定有个一名为OtherScript,js的脚本附加到场景的游戏物体上。
var foo = 5;
function DoSomething ( param : String) {
print(param + " with foo: " + foo);
}
1.通过检视面板赋值引用
你可以通过检视面板赋值变量到任何物体 
//变换拖动到target的物体
var target : Transform;
function Update ()
{
target.Translate(0, 1, 0);
}
你也可以在检视面板中公开到其他物体的引用，下面你可以拖动一个包含的游戏物体到检视面板中的target槽。
//设置在检视面板中赋值的target变量上的foo，调用DoSomething
var target : OtherScript;
function Update ()
{
//设置target物体的foo变量
target.foo = 2;
// 调用target上的DoSomething
target.DoSomething("Hello");
}
2.通过物体层次定位
对于一个已经存在的物体，可以通过游戏物体的Transform组件来找到子和父物体；
//找到脚本所附加的
//游戏物体的子“Hand”
transform.Find("Hand").Translate(0, 1, 0);
一旦在层次视图中找到这个变换，你可以使用GetComponent来获取其他脚本，
//找到名为“Hand”的子
//在附加到它上面的OtherScript中，设置foo为2；
transform.Find("Hand").Translate(0, 1, 0);
//找到名为“Hand”的子
//然后应用一个力到附加在hand上的刚体
transform.Find("Hand").GetComponent(OtherScript).DoSomething("Hello");
// 找到名为“Hand”的了
// 然后应用一个力到附加在hand上的刚体
transform.Find("Hand").rigidbody.AddForce(0, 10, 0);
你可以循环所有的子，
//变换的所有子向上移动10个单位
for (var child : Transform in transform)
{
child.Translate(0, 1, 0);
}
参考Transform类文档获取更多信息。
3.根据名称或标签定位.
你可以使用GameObject.FindWithTag和GameObject.FindGameObjectsWithTag搜索具有特定标签的游戏物体，使用GameObject.Find根据名称查找物体。
function Start ()
{
// 按照名称
var go = GameObject.Find("SomeGuy");
go.transform.Translate(0, 1, 0);
// 按照标签
 
var player = GameObject.FindWithTag("Player");
player.transform.Translate(0, 1, 0);
}
你可以在结果上使用GetComponent，在找到的游戏物体上得到任何脚本或组件。
function Start ()
{
// 按名称
var go = GameObject.Find("SomeGuy");
go.GetComponent(OtherScript).DoSomething();

// 按标签
var player = GameObject.FindWithTag("Player");
player.GetComponent(OtherScript).DoSomething();
}
一些特殊的物体有快捷方式，如主相机使用Camera.main。
4.作为参数传递
一些事件消息在事件包含详细信息。例如，触发器事件传递碰撞物体的Collider组件到处理函数。
OnTriggerStay给我们一个到碰撞器的引用。从这个碰撞器我们可以获取附加到其上的刚体。
function OnTriggerStay( other : Collider ) {
// 如果另一个碰撞器也有一个刚体
// 应用一个力到它上面
if (other.rigidbody) {
other.rigidbody.AddForce(0, 2, 0);
}
}
或者我们可以通过碰撞器获取附加在同一个物体上的任何组件。
function OnTriggerStay( other : Collider ) {
// 如果另一个碰撞器附加了OtherScript
// 调用它上面的DoSomething
// 大多数时候碰撞器不会附加脚本
// 所以我们需要首先检查以避免null引用异常
if (other.GetComponent(OtherScript)) {
other.GetComponent(OtherScript).DoSomething();
}
}
注意通过上述例子中的other变量，你可以访问碰撞物体中的任何组件。
5.一种类型的所有脚本
使用Object.FindObjectsOfType找到所有具有相同类或脚本名称的物体，或者使用Object.FindObjectOfType.找到这个类型的第一个物体。
function Start ()
{
// 找到场景中附加了OtherScript的任意一个游戏物体
var other : OtherScript = FindObjectOfType(OtherScript);
other.DoSomething();
}
概览：向量
Unity使用Vector3类同一表示全体3D向量，3D向量的不同组件可以通过想x，y和z成员变量访问。
var aPosition : Vector3;
aPosition.x = 1;
aPosition.y = 1;
aPosition.z = 1;
你也能够使用Vector3构造函数来同时初始化所有组件。
var aPosition = Vector3(1, 1, 1);
Vector3也定义了一些常用的变量值。
var direction = Vector3.up; // 与 Vector3(0, 1, 0);相同
单个向量上的操作可以使用下面的方式访问：
someVector.Normalize();
使用多个向量的操作可以使用Vector3类的数；
theDistance = Vector3.Distance(oneVector, otherVector);
（注意你必须在函数名之前写Vector3来告诉JavaScript在哪里找到这个函数，这适用于所有类函数）
你也可以使用普通数学操作来操纵向量。 
combined = vector1 + vector2;
查看Vector3类文档获取完整操纵和可用属性的列表。
概览：成员变量 & 全局变量变量
定义在任何函数之外的变量是一个成员变量。在Unity中这个变量可以通过检视面板来访问，任何保存在成员变量中的值也可以自动随工程保存。
var memberVariable = 0.0;
上面的变量将在检视面板中显示为名为"Member Variable"的数值属性。
如果你设置变量的类型为一个组件类型（例如Transform, Rigidbody, Collider，任何脚本名称，等等）然后你可以在检视面板中通过拖动一个游戏物体来设置它们。
var enemy : Transform;
function Update()
{
if ( Vector3.Distance( enemy.position, transform.position ) < 10 );
print("I sense the enemy is near!");
}
}
你也可以创建私有成员变量。私有成员变量可以用来存储那些在该脚本之外不可见的状态。私有成员变量不会被保存到磁盘并且在检视面板中不能编辑。当它被设置为调试模式时，它们在检视面板中可见。这允许你就像一个实时更新的调试器一样使用私有变量。
private var lastCollider : Collider;
function OnCollisionEnter( collisionInfo : Collision ) {
lastCollider = collisionInfo.other;
}
全局变量
你也可以使用static关键字创建全局变量
这创造了一个全局变量，名为someGlobal
// 'TheScriptName.js'中的一个静态变量
static var someGlobal = 5;
// 你可以在脚本内部像普通变量一样访问它
print(someGlobal);
someGlobal = 1;
为了从另一个脚本访问它，你需要使用这个脚本的名称加上一个点和全局变量名。
print(TheScriptName.someGlobal);
TheScriptName.someGlobal = 10;
概览：实例化
实例化，复制一个物体。包含所有附加的脚本和整个层次。它以你期望的方式保持引用。到外部物体引用的克隆层次将保持完好，在克隆层次上到物体的引用映射到克隆物体。
实例化是难以置信的快和非常有用的。因为最大化地使用它是必要的。
例如， 这里是一个小的脚本，当附加到一个带有碰撞器的刚体上时将销毁它自己并实例化一个爆炸物体。
var explosion : Transform;
// 当碰撞发生时销毁我们自己
// 并生成给一个爆炸预设
function OnCollisionEnter (){
Destroy (gameObject);
var  theClonedExplosion : Transform; 
theClonedExplosion = Instantiate(explosion, transform.position, transform.rotation); 
}
实例化通常与预设一起使用
概览：Coroutines & Yield
在编写游戏代码的时候，常常需要处理一系列事件。这可能导致像下面的代码。
private var state = 0;
function Update()
{
if (state == 0) {
// 做步骤0
state = 1;
return;
}
if (state == 1) {
// 做步骤1
state = 2;
return;
}
// …
}
更方便的是使用yield语句。yield语句是一个特殊类型的返回，这个确保在下次调用时该函数继续从该yield语句之后执行。
while(true) {
// 做步骤0
yield; //等待一帧
// 做步骤1
yield; //等待一帧
// ...
}
你也可以传递特定值给yield语句来延迟Update函数的执行，直到一个特定的事件发生。
// 做一些事情
yield WaitForSeconds(5.0); //等待5秒
//做更多事情…
可以叠加和连接coroutines。
这个例子执行Do，在调用之后立即继续。
Do ();
print ("This is printed immediately");
function Do ()
{
print("Do now");
yield WaitForSeconds (2);
print("Do 2 seconds later");
}
这个例子将执行Do并等待直到它完成，才继续执行自己。
//链接coroutine
yield StartCoroutine("Do");
print("Also after 2 seconds");
print ("This is after the Do coroutine has finished execution");
function Do ()
{
print("Do now");
yield WaitForSeconds (2);
print("Do 2 seconds later"); 
}
任何事件处理句柄都可以是一个coroutine
注意你不能在Update或FixedUpdate内使用yield，但是你可以使用StartCoroutine来开始一个函数。
参考YieldInstruction, WaitForSeconds, WaitForFixedUpdate, Coroutine and MonoBehaviour.StartCoroutine获取更多使用yield的信息。
概览：用C#编写脚本
除了语法，使用C#或者Boo编写脚本还有一些不同。最需要注意的是：
1.从MonoBehaviour继承
所有的行为脚本必须从MonoBehaviour继承（直接或间接）。在Javascript中这自动完成，但是必须在C#或Boo脚本中显示申明。如果你在Unity内部使用Asset -> Create -> C Sharp/Boo Script菜单创建脚本，创建模板已经包含了必需的定义。
public class NewBehaviourScript : MonoBehaviour {...} // C#
class NewBehaviourScript (MonoBehaviour): ... # Boo
2.使用Awake或Start函数来初始化
Javascript中放置在函数之外的代码，在C#或Boo中要放置在Awake或Start中。
Awake和Start的不同是Awake在场景被加载时候运行，而Start在第一次调用Update或FixedUpdate函数之前被调用，所有Awake函数在任何Start函数调用之前被调用。
3.类名必须与文件名相同
Javascript中，类名被隐式地设置为脚本的文件名（不包含文件扩展名）。在c#和Boo中必须手工做。
4.在C#中Coroutines有不同语法。
Coroutines必有一个IEnumerator返回类型，并且yield使用yield return… 而不是yield…
using System.Collections;
using UnityEngine;
public class NewBehaviourScript : MonoBehaviour {
// C# coroutine
IEnumerator SomeCoroutine ()
{
// 等一帧
yield return 0;
//等两秒
yield return new WaitForSeconds (2);
}
}
5．不要使用命名空间
目前Unity还不支持将代码放置在一个命名空间中，这个需要将会出在未来的版本中。
6.只有序列化的成员变量会显示在检视面板中
私有和保护成员变量只在专家模式中显示，属性不被序列化或显示在检视面板中。
7．避免使用构造函数
不要在构造函数中初始化任何变量，使用Awake或Start实现这个目的。即使是在编辑模式中Unity也自动调用构造函数，这通常发生在一个脚本被编译之后，因为需要调用构造函数来取向一个脚本的默认值。构造函数不仅会在无法预料的时刻被调用，它也会为预设或未激活的游戏物体调用。 
单件模式使用构造函数可能会导致严重的后果，带来类似随机null引用异常。
因此如果你想实现，如，一个单件模式，不要使用构造函数，而是使用Awake。其实上，没有理由一定要在继续自MononBehaviour类的构造函数中写任何代码。
概览：最重要的类
Javascript中可访问的全局函数或C#中的基类
移动/旋转物体
动画系统
刚体
FPS或第二人称角色控制器
概览：性能优化
1．使用静态类型
在使用Javascript时最重要的优化是使用静态类型而不是动态类型，Unity使用一种叫做类型推理的技术来自自动转换Javascript为静态类型编码而不需要你做任何工作。
var foo=5；
在上面的例子里foo会自动被推断为一个整型值。因此，Unity可能使用大量的编译时间来优化。而不使用耗时的动态名称变量查找等。这就是为什么Unity比其他在JavaScript的实现平均快20倍的原因之一。
唯一的问题是，有时并非一切都可以做类型推断。Unity将会为这些变量重新使用动态类型。通过回到动态类型，编写JavaScript代码很简单。但是这也使得代码运行速度较慢。
让我们看一些例子：
function Start ()
{
var foo = GetComponent(MyScript);
foo.DoSomething();
}
这里foo将是动态类型，因此调用DoSomething函数将使用较长时间，因为foo的类型是未知的，它必须找出它是否支持DoSomething函数，如果支持，调用它。
function Start ()
{
var foo : MyScript = GetComponent(MyScript);
foo.DoSomething();
}
这里我们强制foo为指定类型，你将获得更好的性能。
2．使用#pragma strict
当然现在问题是，你通常没有意识到你在使用动态类型。#pragma strict解决了这个！简单的在脚本顶部添加#pragma strict。然后，unity将在脚本中禁用动态类型，强制使用静态类型，如果一个类型未知。Unity将报告编译错误。那么在这种情况下foo将在编译时产生一个错误：
#pragma strict
function Start ()
{
var foo = GetComponent(MyScript);
foo.DoSomething();
}
3.缓存组件查找
另一个优化是组件缓存。不幸的是该优化需要一点编码，并且不一定是值得的，但是如 
果你的脚本是真的用了很长时间了，你需要把最后一点表现出来，这是一个很好的优化。
当你访问一个组件通过GetComponent或访问变量，Unity会通过游戏对象找到正确的组件。这一次可以很容易地通过缓存保存在一个私有变量里引用该组件。
简单地把这个：
function Update () 
{
transform.Translate(0, 0, 5);
}
变成：
private var myTransform : Transform;
function Awake ()
{
myTransform = transform;
}
function Update ()
{
myTransform.Translate(0, 0, 5);
}
后者的代码将运行快得多，因为Unity没有找到变换在每一帧游戏组件中的对象。这同样适用于脚本组件，在你使用GetComponent代替变换或者其它的东西。
4.使用内置数组
内置数组的速度非常快，所以请使用它们。
而整列或者数组类更容易使用，因为你可以很容易地添加元素，他们几乎没有相同的速度。内置数组有一个固定的尺寸，但大多数时候你事先知道了最大的大小在可以只填写了以后。关于内置数组最好的事情是，他们直接嵌入在一个结构紧凑的缓冲区的数据类型没有任何额外的类型信息或其他开销。因此，遍历是非常容易的，作为一切缓存在内存中的线性关系。
private var positions : Vector3[];
function Awake ()
{
positions = new Vector3[100];
for (var i=0;i<100;i++)
positions[i] = Vector3.zero;
}
5.如果你不需要就不要调用函数
最简单的和所有优化最好的是少工作量的执行。例如，当一个敌人很远最完美的时间就是敌人入睡时可以接受。直到玩家靠近时什么都没有做。这是种缓慢的处理方式的情况：
function Update ()
{
// 早期进行如果玩家实在是太遥远。
if (Vector3.Distance(transform.position, target.position) > 100)
return;
perform real work work...
}
这不是一个好主意，因为Unity必须调用更新功能，而你正在执行工作的每一个帧。一个比较好的解决办法是禁用行为直到玩家靠近。有3种方法来做到这一点：
1.使用OnBecameVisible和OnBecameInvisible。这些回调都是绑到渲染系统的。只要任何相机可以看到物体，OnBecameVisible将被调用，当没有相机看到任何一个，OnBecameInvisible将被调用。这种方法在很多情况下非常有用，但通常在AI中并不是特别有用，因为只要你把相机离开他们敌人将不 
可用。
function OnBecameVisible () {
enabled = true;
}
function OnBecameInvisible ()
{
enabled = false;
}
2.使用触发器。一个简单的球形触发器会工作的非常好。一旦你离开这个影响球你将得到OnTriggerEnter/Exit调用。
function OnTriggerEnter (c : Collider)
{
if (c.CompareTag("Player"))
enabled = true;
}
function OnTriggerExit (c : Collider)
{
if (c.CompareTag("Player"))
enabled = false;
}
3.使用协同程序。Update调用的问题是它们每帧中都发生。很可能会只需要每5秒检检查一次到玩家的距离。这应该会节省大量的处理周期。
概览：脚本编译（高级）
Unity编译所有的脚本为.NET dll文件，.dll将在运行时编译执行。
这允许脚本以惊人的速度执行。这比传统的javascript快约20倍。比原始的C++代码慢大约50%。在保存的时候，Unity将花费一点时间来编译所有脚本，如果Unity还在编译。你可以在Unity主窗口的右下角看到一个小的旋转进度图标。
脚本编译在4个步骤中执行：
1.所有在"Standard Assets", "Pro Standard Assets" 或 "Plugins"的脚本被首先编译。
在这些文件夹之内的脚本不能直接访问这些文件夹之外脚本。
不能直接引用或它的 变量，但是可以使用GameObject.SentMessage与它们通信。
2.所有在"Standard Assets/Editor", "Pro Standard Assets/Editor" 或 "Plugins/Editor"的脚本被首先编译。
如果你想使用UnityEditor命名空间你必须放置你的脚本在这些文件夹中，例如添加菜单项或自定义的向导，你都需要放置脚本到这些文件夹。
这些脚本可以访问前一组中的脚本。
3.然后所有在"Editor"中的脚本被编译。
如果你想使用UnityEditor命名空间你必须放置你的脚本在这些文件夹中。例如添加菜单单项或自定义的向导，你都需要放置脚本到这些文件夹。
这些脚本可以访问所有前面组中的脚本，然而它们不能访问后面组中的脚本。
这可能会是一个问题，当编写编辑器代码编辑那些在后面组中的脚本时。有两个解决方法：1、移动其他脚本到"Plugins"文件夹 2、利用JavaScript的动态类型，在javascript中你不需要知道类的类型。在使用GetComponent时你可以使用字符串而不是类型。你也可以使用SendMessage，它使用一个字符串。
4.所有其他的脚本被最后编译
所有那些没有在上面文件夹中的脚本被最后编译。
所有在这里编译的脚本可以访问第一个组中的所有脚本（"Standard Assets"，"Pro 
Standard Assets" or "Plugins"）。这允许你让不同的脚本语言互操作。例如，如果你想创建一个JavaScript。它使用一个C#脚本;放置C#脚本到"Standard Assets"文件夹并且JavaScript放置在"Standard Assets"文件夹之外。现在JavaScript可以直接引用c#脚本。
放置在第一个组中的脚本，将需要较长的编译时间，因为当他们被编译后，第三组需要被重新编译。因此如果你想减少编译时间，移动那些不常改变 的到第一组。经常改变的到第四组。 
二、 运行时类
AnimationCurve
类
动画曲线，在给定的时间添加关键帧并确定曲线。
变量
◆  var keys : Keyframe[]
描述：定义在动画曲线中的所有键。这让你从数组中清理，添加或移除键。
如果键没有按照时间顺序，它们会在赋值的时候自动排序。
◆  var length : int
描述：曲线中键的数量（只读）。
◆  var preWrapMode : WrapMode
描述：第一帧之前动画的行为。
◆  var this[index : int] : Keyframe
描述：取向索引为index的键（只读）。
构造函数
◆  static function AnimationCurve(params keys : Keyframe[]) : AnimationCurve
描述：从任意数量的关键帧创建一个动画曲线。
该函数从可变数量的Keyframe参数创建一个曲线，如果你想从一个关键帧数组中创建一个曲线，创建一个空的曲线并指定keys属性。
//一个慢退慢出的动画曲线（切线都是平的）。
var curve = new AnimationCurve(Keyframe(0, 0), Keyframe(1, 1);
function Update ()
{
transform.position.x = Time.time;
transform.position.y = curve.Evaluate(Time.time);
}
◆  static function AnimationCurve () : AnimationCurve
描述：创建一个空的动画曲线
函数
◆  function AddKey (time : float, value : float) : int
描述：添加一个新的键到曲线。
平滑切线将被自动为该键的计算，返回该键的索引，如果因为在同一时间上已经有另一个关键帧而不能添加键，将返回-1。
◆  function AddKey (key : Keyframe) : int
描述：添加一个新的键到曲线。
返回该键的索引，如果因为在同一时间上已经有另一个关键帧而不能添加键，将返回-1。
◆  function Evaluate (time : float) : float
描述：该动画曲线在time的值。
◆  function MoveKey (index : int, key : Keyframe) : int
描述：移除index处的关键帧并插入键。
如果一个关键帧已经存在于key-time，老的关键帧位置时间key[index].time/将被用来替换，这对于在一个曲线编辑器中拖动关键帧是一个理想的行为，移动它后返回关键帧的索引。
◆  function RemoveKey (index : int) : void
描述：移除一个键
◆  function SmoothTangents (index : int, weight : float) : void
描述：平滑位于index处的关键帧的进出切线。
权值为0时平均切线。
类方法
◆  static function EaseInOut (timeStart : float, valueStart : float, timeEnd : float, valueEnd : float) : AnimationCurve
描述：一个渐进渐出的曲线，开始于timeStart,valueStart并结束于timeEnd, valueEnd.
◆  static function Linear (timeStart : float, valueStart : float, timeEnd : float, valueEnd : float) : AnimationCurve
描述：一个直线，开始于timeStart,valueStart并结束于timeEnd, valueEnd.
AnimationEvent
类
AnimationEvent类似于SendMessage让你调用一个脚本函数，这个脚本是动画播放的一部分。 
变量
◆  var animationState : AnimationState 
描述：引发这个事件的动画状态。
当这个方法在动画事件回调之外被调用用时返回null。
◆  var date：string
描述：存储在动画剪辑中的字符串数据并将被发送到动画事件。
◆  var functionName : string
描述：被调用的函数的名称
这与调用gameObject.SendMessage(animationEvent.functionName,animationEvent)相同；
◆  var messageOptions ：SendMessageOptions
描述：如果选项被设置为SendMessageOptions.RequireReceiver（缺省），当消息没有被任何组件接收时将打印一个错误消息。
◆  var time:float
描述：该事件被引发的时间。
构造函数
◆  static function AnimationEvent () : AnimationEvent
描述：创建一个新的动画事件
AnimationState
类
AnimationState完全控制动画混合。
在大多数情况下Animation接口就足够了，并且更容易使用。如果你需要完全控制动画播放过程中的混合时，使用AnimationState。
当动画播放时，AnimationState允许你修改速度，权值。时间和层。也可以设置动画合成和wrapMode
动画
变量
◆  var blendMode : AnimationBlendMode
描述：使用哪个混合模式？
// 设置leanLeft动画为附加混合
animation["leanLeft"].blendMode = AnimationBlendMode.Additive;
◆  var clip ：AnimationClip 
描述：该动画状态播放的剪辑。
// 打印动画剪辑的帧频到控制台
print（animation[“walk”]clio.frameRate）；
◆  var enabled : bool
描述：启用/禁用动画
对于需要考虑任何影响的动画，权值需要设置成为一个大于零的值。如果动画被禁用，时间将暂停直到动画再次启用。
// 启用walk循环
animation["Walk"].enabled = true;
animation["Walk"].weight = 1.0;
◆  var layer : int
描述：动画的层。在计算混合权值时，位于较高层的动画将首先获得它们的权值。
只有较高层的动画没有使用完全全部权值时，较低层的动画才能接收混合权值。
// 放置walk和run动画在层1
animation["Walk"].layer = 1;
animation["Run"].layer = 1;
◆  var length : float
描述：动画剪辑的长度，以秒计。
// 打印Walk动画的长度
print (animation["Walk"].length);
◆  var name ：string
描述：动画的名称。
◆  var normalizedSpeed : float
描述：归一化播放速度。
这最常用于混合两个动画时同步播放速度。在多数情况下使用animation.SyncLayer是更容易也更好
// 同步run和walk速度
animation["Run"].normalizedSpeed = animation["Walk"].speed;
◆  var normalizedTime : float
描述：动画的当前归一化时间。
1为动画的末端。 0.5为动画的中部。
// 快进到动画的中部
animation["Walk"].normalizedTime = 0.5;
◆  var speed : float
描述：动画的播放速度。1为正常播放速度。
负的播放速度将回放动画。
// 向后走
animation["Walk"].speed = -1.0;
// 以双倍速度行走
animation["Walk"].speed = 2;
◆  var time ：float
描述：动画的当前时间
如果时间大于长度它将按照wrapMode回绕。该值可以大于动画的长度。看这种情况下播放模式将在采样前重映射时间。这个值从0到无穷。
// 回退walk动画
animation["Walk"].time = 0.0;
◆  var weight : float
描述：动画的权值
// 设置walk动画的混合权值为0.5
animation["Walk"].weight = 0.5;
◆  var wrapMode : WrapMode
描述：动画的回绕模式
默认的wrapMode被初始化为在Animation组件中设置的回绕模式值。
// 设置walk动画回绕模式为循环
animation["Walk"].wrapMode = WrapMode.Loop;
函数
◆  function AddMixingTransform (mix : Transform, recursive : bool = true) : void
描述：添加应该被动画的变换。这允许你缩减需要创建的动画数量。
例如你可能有一个挥手的动画。你可能想在一个空闲角色或行走的角色上播放挥手动画。那么你需要为空闲和行走分别创建挥手动画。运用合成挥手动画，它将由肩膀完全控制。但是下半身不会受它的影响，继续播放空闲或行走动画。因此你只需要一个挥手动画。
如果recursive为真，所有mix变换的子也都将被动画。如果你不调用AddMixingTransform,所有动画曲线将被使用。
// 使用路径添加混合
var shoulder : Transform;
animation["wave_hand"].AddMixingTransform(shoulder);
function Start ()
{
//使用路径添加混合变换
var mixTransform = transform.Find("root/upper_body/left_shoulder");
animation["wave_hand"].AddMixingTransform(mixTransform);
}
Application
类
访问应用程序的运行时数据。
这个类包含静态的方法来查找相关的信息并控制运行时数据。
类变量
◆  static var absoluteURL : string
描述：到web播放器数据文件夹的绝对路径（只读）。
Application.absoluteURL 和Application.srcValue允许你检测unityWeb数据文件是否被移动或链接接到其他位置。你也许想保护这两者来防止盗用数据文件的行为。 
// 检测你的数据文件是否被移动到其他的服务器
// 或是被链接到其他地方
function Start ()
{
var isPirated = false;
if (Application.platform == RuntimePlatform.WindowsWebPlayer ||Application.platform == RuntimePlatform.OSXWebPlayer)
{
if (Application.srcValue != "game.unity3d")
isPirated = true;
if (String.Compare (Application.absoluteURL,http://www.website.com/Game/game.unity3d,true)!=0)
isPirated = true;
if (isPirated)
print("Pirated web player");
}
}
◆  static var dataPath : string
描述：包含游戏数据文件夹的路径（只读）。
这个值依赖于运行的平台：
Unity 编辑器：     <工程文件夹的路径>/Assets
Mac播放器：       <到播发器应用的路径>/Contents
Win播放器：       < 包含可执行播发器的文件夹的路径>\Data
Dasboard窗口：    < dashboard widget bundle的路径>
Web播放器：       到播放器数据文件夹的绝对路径（没有实际的数据文件名称）
// 打印到数据文件夹的路径
Print（Application.dataPath）；
◆  static var isEditor : bool
描述：是在Unity编辑器内运行？（只读）
如果游戏从Unity编辑器中运行，返回真；如果从其他部署目标运行返回假。
if (Application.isEditor)
{
print("We are running this from inside of the editor!");
}
◆  static var isLoadingLevel : bool
描述：正在加载某些关卡？（只读）
LoadLevel 和 LoadLevelAdditive不会立即发生 一个新的关卡在当前游戏帧之后被加载。如果关卡加载所请求的帧已经完成isLoadingLevel返回true。
参见：LoadLevel，LoadLevelAdditive
◆  static var isPlaying : bool
描述：在任何类型的播放器中时返回真（只读）。
在Unity编辑器中，如果处于播放模式时返回真。
if (Application.isPlaying)
{
print("In player or playmode");
}
◆  static var levelCount : int
描述：可用的总关卡数（只读）。 
// 加载一个随机的关卡
Application.LoadLevel (Random.Range(0, Application.levelCount-1));
◆  static var loadedLevel : int
描述：最后一个被加载的关卡的索引（只读）。
print (Application.loadedLevel);
◆  static var loadedLevelName : string
描述：最后一个被加载的关卡的名称（只读）。
print (Application.loadedLevelName);
◆  static var platform : RuntimePlatform
描述：返回游戏运行的平台（只读）。
如果你要做一些平台相关的操作使用这个属性。参见：RuntimePlatform
function Start ()
{
if (Application.platform == RuntimePlatform.WindowsPlayer)
print ("Do something special here!");
}
◆  static var runInBackground : bool
描述：应用程序在后太时是否应该被运行？
默认为假（当程序在后台时暂停）。
// 让游戏运行，即使是在后台
Application.runInBackground = true;
◆  static var srcValue : string
描述：相对于html文件的web播放器数据文件的路径（只读）。
这是被写到html文件中的路径，它是作为object的src参数和cmbed标签。因此如果它是绝对url，srcvalue将含有绝对路径。
Application.absoluteURL 和 Application.srcValue允许你检测你的unityWeb数据文件是否被移动或链接到其他位置。你也许想保护这两者来阻止盗用数据文件的行为。
// 检测你的数据文件是否被移到其他的服务器
// 或是被链接到其他地方
function Start ()
{
Var isPirated = false;
if (Application.platform == RuntimePlatform.WindowsWebPlayer ||Application.platform == RuntimePlatform.OSXWebPlayer)
{
if (Application.srcValue != "game.unity3d")
isPirated = true;
if (String.Compare (Application.absoluteURL,"http://www.website.com/Game/game.unity3d",true)!= 0)
isPirated = true;
if (isPirated)
print("Pirated web player");
}
}
◆  static var streamedBytes : int
描述：我们从主Unityweb流中下载了多少字节（只读）。
在web播放器中这将返回到目前为止已经下载的压缩字节数。在独立模式或编辑器中 
这个总是返回零。
参见：GetStreamProgressForLevel函数
◆  static var targetFrameRate : int
描述：命令游戏尝试以一个特定的帧率渲染。
设置targetFrameRate为-1（默认）使独立版游戏尽可能快的渲染，并且web播放器游戏以50-60帧/秒渲染，取决于平台。
注意设置targetFrameRate不会保证帧率，会因为平台的不同而波动，或者因为计算机太慢而不能取得这个帧率。
在编辑器中targetFrameRate被忽略。
◆  static var unityVersion : string
描述：用于播放内容的Unity运行时版本。
类方法
◆  static function CancelQuit () : void
描述：取消退出。这可以用来在退出游戏的时候显示一个退出画面。
这个函数只工作在播发器中，在web播放器或编辑器中不做任何事。
// 延迟2秒退出。
// 在这段时间内加载退出画面
var showSplashTimeout = 2.0;
private var allowQuitting = false;
function Awake () {
// 需要在多个关卡中使用的游戏物体
DontDestroyOnLoad (this);
}
function OnApplicationQuit () {
// 如果我们还没有加载到最后的退出画面
if (Application.loadedLevelName.ToLower()!= "finalsplash")
StartCoroutine("DelayedQuit");
// Don't allow the user to exit until we got permission in
if (!allowQuitting)
Application.CancelQuit();
}
function DelayedQuit ()
{
Application.LoadLevel("finalsplash");
// 等待showSplashTimecout
yield WaitForSeconds(showSplashTimeout);
// 然后退出
allowQuitting = true;
Application.Quit();
}
◆  static function CanStreamedLevelBeLoaded(levelIndex : int) : bool
描述：可以加载流式关卡了吗？
参见：GetStreamProgressForLevel函数。
 
◆  static function CanStreamedLevelBeLoaded(levelName : string) : bool
描述：可以加载流式关卡了吗？
参见：GetStreamProgressForLevel函数。
◆  static function CaptureScreenshot(filename : string) : void
描述：截取屏幕为PNG文件放置在路径filename。
如果文件已经存在，它将被覆盖。如果在web播放器或者Dashboard窗口中使用该函数，它将不做任何事情。
function OnMouseDown () {
Application.CaptureScreenshot("Screenshot.png");
}
◆  static function ExternalCall(functionName:string,params args:object[]):void
描述：调用一个包含中网页中的函数（只用于Web Player）。
调用包含在网页中名为functionNameJavaScript函数，并传递给定的参数。支持原始的数据类型(string, int, float, char)和这些类型的数字。如何其他的对象被转化为字符串（使用ToString方法）并作为字符串传递。
传递的参数数量是可变的。
// 调用网页上的MyFunction1并不使用参数。
Application.ExternalCall ("MyFunction1");
//调用网页上的MyFunction2并使用字符串参数。
Application.ExternalCall ("MyFunction2", "Hello from Unity!");
//调用网页上的MyFunction3并使用几个不同类型的参数。
Application.ExternalCall ("MyFunction3", "one", 2, 3.0);
被调用的在HTML中的函数只需要使用标准的语法即可，例如：
<script language="JavaScript" type="text/javascript">
<!—
// 使用来自Unity的调用，这将接受
// "Hello from Unity!" 做为参数
function MyFunction2( arg )
{
alert( arg );
}
-->
</script>
See Also: Browser to Unity communication, Application.ExternalEval.
◆  static function ExternalEval (script : string) : void
描述：调用包含在网页中的片段脚本函数（只用于Web Player）。
这将执行包含在网页中JavaScript片段script
// 导航到前一个页面
Application.ExternalEval ("history.back()");
See Also: Browser to Unity communication, Application.ExternalCall.
◆  static function GetStreamProgressForLevel(levelIndex : int) : float
描述：下载了多少？
在web播放器中这将返回这个关卡的进度。
参见：CanStreamedLevelBeLoaded
◆  static function GetStreamProgressForLevel (levelName : string) : float 
 描述：下载了多少？[ 0......1]
在web播放器中这将返回关卡的进度。
参见：CanStreamedLeverlBeLoaded 函数。
◆  static function LoadLevel(index : int) : void
描述：加载关卡。
这个函数按照索引加载关卡。在Unity中使用File->Build Settings.....菜单可以看到所有 关卡的索引列表。在你能过加载关卡之前你必须将它添加到游戏使用关卡列表中。在 Unity中使用File->Build Settings.....并添加你需要的关卡到关卡列表中。
//加载索引为 0 的关卡
Application . LoadLevel（0）；
当加载崭新的关卡时，所有已经加载的游戏物体都将被销毁。 如果你想让物体在被加 载新关卡时不被销毁，使用Object.DontDestroyOnLoad 。
◆  Static function LoadLevel( name : string) : void
描述：按照它的名称加载关卡。
在你能够加载关卡之前你必须将它添加到游戏使用的关卡列表中。在Unity中使用
File->Build Settings..... 并添加你需要的关卡到关卡列表中。关卡被加载所有激活物体上 的MonoBehaviour . OnLevelWasLoaded都被调用。
// 加载名为“HighScore”的关卡。
Application . LoadLevel("HighScore");
当加载新的关卡时，所有已经加载的游戏物体都将被销毁。 如果你想让物体在加载新
关卡时不被销毁，使用Object. DontDestroyOnLoad。
◆  static function LoadLevelAdditive ( index : int ) : void
◆  static function LoadLevelAdditive (name : string ) : void
描述：额外地加载一个关卡。
不同于LoadLevel，LoadLeavelAdditive 不会销毁当前关卡中的物体。新关卡中的物体 
将被添加到当前关卡。这对于创建连续的虚拟世界时非常有用的，当你走过时更多的内
荣被加载。
◆  static function OpenURL( url : string ) : void
描述：在浏览器中打开url 。
在编辑器或者独立播放器模式下，这将在缺省的浏览器中使用新页打开url 。这将是浏
览器位于前端。
但在网页中执行时，包含插件的页将被重定向到 url 。
Function Start ( ) {
Application . OpenURL ("http://unity3d.com");
}
◆  Static function Quit ( ) : void
描述：退出应用程序。在编辑器或者web播放器中退出被忽略。
//当用户点击escape时退出播放器
Function Update ( ){
If ( Input GetKey ( "escape" )){
Application . Quit ( ) ;
} 
}
Array
类
数组允许你将多个对象存储在一个变量中。
Array类只能用于JavaScript 。更多关于C#或JavaScript中ArrayLists ，字典或哈希表的信息参考MSDN 。
这是一个基本的例子，说明可以使用一个数组类做什么 
   function Start( )
{
var arr = new Array ( ) ;  
arr.Push ("Hello"); //添加一个元素  
Print(arr[ 0]);  //打印第一个元素 
arr length = 2 ;  //调整数组大小
arr [ 1] = "World"; //将“World”赋给第二个元素 
for (var value : String in arr)  //遍历这个数组 
{
Print ( value );
}
     }
Unity中有两种类型的数组，内置数组和普通的JavaScript数组。
内置的数组（原始的.NET数组），是非常快速和有效的但是它们不能被调整大小。
它们是静态类型的，这允许它们在检视面板中被编辑。这是如何使用内置数组的简单例子。
//在检视面板中公开一个浮点数组，你可以在那里编辑它
var value : float[ ];
Function Start ( )
{
    //遍历数组
     for ( var value in values){
Print ( value );
}
//因为我们不能调整内置数组的大小
//我们必须重新创建一个数组来调整它的大小
value = new float[ 10 ];
value[ 1 ] = 5.0;//给第二个元素赋值
}
内置数组在性能相关的代码中非常有用的(使用Unity的JavaScript和内置数组可以非常容易使用mesh interface在一秒内处理两万个顶点。)  另一方面，普通的JavaScript数组可以调整大小，排序并可以做所有你期望的数组类的操作。JavaScript数组不显示在检视面板中。你可以容易地在JavaScript数组和内置数组之间转换。
function Start ( ) 
{ 
var array = new Array ( Vector3(0,0,0),Vector3(0,0,1));
array .Push (Vector3 (0,0,2));
array .Push (Vector3 (0,0,3));
//拷贝js数组到内置数组
var builtinArray : Vector3[ ] = array . ToBuiltin ( Vector3 );
//将内置数组赋给js数组
var newarr = new Array ( builtinArray );
//newarr与array 包含相同的元素
print ( newarr );
}
注意按照Unity的命名规则下面所有函数均大写开头。为方便JavaScript用户 ， Unity数组类也接受小写函数。
变量
◆  var length : int 
  描述：数组的长度属性，返回或设置数组中元素的数量。
function Start ( )
{
var arr = Array ( "Hello" , "World" ) ;
print (arr . length ) ; //打印两个
arr . Length = 5 ; //调整数组的大小为5
} 
函数
◆  function Add ( value : object ) : void 
描述：添加 value 到数组末端。
var arr = new Array ("Hello");
arr.Add (" World ");
Print ( arr );  //打印"Hello ","World"
◆  function Clear ( ) : void 
描述: 清空数组。 数组的长度将为零。
var hello = new Array ("Hello ","World ");
hello.Clear ( ) ;  //现在hello包含零个元素
◆  function Concat ( array :Array , optionalArray0: Array, optionalArray1 : Array):Array
描述：连接两个或多个数组。这个方法不会改变已有的数字并返回连接后的数组拷贝
function Start ( ) {
  var arr = new Array ("Hello","World"):
  var arr2 =  new Array ("!");
  var joined = arr.Concat ( arr2 );  //现在jointed包含所有3个字符串
  Print ( joined );  //打印"Hello","World","!"
} 
◆  function Join ( seperator ：string ) : String 
描述：链接数组内容为一个字符串。元素将被seperator字符串分割,并返回数组的拷贝
function Start ( ){
    var arr = new Array ("Hello" , "World");
 print ( arr . join (" , "));//打印"Hello，World"
}
◆  function Pop ( ) : object 
 描述：移除数组最后一个元素并返回它。
 var arr = new Array ("Hello ","World");
 arr . Pop ( );
 print ( arr );//只打印"Hello"
◆  function Push (value : object) : int
描述： 添加value到数组末端。并返回新数组长度。
var arr = new Array ("Hello");
arr.Push ("World");
print ( arr );//打印"Hello","World"
◆  function RemoveAt (index : int ) : void
描述：从数组中移除索引为index的元素。
var arr = new Array ("Hello" , " and good morning" , "World ");
arr.Remove ( 1 ) ;  //移除 "and good morning"
print ( arr );//打印 " Hello World "
◆  function Reverse () : Array
描述：颠倒数组中所有元素顺序。
var hello = new Array (" Hello " ," World ") ;
hello Reverse( ) ;
print (hello);//打印World，Hello
◆  function Shift ( ) :object 
描述：移除数组的第一个元素并返回它。
var arr = new Array ( " Hello " , " World ");
arr . Shift ( ) ;  
print ( " World " ) ;  //现在arr只包含" World "
◆  function Sort( ) : Array 
描述：排序所有数组元素
var hello = new Array ( " e " ," a " ," b ");
hello . Sort ( ) ;
print ( hello ) ;// 打印 a ，b ，c  
◆  function Unshift ( newElement : object , optionalElement : object ) : int 
描述： Unshift 添加一个或多个元素到数组的开始位置并返回新的数组长度。
var arr = new Array (" Hello "," World ");
arr . Unshift (" This "," is ");
print ( arr ) ;//打印 This，is，Hello，World
BitStream
类
BitStream 类表示序列化的变量，打包到一个流中。
数据可以被序列化，传输，然后远端使用这个类接受。参考 Network View component reference
获取关于网络同步的信息和Network. OnSerializeNetworkView函数获取更多信息。
变量
◆  var isReading : bool
描述：这个BitStream现在在被读吗？
参考Network. OnSerializeNetworkView
◆  var isWriting : bool
描述：这个BitStream现在在被写吗？
参考Network. OnSerializeNetworkView
函数
◆  function Serialize (ref  value : bool ) : void 
◆  function Serialize (ref  value : char ) : void 
◆  function Serialize (ref  value : short) : void 
◆  function Serialize (ref  value : int ) : void 
◆  function Serialize (ref  value : float , maxDelta : float = 0.00001F) : void 
◆  function Serialize (ref  value : Quaternion, maxDelta : float = 0.00001F) : void 
◆  function Serialize (ref  value : Vector3, maxDelta : float = 0.00001F) : void 
◆  function Serialize (ref  value : NetworkPlayer ) : void 
◆  function Serialize (ref  viewID: NetworkViewID ) : void 
描述：BitStream类可以序列化几个不同类型的变量。
包含：bool , char , short , int , float , Quaternion , Vector3 和 NetworkPlayer
注意serialize ( char )系列化一个字节，因此，它只能用于 0......255之间的字符。
BoneWeight
结构
网格上一个顶点的蒙皮骨骼权值
每个被蒙皮的点至多有四个骨头。所有权值的和应该为1。权值和骨骼索引应该被以权值递减的顺序定义。如果一个顶点被少于四个骨骼影响，剩下的权值应该为0。
参见：Mesh.boneWeights变量。
变量
◆  var boneIndex0 : int
描述：第一个骨骼的索引。
参见：weight0 .
◆  var boneIndex1 : int
描述：第二个骨骼的索引。
参见：weight1.
◆  var boneIndex2 : int
描述：第三个骨骼的索引。
参见：weight2 .
◆  var boneIndex3 : int
描述：第四个骨骼的索引。
参见：weight3 .
◆  var weight0 : float
描述：第一个骨骼的蒙皮权值。
参见：boneIndex0.
◆  var weight1 : float
描述：第二个骨骼的蒙皮权值。
参见：boneIndex1.
◆  var weight2 : float
描述：第三个骨骼的蒙皮权值。
参见：boneIndex2.
◆  var weight3 : float
描述：第四个骨骼的蒙皮权值。
参见：boneIndex3.
Bounds 
结构
代表一个轴对齐包围盒。
一个轴对齐包围盒，简称为AABB，是与坐标轴对齐的box并且完全包围一些物体。因为这个box不会绕着轴旋转，所以它可以只用center和extents定义，或者用min和max点定义。
Bounds被Collider.bounds,Mesh.bounds,Renderer.bounds使用。
变量
◆var center : Vector3
描述：包围盒子的中心
◆var extents : Vector3
描述：box的宽度。这个总是size的一半
◆var max : Vector3
描述：box的最大点。这个总是等于center + extents。
◆var min : Vector3
描述：box的最小点。这个总是等于center - extents。
◆var size : Vector3
描述：box的总大小。这个总是extents的二倍。
size.x是宽度， size.y 是高度， size.z 是长度。
构造函数
◆static function Bounds ( center : Vector3 , size : Vector3 ) : Bounds
描述：用给定的center和总size创建新的Bounds。Bounds extents将是给定size的一半。
var bounds = Bounds ( Vector3.zero , Vector3(1,2,1));//在原点常见柱状包围盒
函数
◆function Contains ( point : Vector3 ) : bool
描述：point 包含在这个包围盒中吗 ？
◆function Encapsulate ( point : Vector3 ) : void
描述：增大Bounds以包含这个point. 
◆function Encapsulate ( bounds : Bounds ) : void
描述：增大bounds来封装另一个bounds。
◆function Expand ( amount : float ) : void
描述：沿着每个面按照amount增加它的size来扩展这个bounds。
◆function Expand ( amount : Vector3 ) : void
描述：沿着每个面按照amount增加它的size来扩展这个bounds。
◆function IntersectRay ( ray : Ray ) : bool
描述：ray与这个包围盒相交吗？
◆function IntersectRay ( ray : Ray , out distance : float ) : bool
描述：ray与这个包围盒相交吗？
当IntersectRay返回真，distance将是到射线源点的距离。
◆function SetMinMax ( min : Vector3, max : Vector3 ) : void 
描述：设定边界为盒子的min和max值。
使用这个函数要比分别指定min和max更快。
◆function SqrDistance ( point : Vector3 ) : float
描述： 点到这个包围盒的最小平方距离。
◆function ToString ( ) : string
描述：返回一个格式化好的字符串
collision
类
描述碰撞
Collision 信息被传递到Collider . OnCollisionEnter , Collider . OnCollisionStay和Collider.OnCollisionExit事件。参见： ContactPoint.
变量
◆var collider : Collider
描述：碰撞到的Collider ( 只读 ).
为了得到所有被碰撞到的碰撞器的细节，你需要迭代接触点( contacts属性)。
◆var contacts : ContactPoint [ ]
描述：接触点由物理引擎产生。
每个contact包含一个接触点，法线和两个发生碰撞的碰撞器（参考ContactPoint）。在OnCollisionStay或者OnCollisionEnter内可以确保contacts有至少一个元素。
function OnCollisionStay ( collision : Collision ){
//检查碰到碰撞器是否有刚体 
//然后使用一个力
for ( var contact : ContactPoint in collision . contacts ) {
print ( contact.thisCollider . name + "hit" + contact . otherCollider .name );
//可视化接触点
Debug.DrawRay ( contact . point , contact . normal, Color .white ) ;
}
}
//一枚手榴弹，在击中一个表面时初始化一个爆炸预设，然后销毁它
var explosionPrefab : Transform;
function OnCollisionEnter( collision : Collision ){ 
 //旋转这个物体使y轴面沿着表面法线的方向
 var contact = collision . contact [ 0 ];
 var rot = Quaternion . FromToRotation ( Vector3.up , contact . normal ) ;
 var pos = contact . point ;
 Instantiate ( explosionPrefab , pos , rot ) ;
 Destory ( gameObject );//销毁这个投射物
 }
◆var gameObject : GameObject
描述：/ gameObject / 是与之碰撞的物体（只读）
◆var relativeVelocity : Vector3
描述: 两个碰撞物体的相对线形速度（只读）。
//当以较大的速度碰到一个物体时播放声音
function OnCllisionEnter ( collision : Collision ) {
if ( collision . relativeVelocity . magnitude > 2 ) 
audio .Play ( );
}
◆var rigibody : Rigidbody
描述：碰撞到的Rigidbody（只读），如果碰到的物体是一个没有附加刚体的碰撞器，返回null
//让所有碰到的刚体向上飞
function OnCollisionStay ( collision : Collision ) {
//检查碰到的碰撞器是否有一个刚体 ，然后使用力
if ( collision . rigidbody ){ 
collision . rigidbody .AddForce ( Vector3 . up * 15 ) ;
}
}
◆var transform : Transform
描述：碰撞到的物体的Transform（只读）。
如果碰到一个带有Rigidbody的碰撞器，transform将是所有附加刚体的变换。如果碰到了一个没有刚体的碰撞器，transform将是所有附加碰撞器的变换。
color
结构
表示RGBA颜色。
这个结构被用在整个Unity中传递颜色。每个颜色组件是一个0到1之间的浮点数。 
组件(r ,g ,b )在RGB颜色空间内定义一个颜色。Alpha组件（a）透明性 - alpha为0是完全不透明，alpha为1是完全透明。
变量
◆var  a : float 
描述：颜色的Alpha组件。
var color = Color . white ;
color . a = 0 ;
◆var b : float 
描述：颜色的蓝色组件。
var color = Color .white;
color .b = 0 ;
◆var g : float
描述：颜色的绿色组件
var color = Color . white ;
color . g = 0 ;
◆var grayscale : float 
描述：颜色的灰度值（只读）
var color = Color ( 3 , 4 ,6 ) ;
print ( color . grayscale ) ;
◆var r : float 
描述：颜色的红色组件。
var color = Color . white ;
color . r = 0
◆var this [ index : int ] : float
描述：分别使用[ 0 ] ,[ 1 ] ,[ 2 ] ,[ 3 ]访问r ，g  , b  ,a组件。
Color p ;
p [ 1 ] = 5 ;//与p .g = 5相同
构造函数
◆static function Color ( r : float , g : float , b : float, a: float ) : Color
描述：用给定的 r , g , b , a ,组件构建一个新的颜色。
var color = Color ( 0.2 , 0.3 , 0.4 , 0.5 ) ;
◆static function Color ( r : float , g : float , b : float ) : Color
描述：用给定的 r , g , b 组件构建一个新的颜色并设置 a 为1
var color = Color (0.2 , 0.3 , 0.4 ) ;
函数
◆function ToString ( )：string
 描述：返回格式化好的这个颜色的字符串。
 print ( Color .white ) ;
类变量
◆static var black : Color
描述：黑色。 RGBA为（ 0 , 0 , 0 , 1 ).
◆static var blue : Color
描述：蓝色。 RGBA为（ 0 , 0 , 1 , 1 ).
◆static var clear  : Color
描述：完全透明。 RGBA为（ 0 ,0, 0, 0 ).
◆static var eyan : Color
描述：青色。 RGBA为（ 0 , 1 , 1 , 1 ). 
◆static var gray : Color
描述：灰色。RGBA为 ( 5 , 5 , 5 , 1 ).
◆static var green : Color 
描述：绿色。RGBA为（0, 1 , 0, 1 ).
◆static var grey : Color 
描述：英式拼法为gray。RGBA为（0.5 , 0.5 , 0.5 , 1 ).
◆static var magenta : Color 
描述：紫红色。RGBA为（1 , 0 , 1 , 1 ).
◆static var red : Color 
描述：全红。RGBA为（1 , 0 , 0, 1 ).
◆static var white : Color 
描述：全白。RGBA为（1 , 1 , 1 , 1 ).
◆static var yellow : Color 
描述：黄色。RGBA是怪异的（1 , 235/255 , 4/255 , 1 )，但是这个颜色看起来非常好！
类方法
◆static function Lerp ( a : Color , b : Color , t : float ) : Color  
描述：在颜色a和颜色b之间按照t插值。
/ t /被限定到0 和1之间，当t为0时返回a . 当t为1时返回b
◆static operator * ( a : Color , b : Color) : Color
描述：乘两个颜色，每个组件被分别乘。
◆static operator * ( a : Color , b : float) : Color
描述:用浮点数b乘以颜色a。每个组件被分别乘。
◆static operator * ( a : float , b : Color) : Color
描述：用浮点数b乘以颜色a。每个组件被分别乘。
◆static operator + ( a : Color , b : Color) : Color
描述：加两个颜色，每个组件被分别加。
◆static operator - ( a : Color , b : Color) : Color
描述：从颜色a中减去颜色b。每个组件被分别减。
◆static operator / ( a : Color , b : float) : Color
描述：乘用浮点数b除以a。每个组件被分别除。
◆static implicit function Color ( v : Vectro4 ) : Color 
描述：Colors可以被隐式转化为Vector4，或由它转化而来。
◆static implicit function Vector4 ( c : Color ) : Vector4
描述：Colors以被隐式的转化为Vector4，或由它转化而来。
ContactPoint
结构
描述：碰撞发生的接触点。
接触点被存储在collision结构中，参见collision ， collision . OnCollisionEnter,        Collision . OnCollisionStay  , Collision . OnCollisionExit.
变量
◆var normal : Vector3
描述：接触点的法线
◆var otherCollider : Collider
描述：碰撞中的另一个碰撞器
◆var point : Vector3
描述：接触点
◆var thisCollider : Collider? 
描述：碰撞中的第一个碰撞器
ControllerColliderHit
类
ControllerColliderHit被CharacterController . OnControllerColliderHit使用来给出详细的关于碰撞和如何处理它们的信息。
变量
◆var collider : Collider
描述：被控制器碰到的碰撞器。
◆var controller : CharacterController
描述：碰到该碰撞器的控制器。
◆var gameObject : GameObject
描述：被控制器碰到的游戏物体。
◆var moveDirection : Vector3
描述：从胶囊的中心到接触点的大致方向。
这可以用来找到一个合理的方向将力应用到接触的刚体。
◆var moveLength : float
描述：角色碰到这个碰撞器时已经行走了多远。
注意这可能不同于你传递到CharacterController . Move的。因为所有的移动都是被碰撞器制约的。
◆var normal : Vector3
描述：在世界空间中碰撞表面的法线。
◆var point : Vector3
描述：世界空间中的碰撞点。
◆var rigidbody : Rigidbody
描述：被控制器碰到的刚体。
如果没有接触一个刚体而是一个静态碰撞器时为null。
◆var transform : Transform
描述：被控制器碰到的变换。
Debug
类
一个类，包含用于开发游戏时的调试方法。
类变量
◆static var isDebugBuild : bool
描述：在Build Settings....对话框中，有一个被称为"strip debug symbols"的复选框。
如果它被选择isDebugBuild将为关。在编辑器中isDebugBuild总是返回真，建议在发布游戏的时候移除所有对Debug .Log的调用，这样你就能够容易的发布带有调试输出的测试版，而最终版没有调试输出。
//只有这是调试版时，记录调试信息
if ( Debug .isDebugBuild ) {
Debug . Log ( " Something bad happened ! " ) ;
}
类方法
◆static function Break ( ) : void
描述：暂停编辑器
Debug . Break ( ) ;
◆static function DrawLine ( start:Vector3, end: Vector3, color : Color = Color . white ) : void
描述：从point开始到end用颜色绘制一条线。
  这个线将被绘制在编辑器的场景视图中。如果在游戏视图中启用了gizmo绘制，这个线也将被绘制在这里。
//从世界坐标的原点到点( 1 , 0 , 0 )绘制一条红色的线
function Update ( ) {
Debug . DrawLine ( Vector3 . Zero , new Vector3 ( 1 , 0 , 0 ), Color . red ) ;
}
◆static function DrawRay ( start:Vector3, dir : Vector3, color : Color = Color . white ) : void
描述：从start 到start+dir 用颜色绘制一条线。
//绘制一条10米长的线从position，沿着变换的z轴向前。
function Update ( ) {
var forward = transform . TransformDirection ( Vector3 . forward ) * 10 ;
Debug . DrawRay ( transform . position .Vector3 . forward * 10 , Color . green );
}
◆static function Log ( message : object ) : void
描述：记录message到Unity控制台。
Debug . Log ( "Hello");
◆static function Log ( message : object . context : Object ) : void
描述：记录message到Unity控制台。
当你在控制台中选择消息的时候一个到上下文物体的链接将被绘制。这是非常有用的。如果你想知道那个物体发生了错误。
Debug . Log ( "Hello" , gameObject ) ;
◆static function LogError ( message : object ) : void
描述：Debug . Log 的一个变体，用来记录错误信息到控制台。
var memberVariable : Transform ;
if ( memberVariable == null )
Debug . LogError ( " memberVariable must be set to point to a Transform. ") ;
◆static function LogError ( message : object , context : Object ) : void 
描述：Debug . Log的一个变体，用来记录错误信息到控制台。
等你在控制台中选择消息的时候一个到上下文物体的链接将被绘制。这是非常有用的， 如果你想知道那个发生了错误。
var memberVariable : Transform ; 
if ( memberVariable == null )
Debug . LogError ( "memberVariable must be set to point to a Transform " , this ) ;
◆static function LogWarning ( message : object ) : void 
描述：Debug . Log 的一个变体，用来记录警告信息到控制台。
◆static function LogWarning ( message : object , context : Object ) : void 
     描述：Debug . Log的一个变体，用来记录警告信息到控制台。
     当你选择控制台中的一个消息时，一个到上下文物体的连接将被绘制。这是非常有用的，     如果你想知道那个物体发生了错误
Event
类
     一个UnityGUI事件。
     对应于用户的输入事件（按键，鼠标事件），或者是UnityGUI布局或渲染事件。
     对于每个事件OnGUI在脚本中被调用；因此OnGUI在每帧中被潜在调用多次。
Event . current对应于OnGUI调用“当前”事件。
 参见：GUIScripting Guide
变量
◆var alt : bool 
描述：Alt/Option键被按住？（只读）
在windows下，如果Alt键被按下返回真。在Mac下，如果Option键被按下返回真。
◆var button : int
描述：哪个鼠标键被按下
0表示左键，1表示右键。2表示中键。在EventType . MouseDown ,EventType .MouseUp
事件中使用。
◆var capsLock : bool
描述：Caps Lock 处于打开状态？（只读）
如果Caps Lock为打开返回真
◆var character : char
描述：输入的字符
在EventType . KeyDown 事件中使用，注意EventType . KeyUp事件不包含字符，只包含Event . keyCode .
参见：Event . keyCode.
◆var command : bool
描述：Command/Windows键被按住？（只读）
在Windows下，如果Windows键被按下返回真。在Mac下，如果Command键被按下返回真。
◆var control : bool 
描述：Control被按下？（只读）
如果Control被按下返回真。
◆var delta : Vector2
描述：与上次事件相比，鼠标的相对移动。
在EventType .MouseMove，EventType .MouseDrag,，EventType .ScrollWheel时间中使用。
参见：Event . mousePosition
◆var functionKey : bool 
描述：当前按下的键是功能键？（只读）
如果当前按下的键是方向键，翻页键，退格键等等时返回真，如果这个键需要特殊处理才能用与文本编辑时，functionKey为打开。
◆var isKey : bool
描述：这个事件是键盘事件？（只读）
◆var isMouse : bool
描述：这个事件是鼠标事件？（只读）
◆var keyCode : KeyCode 
描述：用于键盘事件的原始键代码
在EventType . KeyDown 和 EventType . KeyUp事件中使用；返回匹配物理键盘的KeyCode值，使用这个来处理光标，功能键等等。
参见：Event . character 。
◆var mousePosition : Vector2
描述：鼠标位置
在EventType . MouseMove 和EventType . MouseDrag事件中使用。
参见：Event . delta
◆var numeric : bool
描述：当前按下的数字的键？（只读）
使用这个表示区分主&数字键。
◆var shift : bool
描述：Shift被按下？（只读）
如果Shift被按下返回真。
函数
◆function GetTypeForControl ( controlID : int ) : EventType
参数
controlID           查询的控件ID。从GUIUtilty . GetControlID ( ) 获取。参考   EventType获取可能值的列表。
描述：为给定的控件ID获取一个过滤的事件类型。
这个函数可以用来实现鼠标锁和键盘焦点。
◆function  Use ( ) : void 
描述：使用这个事件。
当已经使用了一个事件时调用这个方法。事件类型将被设置为EventType . Used。使其 他GUI元素忽略它。
类变量 
◆static var current : Event
 描述：现在被处理的当前事件。
类方法
◆static function KeyboardEvent ( key : string ) : Event
 描述：创建一个键盘事件。
 这可用于检查某个键是否被按下。可能带有调整器。key字符串是键的名称（与输入管理器中的相同），可以使用任意数量的调整器前缀：& = Alternate , ^ = Controler, % = Command , # = Shift   例如：&f12 = Alternate +F12., " ^[ 0 ] " = Control +keypad0
 function OnGUI ( ) {
GUILayout . Lable ( " Press Enter To Start Game ") ; 
  if ( Event . current . Equals ( Event . KeyboardEvent ("[enter]")))
   Application . LoadLevel ( 1 ) 
if(Event current Equals(Event KeybordEvent("return") ))
Print( "I said enter ,not return – try the keypad" );
}
GL
类
底层图像库。
使用这个类操作激活的变换矩阵，发送与OpengGL立即模式相同的渲染命令并做一些其他的底层图像操作。注意，在所有情况下使用Graphics.DrawMesh比任何使用立即模式绘制更有效。
这个类只限于Unity Pro.
类变量
◆ static var LINES: int
描述：用于Begin的模式:绘制直线。
参见：GL . Begin, GL . End.
◆ static var modelview：Matrix4x4
描述：当前模型视矩阵。
给这个变量赋值等同于OpenGL中的glLoadMatrix(mat);在其他图形API中对应的功能被模拟。
改变模型视矩阵覆盖当前相机的视参数，因此最常用的是使用GL.PushMatrix和GL.PopMatrix来保存和恢复矩阵。
读取这个变量返回当前模型视矩阵。
◆ static var QUADS：int
描述：用于Begin的模式：绘制四边形
参见：GL.Begin,GL.End.
◆ static var TRIANGLE_STRIP：int
描述：用于Begin的模式：绘制三角面
参见：GL.Begin,GL.End.
◆ static var TRIANGLES：int
描述：用于Begin的模式：绘制三角形
参见：GL.Begin,GL.End.
类方法
◆ static function Begin(mode:int) : void
参数
mode         绘制的几何体：可以是TRIANGLES,TRIANGLE_STRIP,QUADS或
       LINES.
描述：开始绘制3D几何体
这个对应OpenGL中的glBegin，在其他图形API中相同的功能被模拟 ，在GL.Begin 和 GL.End之间，可以调用GL .Veriex,GL.Color,GL.TexCoord和其他立即模式绘制函数。
  在绘制你自己的几何体时，你应该注意它们的裁剪。裁剪规则可能会因为不同的图形 API而不同。在大多数情况下在shader中使用Cull Off命令是安全的。
参见：GL.End.
◆ static function Clear(clearDepth:bool,clearColor:bool,backgroudColor):void
参数
clearDepth            应该清除深度缓存？
clearColor            应该清除颜色缓存？
backgroudColor       颜色被清理为什么，只有当clearColor为true时使用.
描述：清除当前渲染缓存
这将清除屏幕或激活的RenderTexture.
◆ static function Color(c : Color) : void
描述：设置当前顶点颜色
这个对应OpenGL中的glColor4f(c. r,c.g,c.b,c.a):在其他图形中API中相同的功能被模拟，
为了使逐顶点颜色可以在不同的硬件上工作，你需要使用绑定了颜色通道的shader。参考BindChannels文档.
这个函数只在GL.Begin和GL.End函数之间调用.
◆ static function End( ) : void
描述：结束绘制3D几何体
这个对应OpenGL中的glEnd;在其他图形API中相同的功能被模拟.
参见：GL.Begin.
◆ static function LoadIdentity( ) : void
描述：加载单位矩阵到当前模型视矩阵。
这个函数覆盖当前相机的视参数，因此最常用的是使用GL.PushMatrix和GL.PopMatrix
来保存和恢复矩阵。
◆ static function LoadOrtho( ) : void
描述：辅助函数用来设置一个正交透视变换
调用LoadOrtho知道，视锥从 (0,0,-1) 变化到(1,1,100).
◆ static function LoadPixelMatrix( ) : void
描述：设置一个用于像素修正渲染的矩阵。
这个设置模型视和投影矩阵，因此X，Y坐标直接映射到像素。(0,0)位于当前相机
视口的左下角。Z坐标从-1到+100
这个函数覆盖当前相机的参数，因此最常用的是使用GL.PushMatrix和GL.PopMatrix
来保存和恢复矩阵。
◆ static function LoadPixelMatrix(left:float,right:float,bottom:float,top:float):void 
描述：设置一个矩阵的像素正确渲染。
这样设置投影矩阵点以便X、Y坐标图直接像素化。（0,0）在底部左侧当前摄像机的视角。Z坐标是从-1到+100。
这个函数覆盖了相机的参数，所以通常你要保存和恢复矩阵就使用GLPushMatrix和GL.PopMatrix。
◆  static function LoadProjectionMatrix (mat : Matrix4x4) : void 
描述：加载到当前任意矩阵投影矩阵。
这个函数重写当前摄像机的投影参数，所以通常你要保存和恢复投影矩阵就使用GLPushMatrix和GL.PopMatrix。
◆  static function MultiTexCoord (unit : int, v : Vector3) : void 
描述：设置当前纹理坐标(v.x,v.y,v.z)实际的纹理单元。
在OpenGL中glMultiTexCoord为特定的纹理单元如果多纹理是可用的。在其他图形的API中相同的功能进行了仿真。
这个函数只能被称为介于GL.Begin和GL.End功能之间。
◆  static function MultiTexCoord2 (unit : int, x : float, y : float) : void 
描述：设置当前纹理坐标（x，y）的为实际纹理单元。
在OpenGL中glMultiTexCoord为特定的纹理单元如果多纹理是可用的。在其他图形的API中相同的功能进行了仿真。
这个函数只能被称为介于GL.Begin和GL.End功能之间。
◆  static function MultiTexCoord3(unit : int, x : float, y : float, z : float) :void 
描述：设置当前纹理坐标（x，y，z）的为实际纹理单元。
在OpenGL中glMultiTexCoord为特定的纹理单元如果多纹理是可用的。在其他图形的API中相同的功能进行了仿真。
这个函数只能被称为介于GL.Begin和GL.End功能之间。
◆  static function MultMatrix (mat : Matrix4x4) : void 
描述：复制当前的点矩阵和其中的一个说明。
相当于glMultMatrix（垫在）OpenGL; 在其他图形API的相应功能是相仿的。
换点矩阵覆盖当前相机视图的参数，所以通常你要保存和恢复投影矩阵就使用GLPushMatrix和GL.PopMatrix。
◆  static function PopMatrix () : void 
描述：恢复了投影和点矩阵的矩阵堆栈的顶部。
换投影矩阵点覆盖当前相机视图的参数。这些矩阵可以用GLPushMatrix和GL.PopMatrix来保存和恢复。
参见：PushMatrix函数。
◆  static function PushMatrix () : void 
描述：节约双方投影矩阵对点和矩阵堆栈。
换投影矩阵点覆盖当前相机视图的参数。这些矩阵可以用GLPushMatrix和
 GL.PopMatrix来保存和恢复。
 参见：PopMatrix函数
◆ static function SetRevertBackfacing(revertBackFaces : bool) : void
 描述：选择是否翻转隐面剔除，是（真）或者不是（假）
◆ static function TextCoord (v : Vector3) : void
 描述：为所有纹理单元设置当前纹理坐标(v.x, v.y, v.z)
 这个对应于OpengGL中用于所有纹理单元的glMultiTexCoord或者多纹理不可用时的glTexCoord，在其他的图形API中仿真了相同的功能。
 这个函数只在GL.Begin和GL.End函数之间调用。
◆ static function TexCoord2(x : float, y : float) : void
 描述：为所有纹理单元设置当前纹理坐标(x, y)
 这个对应于OpengGL中用于所有纹理单元的glMultiTexCoord或者多纹理不可用时的glTexCoord，在其他的图形API中仿真了相同的功能。
 , 这个函数只在GL.Begin和GL.End函数之间调用。
◆ static function TexCoord3(x : float, y : float, z : float) : void
 描述：为所有纹理单元设置当前纹理坐标(x, y, z)
 这个对应于OpengGL中用于所有纹理单元的glMultiTexCoord或者多纹理不可用时的glTexCoord，在其他的图形API中仿真了相同的功能。
 这个函数只在GL.Begin和GL.End函数之间调用。
◆ static function Vertex(v : Vector3) : void
 描述：提交顶点
 这个对应OpenGL中的glVertex3f(v.x, v.y.v.z); 在其他图形API中相同的功能被模拟。
 这个函数只在GL.Begin和GL.End函数之间调用。
◆ static function Vertex3(x : float, y : float, z : float) : void
 描述：提交顶点
 这个对应OpenGL中的glVertex3f(x, y, z); 在其他图形API中相同的功能被模拟。
 这个函数只在GL.Begin和GL.End函数之间调用。
◆ static function Viewport(pixelRect : Rect) : void
 描述：设置渲染视口
 所有的渲染都被限制在pixelRect之内。
GUIContent
 类
 GUI元素的内容
 这个与GUIStyle紧密相关，GUIContent定义渲染什么而GUIStyle定义如何渲染。
 参见：GUIStyle
变量
◆ var image : Texture
描述：包含图标的图像
◆ var text : string
 描述：包含的文本
◆ var tooltip : string
 描述：这个元素的提示
 与这个内容相关的提示。读取GUItooltip来获取当前用户指向的GUI元素的提示。
构造函数
◆ static function GUIContent() : GUIContent
 描述：用于所有形状和尺寸的GUIContent的构造函数
 构建一个空的GUIContent。
◆ static function GUIContent(text : string) : GUIContent
 描述：构建一个只包含文本的GUIContent物体。
 使用GUI是，你不需要为一个简单的文本字符创建GUIContents – 这两行代码功能等效：
 function OnGUI()
{
  GUI.Button(Rect(0, 0, 100, 20), “Click Me”);
  GUI.Button(Rect(0, 30, 100, 20), GUIContent(“Click Me”));
}
◆ static function GUIContent(image : Texture) : GUIContent
 描述：构建一个只包含图片的GUIContent对象。
 var icon : Texture;
 function OnGUI()
{
  GUI.Button(Rect(0, 0, 100, 20), GUIContent(icon));
}
◆ static function GUIContent(text : string, image : Texture) : GUIContent
 描述：构建一个包含text和图片的GUIContent对象
 var icon : Texture;
 function OnGUI()
{
 GUI.Button(Rect(0, 0, 100, 20), GUIContent(“Click me”, icon));
}
◆ static function GUIContent(text : string, tooltip : string) : GUIContent
 描述：构建一个包含text的GUIContent，当用户鼠标悬停在它上面的时候，全局GUI.tooltip被设置为tooltip。
 function OnGUI()
 {
  GUI.Button(Rect(0, 0, 100, 20), GUIContent(“Click me”,  “This is a tooltip.”));
 //如果用户指向这个按钮，全局提示被设置
 GUI.Label(Rect(0, 40, 100, 40), GUI.tooltip);
}
◆ static function GUIContent(image : Texture, tooltip : string) : GUIContent
 描述：构建一个包含图片的GUIContent，当用户鼠标悬停在它上面的时候，全局GUItooltip被设置为tooltip。
◆ static function GUIContent(text : string,  image : Texture, tooltip : string) : GUIContent
 描述：构建一个包含text和image的GUIContent,，当用户鼠标悬停在它上面的时候，全局GUItooltip被设置为tooltip。
◆ static function GUIContent(src : GUIContent) : GUIContent
 描述：从另一个GUIContent构建一个GUIContent。
GUILayoutOption
类
内部类用来传递布局选项给GUILayout函数，不要直接使用这些，而是在GUILayout类的布局函数中构造它们。
参见：
GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight
GUILayoutUtility
 类
 用于实现并扩展GUILayout类的工具函数。
 使用这个类制作你自己的GUI布局代码
类方法
◆ static function BeginGroup(GroupName : string) : void
 
◆ static function BeginLayoutGroup(style : GUIStyle, options : GUILayoutOption[], LayoutType : System.Type) : GUILayoutGroup
 描述：普通的辅助函数 – 当创建一个布局组的时候使用这个。它将确保所有的事情都正确的排列。
 style : 组选项的风格
 option : 使用的布局选项
 LayoutType : 创建的布局组的类型
◆ static function EndGroup(groupName : string) : void
◆ static function GetAspectRect(aspect : float) : Rect
◆ static function GetAspectRect(aspect : floar, style : GUIStyle) : Rect
◆ static function GetAspectRect(aspect : float,  params options : GUILayoutOption[]) : Rect
◆ static function GetAspectRect(aspect : float,  style : GUIStyle, params options：  GUILayoutOption[]) : Rect
 参数
 aspect  这个元素的宽高比（宽/高）
style  一个可选的风格。如果指定风格的padding将被添加到返回举行的尺寸并且这个风格的margin将被用于间距。
options 一个可选的布局选项的列表，它用来指定额外的布局属性。任何在这里设置的值将覆盖由Style定义的设置。参见GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
返回Rect – 控制的矩形
描述：用一个制定的宽高比获取一个矩形。
◆ static function GetRect(content : GUIContent, style : GUIStyle,  params options : GUILayoutOption[]) : Rect
 参数
 content  让出空间所显示的内容
 style用于布局的GUIStyle
options  一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。参见：GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILAyout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight
返回Rect – 一个足够大的矩形区域用来包含用/style/渲染时的/content/。
描述：获取一个以特定风格显示内容的矩形。
◆ static function GetRect(width : float,  height : float) : Rect
◆ static function GetRect(width : float,  height : float,  params options : GUILayoutOption[]) : Rect
◆ static function GetRect(width : float, height : float, style : GUIStyle,  params options : GUILayoutOption[]) : Rect
 参数 
 width  你想要的区域的宽度
 height  你想要的区域的高度
style  用了布局的可选GUIStyle，如果指定，风格的padding将被添加到尺寸并且它的margin将被用于间距
options 一个可选的布局选项的列表，它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
 参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
返回Rect – 用于放置控件的矩形
描述：用一个固定的内容区域获取一个矩形
◆ static function GetRect(minWidth : float,  maxWidth : float,  minHeight : float,  maxHeight : float) : Rect
◆ static function GetRect(minWidth : float,  maxWidth : float,  minHeight : float,  maxHeight : float, style : GUIStyle) : Rect
◆ static function GetRect(minWidth : float, maxWidth : float, minHeight : float, maxHeight :  float, params options : GUILayerOption[]) : Rect
◆ static function GetRect(minWidth : float, maxWidth : float, minHeight : float, maxHeight :  float, style : GUIStyle, paramas option : GUILayoutOption[]) : Rect
 参数
 minWidth  传回区域的最小宽度
 maxWidth  传回区域的最大宽度
 minHeight  传回区域的最小高度
 maxHeight  传回区域的最大宽度
style  一个可选的风格。如果指定，风格的padding将被添加到尺寸并且它的margin将被用于间距
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
 参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
返回Rect – 一个矩形区域在两个轴上的尺寸介于minWidth和maxWidth之间
描述：从布局系统获取一个可扩展的矩形，矩形的尺寸将在min和max值之间。
GUILayout
 类
 GUILayout是用于UnityGUI自动布局的类。
 参见：GUI Layout tutoria
类方法
◆ static function BeginArea(screenRect : Rect) : void
◆ static function BeginArea(screenRect : rect, text : string) : void
◆ static function BeginArea(screenRect : Rect, image : Texture) : void
◆ static function BeginArea(screenRect : Rect, content : GUIContent) : void
◆ static function BeginArea(screenRect : Rect, style : GUIStyle) : void
◆ static function BeginArea(screenRect : Rect, text : string, style : GUIStyle) : void
◆ static function BeginArea(screenRect : Rect, image : Texture, style : GUIStyle) : void
◆ static function BeginArea(screenRect : Rect, content : GUIContent, style : GUIStyle) : void
 参数
 text可选的显示在该区域中的文本
 image  可选的显示在该区域中的纹理
 content  可选的在该区域顶部显示的文本，图片和提示
style  使用的风格。如果留空，空的GUIStyle(GUIStyle.none)将被使用，给出一个透明的背景。参见：EndArea
描述：在屏幕的固定区域开始一个GUI空间的GUILayout块。
默认的，任何使用GUILayout制作的GUI空间都放置在屏幕的左上角。如果你想在任一区域放置一系列自动布局的控件，使用GUILayout.BeginArea定义一个新的区域以便自动布局系统可以使用它。
function OnGUI()
{
 GUILayout.BeginArea(Rect(200, 200, 100, 100));
 GUILayout.Button(“Click me”);
GUILayout.Button(“Or me”);
GUILayout.EndArea();
}
在混合GUILayout代码是这个函数是非常有用的。必须与EndArea调用匹配。BeginArea / EndArea不能嵌套。
◆ static function BeginHorizontal(params options : GUILayoutOption[]): void
◆ static function BeginHorizontal(style : GUIStyle, params options : GUILayoutOption[]): void
 参数
 style这个风格用于背景图片和填充值。如果留空，背景是透明的。
options  一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这个设置的值将覆盖由style定义的设置。
 参见：GUILayout.Width, GUILayout.Height, GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight
描述：开始一个水平控件组。
所有在这个元素内部渲染的空间将被一个接一个的水平放置，改组必须调用EndHorizontal关闭。
 
◆ static function BeginScrollView(scrollPosition : Vector2, params options : GUILayoutOption[]) : Vector2
◆ static function BeginScrollView(scrollPosition : Vector2, horizontalScrollbar : GUIStyle, verticalScrollbar : GUIStyle, params options : GUILayoutOption[]) : Vector2
◆ static function BeginScrollView(scrollPosition : Vector2, alwaysShowHorizontal : bool, alwaysShowVertical : bool, params options : GUILayoutOption[]) : Vector2
◆ static function BeginScrollView(scrollPosition : Vector2, style : GUIStyle) : Vector2
◆ static function BeginScrollView(scrollPosition : Vector2, alwaysShowHorizontal : bool, alwaysShowVertical : bool, horizontalScrollbar : GUIStyle, verticalScrollbar : GUIStyle,  params options : GUILayoutOption[]) : Vector2
◆ static function BeginScrollView(scrollPosition : Vector2, alwaysShowHorizontal : bool, alwaysShowVertical : bool, horizontalScrollbar : GUIStyle, verticalScrollbar : GUIStyle,  background : GUIStyle, params options : GUILayoutOption[]) : Vector2
 参数：
 scrollPostion 用来显示的位置
alwaysShowHorizontal  可选的参数用来总是显示水平滚动条。如果为假或者留空，它将只在ScrollView中的内容比滚动视宽时显示。
alwaysShowVertical 可选的参数用来总是显示垂直滚动条。如果为假或者留空，它将只在ScrollView中的内容比滚动视高时显示。
horizontalScrollbar 用于水平滚动条的可选GUIStyle。如果不设置，将使用当前GUISkin的horizontalScrollbar。
verticalScrollbar 用于垂直滚动条的可选GUIStyle。如果不设置，将使用当前GUISken的verticalScrollbar风格。
返回Vector2 – 修改过的scrollPosition。回传这个变量，如下的例子：
描述：开始一个自动布局滚动视。
自动布局滚动视，将使用任何你放置在它们中的内容并正常显示出来。如果他不适合，将显示滚动条，BeginScrollView的调用总是与EndScrollView的调用匹配。
//这个变量对于空间来说就是这个滚动视查看子元素的位置。
var scrollPosition : Vector2;
//显示在滚动视中的字符串，下面两个按钮添加，清除这个字符串。
var longString = “This is a long-ish string”;
function OnGUI()
{
 //开始一个滚动视，所有矩形被自动计算。
 //它将使用任何可用的空间并确保内容排列正确
 //这是小的最后两参数来强制滚动条出现
 scrollPosition = GUILayout.BeginScrollView(scrollPosition,  GUILayout.Width(100),  GUILayout.Height(100));
 //添加一个简单的标签到滚动视内部。注意
 //滚动条如何与文字换行正确的工作。
 GUILayout.Height(longString);
 //添加一个按钮来消除字符串。这个是在滚动区域内部，因此它
 //也将被滚动。注意按钮如何变窄为垂直滚动条留出空间
 if(GUILayout.Button(“Clear”)
longString = “”;
 //结束我们上面开始的滚动条
 GUILayout.EndScrollView();
 //现在我们在滚动视外边添加一个按钮 – 这将显示在滚动区域的下边
 if(GUILayout.Button(“Add MoreText”))
{
 longString += “\nHere is another line.”;
}
◆ static function Box(params option : GUILayoutOption[]) : void
◆ static function Box(style : GUIStyle, params option : GUILayoutOption[]) : void
 参数
 style 这个风格将用于背景图片和填充值，如果留空，背景是透明的。
options  一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
 参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
描述：开始一个垂直控件组。
所有在这个元素内部渲染的空间将被一个接一个地垂直放置。改组必须调用EndVertical关闭。
◆ static function Box(image : Texture, params option : GUILayoutOption[]) : void
◆ static function Box(text : string, params option : GUILayoutOption[]) : void
◆ static function Box(contend : GUIContent, params option : GUILayoutOption[]) : void
◆ static function Box(image : Texture, style : GUIStyle, params option : GUILayoutOption[]) : void
◆ static function Box(text : string, style : GUIStyle, params option : GUILayoutOption[]) : void
◆ static function Box(contend : GUIContent, style : GUIStyle, params option : GUILayoutOption[]) : void
 参数
 text 显示在该box上的文本
 image显示在该box上的Texture
 content用于这个box的文本，图形和提示
style 使用的风格。如果不设置，将使用当前的GUISkin的box风格。
options  一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
 参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
描述：制作一个自动布局box
这将制作一个实心box，如果你想制作一个包含一些内容的box，使用一个子组函数的
风格参数(BeginHorizontal, BeginVertical, 等等)
◆ static function Button(image : Texture, params options : GUILayoutOption[]) : bool
◆ static function Button(text : string, params options : GUILayoutOption[]) : bool
◆ static function Button(content : GUIContent, params options : GUILayoutOption[]) : bool
◆ static function Button(image : Texture, style : GUIStyle, params options : GUILayoutOption[]) : bool
◆ static function Button(text : string, style : GUIStyle, params options : GUILayoutOption[]) : bool
◆ static function Button(content : GUIContent, style : GUIStyle, params options : GUILayoutOption[]) : bool
 参数
 text 显示在该按钮上的文本
 image显示在该按钮上的Texture
 content用于这个按钮的文本，图形和提示。
 style 使用的风格。如果不设置，将使用当前的GUISkin的button风格。
options  一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight
 返回bool – true当用户单击按钮时。
 描述：制作一个简单的按钮，用户点击它们的时候就会有事情发生。
◆ static functioin EndArea() : void
 描述：关闭由BeginArea开始的GUILayout块
◆ static function EndHorizontal() : void
 描述：关闭一个开始于BeginHorizontal的组
◆ static functioin EndScrollView() : void
 描述：结束由BeginScrollView调用开始的滚动视。
◆ static functioin EndVertical() : void
 描述：关闭一个开始于BeginVertical的组
◆ static functioin ExpandHeight(expand : bool) : GUILayoutOption
 描述：传递给一个空间的选项来允许或不允许垂直扩展。
◆ static functioin ExpandWidth(expand : bool) : GUILayoutOption
 描述：传递给一个空间的选项来允许或不允许水平扩展。
◆ static functioin FlexibleSpace() : void
 描述：插入一个灵活的空格元素
 灵活的空格用来填充一个布局中任何遗漏的空间。
◆ static functioin Height(height : float) : GUILayoutOption
 描述：传递给空间的选项以便给它一个绝对高度。
◆ static functioin HorizontalScrollbar(value : float, size : float, leftValue : float, rightValue : float, params options : GUILayoutOption[]) : float
◆ static functioin HorizontalScrollbar(value : float, size : float, leftValue : float, rightValue : float, style : GUIStyle, params options : GUILayoutOption[]) : float
 参数
 value在min和max之间的位置
 size 能看见多大？
 leftValue滚动条左端的值
 rightValue  滚动条右端的值
style 用于滚动条背景的风格。如果不设置，将使用当前GUISkin的horizontalScrollbar
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
 参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight
返回floar – 修改后的值。这可以通过拖动这个滚动条，或者单击两端的箭头来改变。
描述：一个水平滚动条。滚动条可以用来滚动文档。大多数情况下，你会使用滚动视代替。
找到额外的元素：
在滚动条两端的按钮将在当前皮肤中搜索“leftButton”和“rightButton”作为风格，滚动条的滑块（你拖动的东西）将搜索并使用名为“thumb”的风格。
//这将使用下面的风格名来决定该按钮的尺寸/位置
//MyScrollbarleftButton - 用于左侧按钮的风格位置
//MyScrollbarrightButton - 用于右侧按钮的风格位置
//MyScrollbarthumb - 用于滑块的风格名称
scrollPos = GUILayout.HorizontalScrollbar(scrollPos, 1, 0, 100, “MyScrollbar”);
◆ static functioin HorizontalSlider(value : float, leftValue : float, rightValue : float, params options : GUILayoutOption[]) : float
◆ static functioin HorizontalSlider(value : float, leftValue : float, rightValue : float, slider : GUIStyle, thumb : GUIStyle, params options : GUILayoutOption[]) : float
 参数
 value滑块显示的值。这个决定可拖动滑块的位置。
 leftValue滑杆左端的值。
rightValue  滑杆右边的值。
slider用于显示拖动区域的GUIStyle。如果不设置，将使用当前GUISkin的horizontalSlider。

thumb  用于显示拖动块的GUISkin。如果不设置，将使用当前的GUISkin的horizontalSliderThumb
options  一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
 参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
返回float – 被用户设置的值。
描述：一个用户可以拖动的滑杆。可以在min和max之间取一个值。
◆ static function Label(image : Texture, params options : GUILayoutOption[]) : void
◆ static function Label(text : string, params options : GUILayoutOption[]) : void
◆ static function Label(content : GUIContent, params options : GUILayoutOption[]) : void
◆ static function Label(image : Texture, style : GUIStyle, params options : GUILayoutOption[]) : void
◆ static function Label(text : string, style : GUIStyle, params options : GUILayoutOption[]) : void
◆ static function Label(content: GUIContent, style : GUIStyle, params options : GUILayoutOption[]) : void
 参数
 text 显示在该标签上的文本。
 image显示在标签上的Texture。
 content用于这个标签的文本，图形和提示。
 style 使用的风格。如果不设置。将使用当前GUISkin的label。
options  一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
 参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
 描述：制作一个自动布局label
 标签没有用户交互。不会获取鼠标点击并总是以普通风格渲染。如果你想制作一个可视化响应用户输出的控件，使用一个Box控件。
◆ static function MaxHeight(maxHeight : float) : GUILayoutOption
 描述：传递给控件的选项来指定一个最大高度。
◆ static function MaxWidth(maxWidth : float) : GUILayoutOption
 描述：传递给控件的选项来指定一个最大宽度。
◆ static function MinHeight(minHeight : float) : GUILayoutOption
 描述：传递给控件的选项来指定一个最小高度。
◆ static function MinWidth(minWidth : float) : GUILayoutOption
 描述：传递给控件的选项，来指定一个最小宽度
◆ static function PasswordField(password : string,  maskChar : char, params options : GUILayoutOption[]) : string
◆ static function PasswordField(password : string,  maskChar : char, maxLength : int, params options : GUILayoutOption[]) : string
◆ static function PasswordField(password : string,  maskChar : char, style : GUIStyle, params options : GUILayoutOption[]) : string
◆ static function PasswordField(password : string,  maskChar : char, maxLength : int, style : GUIStyle, params options : GUILayoutOption[]) : string
 参数
password 用于编辑的密码。这个函数返回值应该被赋回这个字符串。如下的例子。
maskChar 用来隐藏密码的字符。
maxLength 字符串的最大长度。如果不设置，用户可以一直输入。
style 使用的风格。如果不设置，将使用当前GUISkin的textField风格。
返回string – 编辑过的密码。
描述：制作一个用户可以输入密码的文本域。
var passwordToEdit = “My Password”;
function OnGUI()
{// 制作一个密码与来调整stringToEdit。
  passwordToEdit = GUILayout.PasswordField(passwordToEdit, “*”, 25);
}
◆ static function RepeatButton(image : Texture, params options : GUILayoutOption[]) : bool
◆ static function RepeatButton(text : string, params options : GUILayoutOption[]) : bool
◆ static function RepeatButton(content : GUIContent, params options : GUILayoutOption[]) : bool
◆ static function RepeatButton(image : Texture, style : GUIStyle, params options : GUILayoutOption[]) : bool
◆ static function RepeatButton(text : string, style : GUIStyle, params options : GUILayoutOption[]) : bool
◆ static function RepeatButton(content : GUIContent, style : GUIStyle, params options : GUILayoutOption[]) : bool
 参数
 text显示在该按钮上的文本。
 image  显示在该按钮上的Texture。
 content  用于这个按钮的文本，图形和提示。
 style使用的风格，如果不设置，将使用当前GUISkin的button风格。
 
options  一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
 参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
 返回bool - /true/当用户按住按钮时
 描述：制作一个重复按钮，只要用户按住鼠标这个按钮一直返回真。
◆ static function SeletionGrid(selected : int, texts : string[], xCount : int, params options : GUILayoutOption[]) : int
◆ static function SeletionGrid(selected : int, images : Texture[], xCount : int, params options : GUILayoutOption[]) : int
◆ static function SeletionGrid(selected : int, contents : GUIContent[], xCount : int, params options : GUILayoutOption[]) : int
◆ static function SeletionGrid(selected : int, texts : string[], xCount : int, style : GUIStyle, params options : GUILayoutOption[]) : int
◆ static function SeletionGrid(selected : int, images : Texture[], xCount : int, style : GUIStyle, params options : GUILayoutOption[]) : int
◆ static function SeletionGrid(selected : int, contents : GUIContent[], xCount : int, style : GUIStyle, params options : GUILayoutOption[]) : int
 参数
 selected选择按钮的索引
 texts 显示在按钮的字符串数组。
 images在按钮上纹理数组
 contents用于按钮的文本，图形和提示。
xCount  在水平方向多少个元素，元素将被缩放来适应，除非风格定义了一个fixedWidth，空间高度将由元素的数量决定。
style 使用的风格。如果不设置，将使用当前GUISkin的button风格。
options 一个可选的布局选项的列表，它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
返回int – 选择按钮的索引
描述：制作一个选择网格
◆ static function Space(pixel : float) : void
 描述：在当前布局组中插入一个空格
 空格的方向依赖与使用这个命令时当前所在布局组。如果在垂直组，空格是垂直的。
 function OnGUI()
 {
  GUILayout.Button(“I’m the first button”);
  //在两个按钮间插入20像素
  GUILayout.Space(20);
 
}
  GUILayout.Button(“I’m a bit futher down”);
}
 在水平组，pixels将是水平的；
 function OnGUI()
 {
  //开始水平组以便显示水平空格
  GUILayout.BeginHorizontal(“box”);
  GUILayout.Button(“I’m the first button”);
  //在两个按钮间插入20像素
  GUILayout.Space(20);
  GUILayout.Button(“I’m to the right”);
  //结束上面开始的水平组
  GUILayout.EndHorizontal();
}
◆ static function TextArea(text : string, params options : GUILayoutOption[]) : string
◆ static function TextArea(text : string, maxLength : int, params options : GUILayoutOption[]) : string
◆ static function TextArea(text : string, style : GUIStyle, params options : GUILayoutOption[]) : string
◆ static function TextArea(text : string, maxLength : int, style : GUIStyle, params options : GUILayoutOption[]) : string
 参数
text  用于编辑的文本。这个函数返回值应该被赋回这个字符串。如下的例子。
maxLength  字符串的最大长度。如果不设置，用户可以一直输入。
style 使用的风格。如果不设置，则使用当前GUISkin的textField风格。
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
 返回string – 编辑过的字符串。
 描述：制作一个多行文本域。这里用户可以编辑这个字符串。
◆ static function TextField(text : string, params options : GUILayoutOption[]) : string
◆ static function TextField (text : string, maxLength : int, params options : GUILayoutOption[]) : string
◆ static function TextField (text : string, style：GUIStyle, params options : GUILayoutOption[]) : string
◆ static function TextField (text : string, maxLength : int, style : GUIStyle, params options : GUILayoutOption[]) : string
 参数
text  用于编辑的文本。这个函数返回值应该被赋回这个字符串，如下的例子。
 
maxLength  字符串的最大长度。如果不设置，用户可以一直输入。
 style 使用的风格。如果不设置，将使用当前的GUISkin的textArea
options  一个可选的布局选项的列表，它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
返回string – 编辑过的字符串。
描述：制作一个单行文本域。这里用户可以编辑这个字符串。
var stringToEdit = “Hello, world”;
function OnGUI()
{
  //制作一个文本域来调整stringToEdit
  stringToEdit = GUILayout.TextField(stringToEdit, 25);
}
◆ static function Toogle(value : bool, image : Texture, params options : GUILayoutOption[]) : bool
◆ static function Toogle(value : bool, text : string, params options : GUILayoutOption[]) : bool
◆ static function Toogle(value : bool, content : GUIContent, params options : GUILayoutOption[]) : bool
◆ static function Toogle(value : bool, image : Texture, style : GUIStyle, params options : GUILayoutOption[]) : bool
◆ static function Toogle(value : bool, text : string, style : GUIStyle, params options : GUILayoutOption[]) : bool
◆ static function Toogle(value : bool, content : GUIContent, style : GUIStyle, params options : GUILayoutOption[]) : bool

参数
 value按钮是打开或关闭
 text 显示在该按钮上的文本
 image显示在该按钮上的Texture
 content用于这个按钮的文本，图形和提示
 style 使用的风格。如果不设置，将使用当前GUISkin的button风格。
options  一个可选的布局选项的列表，它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
 返回bool – 按钮的新值
 描述：制作一个on/off开关按钮。

◆ static function Toolbar(selected: int, texts : string[], params options : GUILayoutOption[]) : int
◆ static function Toolbar(selected: int, images : Texture[], params options : GUILayoutOption[]) : int
◆ static function Toolbar(selected: int, contents: GUIContent[], params options : GUILayoutOption[]) : int
◆ static function Toolbar(selected: int, texts : string[], style : GUIStyle, params options : GUILayoutOption[]) : int
◆ static function Toolbar(selected: int, image : Texture[],style : GUIStyle, params options : GUILayoutOption[]) : int
◆ static function Toolbar(selected: int, content : GUIContent[],style : GUIStyle, params options : GUILayoutOption[]) : int
 参数
 selected选择按钮的索引
 texts 显示在按钮上的字符串数组
 images在按钮上的纹理数组
 contents用于按钮的文本，图形和提示数组
 style 使用的风格。如果不设置，将使用当前GUISkin的button风格。
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
 返回int – 选择按钮的索引
 描述：制作一个工具栏
◆ static function VerticalScrollbar(value: float, size : float, topValue : float, buttomValue : float, params options : GUILayoutOption[]) : float
◆ static function VerticalScrollbar(value: float, size : float, topValue : float, buttomValue : float, style : GUIStyle, params options : GUILayoutOption[]) : float
 参数
 value在min和max之间的位置
 size 能看见多大？
 topValue滚动条顶端的值
 bottomValue  滚动条底端的值
style  用于滚动条背景的风格。如果不设置，将使用当前GUISkin的horizontalScrollbar。
options 一个可选的布局选项的列表。它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
返回float – 修改后的值。这可以通过拖动这个滚动条，或者单击两端的箭头来改变。
 描述：制作一个垂直滚动条。滚动条可以用来滚动文档。大多数情况下，你会使用scollView代替。
 找到额外的元素：
 在滚动条两端的按钮将在当前皮肤中搜索“upbutton”和“downbutton”作为风格。滚动条的滑块（你拖动的东西）将搜索并使用名为thumb的风格。
 //这将使用下面的风格名来决定该按钮的尺寸/位置
 //MyVerticalScrollbarupbutton – 用于顶端按钮的风格名称
 //MyVerticalScrollbardownbutton – 用于底端按钮的风格名称
 //MyScrollbarthumb – 用于滑块的风格名称
 scrollPos = GUILayout.HorizontalScrollbar(scrollPos, 1, 0, 100, “MyVerticalScrollbar”);
◆ static function VerticalSlider(value : floar, leftValue : float, rightValue : float, params options : GUILayoutOption[]) : float
◆ static function VerticalSlider(value : floar, leftValue : float, rightValue : float, slider : GUIStyle, thumb : GUIStyle, params options : GUILayoutOption[]) : float
 参数
 value滑杆显示的值。这个决定可拖动滑块的位置。
 topValue滑杆顶端的值。
 downValue  滑杆底端的值。
slider  用于显示拖动区域的GUIStyle。如果不设置，将使用当前GUISkin的horizontalSlider。
thumb  用于显示拖动块的GUIStyle。如果不设置，将使用当前的GUISkin的horizontalSliderThumb。
options  一个可选的布局选项的列表，它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
◆ static function Width(width : float) : GUILayoutOption
 描述：传递给控件的选项以便给它一个绝对宽度
◆ static function Window(id : int, screenRect : Rect, func : GUIWindowFunction, text : string) : Rect
◆ static function Window(id : int, screenRect : Rect, func : GUIWindowFunction, image : Texture) : Rect
◆ static function Window(id : int, screenRect : Rect, func : GUIWindowFunction, content : GUIContent) : Rect
◆ static function Window(id : int, screenRect : Rect, func : GUIWindowFunction, text : string, style : GUIStyle) : Rect
◆ static function Window(id : int, screenRect : Rect, func : GUIWindowFunction, image : Texture, style : GUIStyle) : Rect
 
◆ static function Window(id : int, screenRect : Rect, func : GUIWindowFunction, content : GUIContent, style : GUIStyle) : Rect
 参数
 id 用于每个窗口唯一的ID。这是用于接口的ID。
clientRect  屏幕上用于窗口的矩形区域。布局系统将试图使窗体在他内部。如果不能，它将调整矩形去适应它
func  在窗体内部创建GUI的函数。这个函数必须使用一个函数 – 当前创建GUI的窗体id。
image 用于在标题栏上显示图片的Texture。
content 用于这个窗口的文本，图形和提示。
style 使用的风格。如果不设置，将使用当前GUISkin的button风格。
options  一个可选的布局选项的列表，它用来指定额外的布局属性。任何在这里设置的值将覆盖由style定义的设置。
参见：GUILayout.Width,  GUILayout.Height,  GUILayout.MinWidth, GUILayout.MaxWidth, GUILayout.MinHeight, GUILayout.MaxHeight, GUILayout.ExpandWidth, GUILayout.ExpandHeight.
返回Rect – 窗口位于举行位置。这个可能与你传入的一个具有不同位置和尺寸。
描述：制作一个弹出窗口。它的内容是自动布局的。
窗口浮动在普通GUI控件之上。具有单击激活的特点并可以有选择的随意被用户拖动。不像其他的控件，你需要传递给他们一个独立的功能并放置在窗口中这儿是一个小例子来帮助你开始：
var windowRect = Rect(20, 20, 120, 50);

function OnGUI()
{
 //注册窗口，注意第三个参数
 windowRect = GUILayout.Window(0, windowsRect, DoMyWindow, “My Window”);
}

//制作窗口内容
function DoMyWindow(windowed : int)
{
 //这个按钮将调整以适应物体
 if(GUILayout.Button(“Hello World”))
  print(“Get a click”);
}
你传入的客户区域只是作为一个参考，为了对窗口使用额外的限制。闯入一些额外的布局选项。用在这里的一个将覆盖尺寸的计算。这是一个简单的例子。
var windowRect = Rect(20, 20, 120, 50);

function OnGUI()
{
 //注册窗口，这里我们指示布局系统必须使窗体为100像素宽。
 windowRect = GUILayout.Window(0, windowRect, DoMyWindow, “My Window”, GUILayout.width(100));
}

//制作窗体内容
function DoMyWindow(windowID : int)
{
 //这个按钮大小不能适应这个窗体
//通常，这个窗体将被扩展以便适应这个按钮。但是由于GUILayout.Width将只允//许窗体为100像素宽
if(GUILayout.Button(“Please click me a lot”))
 print(“Get a click”);
 
}
GUISettings
 类
 用于GUI如何表现的通用设置。
 这些被所有在GUISkin中的元素共享。
变量
◆ var cursorColor : Color
 描述：文本域中光标的颜色。
◆ var cursorFlashSpeed : float
 描述：文本域指示的闪动速度。
 这个是闪动/秒。如果设置为0，闪动将被禁用。如果设置为-1，闪动速度将匹配系统的默认速度。
◆ var doubleClickSelectsWord : bool
 描述：文本域中双击是否选择单词。
◆ var selectionColor : Color
 描述：文本域中选择矩形的颜色。
◆ var tripleClickSelectsLine : bool
 描述：文本域中点击鼠标三次是否选择整行文本。
GUIStyleState
 类
 为GUIStyle物体使用的给定状态的一个特定值。
 GUIStyle包含用于显示GUI元素的所有值
变量
◆ var background : Texture2D
 描述：在这个状态中被GUI元素使用的背景图片。
◆ var textColor : Color
 描述：在这个状态中被GUI元素使用的文本颜色。
GUIStyle
类
GUI元素的风格位置
这个类包含一个GUI元素如何被渲染的所有信息。它包含用于字体，图标位置，背景图标，和间距的信息。它不包含关于它包含什么的信息 – 仅仅定义用这个风格渲染的文本如何被显示。它不定义这个元素可以发生什么交互，但是定义了用于交互的显示设置。
一个GUIStyle的设置。这是模仿一个CSS样式。它包含下列事项的设置：
背景图片
 这些被渲染在空间后面。不同的图像可以被指定为正常显示。当用户将鼠标放在元素上时的显示，当使用者按下选择 – 以及当元素被打开，如触发按钮，下面的这些都被称为风格的状态。参见：normal, hover, active, onNormal, onHover, onActive – 这些包含每个状态的背景图片，文本颜色属性。
文本渲染
 这个风格都可以定义一个字体渲染，以及文本对齐，换行和剪裁的设置，它也定了该风格元素不同状态的文本颜色参考 : font, alignment, wordWrap, normal, hover, active, onHover, onActive
图标位置
 GUIStyle可以渲染文本，图标或者两者兼而有之。GUIStyle定义渲染时这两者间的相关位置（这可以强制它只显示他们其中之一）。参见：imagePosition
尺寸和间距选项
 GUIStyle包含填充，边缘和边界。这些不严格地对应类似命名的CSS属性。一个GUIStyle可以选择的定义一个固定的宽度和高度。参见：margin, padding, border, fixedWidth, fixedHieght
变量
◆ var active : GUIStyleState
 描述：空间被按下时的渲染设置。
◆ var alignment : TextAnchor
 描述：文本对齐
◆ var border : RectOffset
 描述：所有背景图片的边界。
 这个对应于GUITexture的边界设置。它只影响渲染的背景图像，不影响定位。
◆ var clipOffset : Vector2
 描述：用于该GUIStyle内容的剪裁偏移。
◆ var clipping : TextClipping
 描述：当渲染的内容相对于给定的区域太大时做什么
◆ var contentOffset : Vector2
 描述：用于该GUIStyle内容的像素偏移。
◆ var fixedHeight : float
 描述：如果非0，任何用这个风格渲染的GUI元素将有这里指定的高度。
◆ var fixedWidth : float
 描述：如果非0，任何用这个风格渲染的GUI元素将有这里指定的宽度。
◆ var focused : GUIStyleState
 描述：元素获得键盘焦点时的渲染设置。
◆ var font : Font
 描述：用于渲染的字体。如果null，当前的GUISkin的默认字体将被使用。
◆ var hover : GUIStyleState
 描述：鼠标悬停在控件时的渲染设置。
◆ var imagePosition : ImagePosition
 描述：GUIContent的图片和文本如何组合。
◆ var lineHeight : float
 描述：这个风格一行文本的高度。以像素为单位。（只读）
◆ var margin : RectOffset
 描述：以这种风格渲染的元素和任何其他GUI元素之间的边界。
这个只影响自动布局。（参见 : GUILayout）
◆ var name : string
 描述：GUIStyle的名称。用来基于名称获取它们。
◆ var normal : GUIStyleState
 描述：组建正常显示是渲染设置。
◆ var onActive : GUIStyleState
 描述：元素被打开并具有键盘焦点时的渲染设置。
◆ var onFocused : GUIStyleState
 描述：元素被打开并被按下时的渲染设置。
◆ var onHover : GUIStyleState
 描述：控件被打开并且鼠标悬停在它上面时的渲染设置
◆ var onNormal : GUIStyleState
 描述：控件被打开时的渲染设置。
◆ var overflow : RectOffset
 描述：添加到背景图片的额外间距。
 这可用于如果你的图片要投射一个阴影，并且向扩展背景图片超出使用这个风格的制定GUI元素的矩形时。
◆ var padding : RectOffset
 描述：从GUIStyle边界到内容开始的间距
◆ var stretchHeight : bool
 描述：这个风格的GUI元素可以被垂直拉伸以便更好的布局么？
◆ var stretchWidth : bool
 描述：这个风格的GUI元素可以被水平拉伸以便更好的布局么？
◆ var wordWrap : bool
 描述：文本换行？
 这将导致任何包含的文本被换行以便适应控件的宽度。
构造函数
◆ static function GUIStyle() : GUIStyle
 描述：
◆ static function GUIStyle(other：GUIStyle) : GUIStyle
 描述：
函数
◆ function CalcHeight(content : GUIContent, width : float) : float
 描述：当渲染content并制定width时这个元素的高度。
◆ function CalcMinMaxHeight (content : GUIContent, outminWidth : float, outmaxWidth : float) : void
 描述：计算以这个风格渲染的content的最大最小宽度。
 被GUILayout使用来正确处理换行。
◆ function CalcScreenSize(contentSize : Vector2) : Vector2
 描述：计算用这个风格格式化的元素的尺寸，和一个给定的内容空格。
◆ function CalcSize(content : GUIContent) : Vector2
 描述：如果内容使用这个风格渲染，计算某些内容的尺寸。
 这个函数不考虑换行。要做到这点，你需要确定宽度，然后打调用CalcHeight分配计算出wordwrapped高度。
◆ function Draw(position : Rect, isHover: bool, isActive : bool, on : bool, hasKeyboardFocus : bool) : void
 描述：
◆ function Draw(position : Rect, text : string, isHover: bool, isActive : bool, on : bool, hasKeyboardFocus : bool) : void
 描述：用GUIStyle绘制一个文本字符串。
◆ function Draw(position : Rect, image : Texture, isHover: bool, isActive : bool, on : bool, hasKeyboardFocus : bool) : void
 描述：用GUIStyle绘制图片。如果图片太大，它将被缩小。
◆ function Draw(position : Rect, content : GUIContent, isHover: bool, isActive : bool, on : bool, hasKeyboardFocus : bool) : void
 描述：用GUIStyle绘制文本和图片。如果图片太大，它将被缩小。
◆ function Draw(position : Rect, content : GUIContent, controlID : int, on : bool = false) : void
 描述：GUI代码中使用的主要绘制函数。
◆ function DrawCursor(position : Rect, content : GUIContent, controlID : int, Character : int) : void
 描述：用选定的内容绘制这个GUIStyle
◆ function DrawWithTextSelection(position : Rect, content : GUIContent, controlID : int, firstSelectedCharacter : int, lastSelectedCharacter : int) : void
 描述：用选定的内容绘制这个GUIStyle
◆ function GetCursorPixelPosition(position : Rect, content : GUIContent, cursorStringIndex : int) : Vector2
 描述：获取给定字符串索引的像素位置。
◆ function GetCursorStringIndex(postion : Rect, content : GUIContent, cursorPixelPosition : Vector2) : int
 描述：当用户在cursorPixelPosition处点击时获取光标位置（索引到内容文本）这部计算内容中任何图片。
类变量
◆ static var none : GUIStyle
 描述：空GUIStyle的快捷方式。
 这个风格不包含装饰而仅仅以缺省字体渲染所有东西。
 function OnGUI()
 {  //制作一个没有装饰的按钮
  GUI.Button(“I’m very bare”, GUIStyle.none);
}
类方法
◆ static implicit function GUIStyle(str : string) : GUIStyle
 描述：从当前皮肤获取一个名为GUI风格。
GUIUtility
 类
 用于制作新GUI空间的工具类。
 除非从头开始创建自己的GUI控件，否则你不需要使用这些函数。
类变量
◆ static var hotControl : int
 描述：当前具有特点的控件controlID。
 热点空间是临时激活的一个控件。当用于在一个按钮上按下鼠标时，它变为热点。当一个控件具有热点时，其他控件不允许响应鼠标事件。一旦用户鼠标示范，这个控件设置hotControl为0以便表明其他控件可以响应用户输入。

◆ static var keyboardControl : int
 描述：具有键盘焦点控件的controlID。
类方法
◆ static function GetControlID(focus : FocusType) : int
◆ static function GetControlID(hint : int, focus : FocusType) : int
◆ static function GetControlID(content : GUIContent, focus : FocusType) : int
 描述：为一个控件获取唯一ID。
◆ static function GetControlID(focus : FocusType, position : Rect) : int
◆ static function GetControlID(hint : int, focus : FocusType, position : Rect) : int
◆ static function GetControlID(content : GUIContent, focus : FocusType, position : Rect) :  int
描述：为一个控件获取唯一ID。
◆ static function GetStateObject(t : type, controlID : int) : object
 描述：从一个controlID获取一个状态对象。
 这将返回一个可重用的状态对象，它的controlID是唯一的。如果没有，一个新的将被创建并添加到ControlID。
◆ static function GUIToScreenPoint(guiPoint : Vector2) : Vector2
 描述：将一个点从GUI位置转化为屏幕空间。
 参见：GUIUtility, ScreenToGUIPoint
◆ static function MoveNextAndScroll(forward: bool) : void
 描述：只允许从OnGUI内部调出GUI函数
◆ static function QueryStateObject(t: Type, controlID : int) : object
 描述：从一个controlID获取一个存在的状态物体。
 这个返回一个可回收的状态物体。这个物体具有唯一的controlID。如果没有，这个函数将返回null。
◆ static function RotateAroundPivot(angle: float, pivotPoint : Vector2) : void
 描述：使GUI围绕一个点旋转的辅助函数。
 修改GUI.matrix来绕着pivotPoint旋转所有的GUI元素angel度。
 参见：GUI.matrix, ScaleAroundPivot
◆ static function ScaleAroundPivot(scale: Vector2, pivotPoint: Vector2) : void
 描述：使GUI围绕一个点缩放的辅助函数。
 修改GUI,.matrix来绕着pivotPoint缩放所有的GUI元素angel度。
 参见：GUI.matrix, RotateAroundPivot
◆ static function ScreenToGUIPoint(screenPoint : Vector2) : object
 描述：将一个点从屏幕空间转化为GUI位置。
 用于反转计算GUIToScreenPoint的值。
 参见：GUIUtility.GUIToScreenPoint。
GUI
类
 GUI类是Unity GUI的手工定位接口
 参见：GUI tutorial
类变量
◆ static var backgroundColor : Color
 描述：全局的修改由GUI渲染的所有元素的背景颜色。
 这个获取多个color。
 参见：contentColor, color
◆ static var changed : bool
 描述：有任何控件的输入数据改变吗？
◆ static var color : Color
 描述：全局的修改GUI颜色。
 这将影响背景和文本颜色。
 参见：backgroundColor, contentColor
◆ static var contentColor : Color
 描述：修改由GUI渲染的所有文本的颜色。
 这个获取多个color。
 参见：backgroundColor : Color
◆ static var depth : int
 描述：当前执行的GUI行为的排序深度
 当你有不同的脚本同时运行时。设置这个来决定顺序。
◆ static var enabled : bool
 描述：GUI启用了？
 设置这个值为假将禁用所有GUI交互。所有的控件将以半透明方式绘制。并将不响应用户输入。
 //这个值跟踪扩展的选项是否可以被打开。
 var allOptions = true;
 //两个扩展选项
 var extended1 = true;
 var extended2 = true;
 function OnGUI()
{
 //制作一个开关控件以便允许用户编辑扩展的选项
 allOptions = GUI.Toogle(Rect(0, 0, 150, 20), allOptions, “Edit All Options”);

//将它的值赋给GUIEnabled – 如果上面的复选框被禁用
 //这些GUI元素将
 GUIenabled = allOptions

//这两个控件只在上面的按钮为On时启用。
 extended1 = GUI.Toogle(Rect(20, 20, 130, 20), extended1, “Extended Option 1”);
 extended2 = GUI.Toogle(Rect(20, 40, 130, 30), extended2, “Extended Option 2”);

//使用条件语句，以使GUI代码可以再次启用
 GUI.enabled = true; 
 //制作一个OK按钮
 if(GUI.Button(Rect(0, 60, 150, 20), “OK”))
print(“user clicked ok”);
}
◆ static var matrix : Matrix4x4
 描述：GUI变换矩阵
◆ static var skin : GUISkin
 描述：使用的全局皮肤
 你可以在任何时候设置这个来改变GUI的外观。如果设置为null，这个皮肤将使用默认的Unity皮肤。
◆ static var tooltip : string
 描述：鼠标移动到空间上的提示信息（只读）。
 创建GUI空间是。你可以给他传递一个提示。这可以通过改变内容参数来制作一个自定义GUIContent物体，而不是仅仅传递一个字符串。
 但鼠标经过带有提示性的控件时，它设置全局的GUI.tooltip值为传入得知。在OnGUI代码的末端，你可以制作一个标签来显示GUI.tooltip的值。
 function OnGUI()
{
 //制作一个按钮，它使用自定义GUI.Content参数来传递提示。
 GUI.Button(Rect(10, 10, 100, 20), GUIContent(“Click me”, “This is the tooltip”));

//显示鼠标指向或具有键盘焦点的控件提示
 GUI.Button(Rect(10, 55, 100, 20), “No tooltip here”);
}
 你可以使用元素的次序来创建’层次化的’提示
function OnGUI()
{
 //这个box比随后的许多元素大，并且它有一个提示。
 GUI.Box(Rect(5, 35, 110, 75), GUIContent(“Box”, “this box has a tooltip”));

这个按钮在box内部，但是没有提示，因此它不会覆盖这个box的提示。
 GUI.Button(Rect(10, 55, 100, 20), “No tooltip here”);
  
 这个按钮在box内部，并且有一个提示，因此它会覆盖这个box的提示。
GUI.Button(Rect(10, 80, 100, 20), GUIContent(“I have a tooltip”, “This button overrides the box”));
//最后，显示来自鼠标指向或具有键盘焦点的提示
GUI.Label(Rect(10, 40, 100, 40), GUI.tooltip);
}
Tooltip也能用来实现一个OnMouseOver/OnMouseOut消息系统：
var lastTooltip = “”;
function OnGUI()
{
 GUILayout.Button(GUIContent(“Play Game”, “Button1”));
 GUILayout.Button(GUIContent(“Quit”, “Button2”));

if(Event.current.type == EventType.repaint && GUI.tooltip! = lastTooltip)
{
  if(lastTooltip != “”)
SendMessage(lastTooltip + “OnMouseOut”, SendMessageOptions, DontRequireReceiver);
  if(GUI.tooltip != “”)
SendMessage(GUI.tooltip + “OnMouseOut”, SendMessageOptions, DontRequireReceiver);
  lastTool\tip = GUI.tooltip;
 }
}
类方法
◆ static function BeginGroup(position : Rect) : void
◆ static function BeginGroup(position : Rect, text : string) : void
◆ static function BeginGroup(position : Rect, image : Texture) : void
◆ static function BeginGroup(position : Rect, content : GUIContent) : void
◆ static function BeginGroup(position : Rect, style : GUIStyle) : void
◆ static function BeginGroup(position : Rect, text : string, style : GUIStyle) : void
◆ static function BeginGroup(position : Rect, image : Texture, style : GUIStyle) : void
◆ static function BeginGroup(position : Rect, content : GUIContent, style : GUIStyle) : void
 参数
 position屏幕用于组的矩形区域。
 text 显示在该组上的文本。
 image显示在该组上的Texture。
content  用于这个组的文本，图形和提示。如果提供，任何鼠标点击被组捕获，并且如果没有设置，不会渲染背景，和传递鼠标点击。
style 用于背景的风格。
描述：
开始组，必须与EndGroup调用匹配。
当你开始一个组时，用于GUI控件的坐标系统被设置为(0, 0)是组的左上角。所有控件被附加到组。组可以嵌套 – 如果使用，子被附加到他们的父。
当你在屏幕上移动一组GUI元素是这是非常有用的。一个普通的用法是设计你的菜单以适合一个特定的屏幕的尺寸。然后在更大的显示器上居中显示GUI。
function OnGUI()
{
 //约束所有的绘图在屏幕中心800*600的区域
 GUI.BeginGroup(new Rect(Screen.width / 2 – 400, Screen.height / 2 – 300, 800, 600));
 //在由BeginGroup定义的新坐标空间中绘制一个box
 //注意，现在（0，0）已经被移动了
 GUI.Box(new Rect(0, 0, 800, 600), “This box is new centered! – Here you would put your main menu”);
 //需要用一个EndGroup来匹配所有的BeginGroup调用。
 GUI.EndGroup();
}
 参见：matrix, BeginScrollView

◆ static function BeginScrollView(position : Rect, scrollPostion: Vector2, viewRect : Rect) : Vector2
◆ static function BeginScrollView(position : Rect, scrollPostion: Vector2, viewRect : Rect, alwaysShowHorizontal : bool, alwaysShowVertical : bool) : Vector2
◆ static function BeginScrollView(position : Rect, scrollPostion: Vector2, viewRect : Rect, horizontalScrollbar : GUIStyle, verticalScrollbar : GUIStyle) : Vector2
◆ static function BeginScrollView(position : Rect, scrollPostion: Vector2, viewRect : Rect, alwaysShowHorizontal : bool, alwaysShowVertical : bool, horizontalScrollbar : GUIStyle, verticalScrollbar : GUIStyle) : Vector2
 参数
 position  屏幕上用了ScrollView的矩形区域
 scrollPosition 用来显示的位置。
 viewRect  用在滚动视内部的矩形。
alwaysShowHorizontal  可选的参数用来总是显示水平滚动条。如果为假或不设置，它只在clientRect比position宽的时候显示
alwaysShowVertical 可选的参数用来总是显示垂直滚动条。如果为假或不设置，它只在clientRect比position长的时候显示。
horizontalScrollbar 用于水平滚动条的可选GUIStyle，如果不设置，将使用当前GUISkin的horizontalScrollbar.
verticalScrollbar 用于水平滚动条的可选GUIStyle，如果不设置，将使用当前GUISkin的verticalScrollbar.
返回Vector2 – 修改过的scrollPosition回传这个变量。如下的例子。
描述：在你的GUI中开始滚动视。
ScrollViews让你在屏幕上制作一个较小的区域。使用放置在ScrollView边上的滚动条来查看一个较大的区域。
//滚动视口的位置
var smallPosition = Vector2.zero;
function OnGUI()
{
 //一个绝对位置的例子。制作一个具有较大区域的滚动视。
 //并将它放置在一个小的矩形中。
 scrollPosition = GUI.BeginScrollView(Rect(10, 300, 100, 100), scrollPosition, Rect(0, 0, 220, 200));
 //制作四个按钮 – 每个角上有一个，由BeginScrollView最后一个参数定义的坐标系统。
GUI.Button(Rect(0, 0, 100, 20), “Top-left”);
GUI.Button(Rect(0, 0, 100, 20), “Top-right”);
GUI.Button(Rect(0, 0, 100, 20), “Bottom-left”);
GUI.Button(Rect(0, 0, 100, 20), “Bottom-right”);
//结束前面开始滚动视
GUI.EndScrollView();
}
◆ static function Box(position : Rect, text : string) : void
◆ static function Box(position : Rect, image : Texture) : void
◆ static function Box(position : Rect, content : GUIContent) : void
◆ static function Box(position : Rect, text : string, style : GUIStyle) : void
◆ static function Box(position : Rect, image : Texture, style : GUIStyle) : void
◆ static function Box(position : Rect, content : GUIContent, style : GUIStyle) : void
 参数
 position屏幕上用于box的矩形区域
 text 显示在该box上的文本
 image显示在该box上的Texture
 content用于这个box的文本，图形和提示
 style 使用的风格。如果不设置，将使用当前GUISkin的box风格。
 描述：制作一个图形box。
◆ static function BringWindowToBack(windowID: int) : void
 参数
 windowID  在window调用中创建窗体时使用的唯一标识。
 描述：将特定的窗口放到浮动窗口的后面。
◆ static function BringWindowToFront(windowID: int) : void
 参数
 windowID  在Window调用中创建窗体时使用的唯一标识。
 描述：将特定的窗口放到浮动窗口的前面。
◆ static function Button(position : Rect, text : string) : bool
◆ static function Button(position : Rect, image : Texture) : bool
◆ static function Button(position : Rect, content : GUIContent) : bool
◆ static function Button(position : Rect, text : string, style : GUIStyle) : bool
◆ static function Button(position : Rect, image : Texture, style : GUIStyle) : bool
◆ static function Button(position : Rect, content : GUIContent, style : GUIStyle) : bool
 参数
 position屏幕上用于按钮的矩形区域
 text 显示在该按钮上的文本
 image显示在该按钮上的Texture
 content用于这个按钮的文本，图形和提示
 style 使用的风格。如果不设置，将使用当前GUISkin的button风格。
 返回bool - /true/当用户单击按钮时
 描述：制作一个简单的按钮，用户点击它们的时候，就会有些事情发生。
◆ static function DragWindow(position : Rect) : void
 参数
 position可以拖动的窗口部分。这个被附加到实际窗口。
 描述：让窗口可拖动。
 插入这个函数的在你的窗口代码中使窗口可拖动。
 var windowRect = Rect(20, 20, 120, 50);
 
 function OnGUI()
 {
  //注册窗体
  windowRect = GUI.Window(0, windowRect, DoMyWindow, “My Window");
}
//制作窗体内容
function DoMyWindows(windowID : int)
{
 //制作一个非常长的矩形，高20像素。
 //这将使得窗口可以调整大小，通过顶部的标题栏 – 不管它有多宽。
 GUI.DragWindow(Rect(0, 0, 10000, 20));
}
◆ static function DragWindow() : void
 如果你想将整个窗体背景作为一个可拖动区域，不使用参数并将DragWindow放置到整体函数的最后。
 这意味着任何其他类型的控件将首先被处理并且拖动将只在没有其他控件获得焦点时使用。
◆ static function DrawTexture(position : Rect, image : Texture, scaleMode : ScaleMode =  stretchToFill, alphaBlend : bool = true, imageAspect : float = 0) : void
 参数
 position在屏幕上绘制一个内部包含有纹理的矩形。
 image需要被绘制的纹理。
 scaleMode  定义了当矩形的长宽比和内部图像的长宽比不同时如何缩放图像。
 alphaBlend  定义了alpha值是否参与图像的混合（默认为真）。如果为假，图像将会被绘制并显示。
 imageAspect  源图像的的长宽比。如果是0（默认值），则使用图像自身的长宽比。
 描述：在一个矩形内部绘制一个纹理。 
 参见：GUI.color, GUI.contentColor
◆ static function EndGroup() : void
 描述：结束一个组
 参见：BeginGroup()。
◆ static function EndScrollView : void
 描述：结束一个由BeginScrollView开始的滚动视。
◆ static function FocusControl(name : string) : void
 描述：把键盘焦点转移到定义的控件。
 参见：SetNextControlName, GetNameOfFocusedControl。
var username = "username";
function OnGUI () 
{  // 设置一个文本域中内部名称
  GUI.SetNextControlName ("MyTextField");
  // Make the actual text field.
  username = GUI.TextField (Rect (10,10,100,20), username);
  // If the user presses this button, keyboard focus , will move.
  if (GUI.Button (Rect (10,40,80,20), "Move Focus"))
  GUI.FocusControl ("MyTextField");
}
◆ static function FocusWindow(windowID : int) : void
 参数：
 windowID  当调用Window而创建的窗口的标识符。
 描述：使一个窗口被激活。
 参见：GUI.UnfocusWindow
◆ static function GetNameOfFocusedControl() : string
 描述：返回当前激活的控件的名字。控件的名字是由SetNextControlName函数创建的。当有名字的控件被激活时，函数返回它的名字；否则的话返回一个空字符串。
var login = "username";
var login2 = "no action here";
function OnGUI () 
{
    GUI.SetNextControlName ("user");
    login = GUI.TextField (Rect (10,10,130,20), login);
    login2 = GUI.TextField (Rect (10,40,130,20), login2);
    if (Event.current.Equals (Event.KeyboardEvent ("return")) && GUI.GetNameOfFocusedControl () == "user")
     {
          Debug.Log ("Login");
      }
    if (GUI.Button (new Rect (150,10,50,20), "Login"))
        Debug.Log ("Login");
}
  参见：SetNextControlName, FocusControl
  login2 = GUI.TextField(new Rect(10, 40, 130, 20), login2);
if(Event.current.Equals(Event.KeyboardEvent.(“return”))&&GUI.GetNameOfFocusedControl() == “user”)
 Debug.log(“Login”);
if(GUI.Button(new Rect(150, 10, 50, 20), “Login”))
 Debug.log(“Login”);
}
 参见：SetNextControlName
◆ static function HorizontalScrollbar(position : Rect, value : float, size : float, leftValue : float, rightValue : float) : bool
◆ static function HorizontalScrollbar(position : Rect, value : float, size : float, leftValue : float, rightValue : float, style : GUIStyle) : bool
 参数
position屏幕上用于滚动条的矩形区域
value在min和max之间的位置
 size 能看见多大？
 leftValue滚动条左边的值
 rightValue  滚动条右边的值
 style 用于滚动条背景的风格。如果不设置，将使用当前GUISkin的horizontalScrollbar。
 返回float – 修改后的值。这可以通过拖动这个滚动条，或者单击两端的箭头来改变。
 描述：制作一个水平滚动条。滚动条可以用来滚动文档。大多数情况下，你会使用scrollViews代替。
 找到额外的元素：
 在滚动条两端的按钮将在当前皮肤中搜索”leftbutton”和”rightbutton”作为风格。滚动条的滑块（你拖动的东西）将搜索并使用名为“thumb”的风格。
 //这将使用下面的风格名来决定该按钮的尺寸/位置
 //MyScrollbarrightbutton – 用于左侧按钮的风格名称
 //MyScrollbarleftbutton – 用于右侧按钮的风格名称
 //MyScrollbarthumb – 用于滑块的风格名称
 scrollPos = HoriztontalScrollbar(Rect(0, 0, 100, 20), scrollPos, 1, 0, 100, “My Scrollbar”);
◆ static function HorizontalSlider(position : Rect, value : float, leftValue : float, rightValue :  float) : float
◆ static function HorizontalSlider(position : Rect, value : float, leftValue : float, rightValue :  float, slider : GUIStyle, thumb : GUIStyle) : float
 参数
position屏幕上用于滑杆的矩形区域
value滑杆显示的值。这个决定可拖动的位置。
 leftValue滑杆左边的值
 rightValue  滑杆右边的值
 slider用于显示拖动区域的GUIStyle。如果不设置, 将使用当前GUISkin的  horizontalSlider。
 thumb用于显示拖动块的GUIStyle。如果不设置, 将使用当前GUISkin的horizontalSliderThumb。
 返回float – 被用户设置的值。
 描述：一个用户可以拖动的滑杆。可以在min和max只见改变一个值。
◆ static function Label(position : Rect, text : string) : void
◆ static function Label(position : Rect, image : Texture) : void
◆ static function Label(position : Rect, content : GUIContent) : void
◆ static function Label(position : Rect, text : string, style : GUIStyle) : void
◆ static function Label(position : Rect, image : Texture, style : GUIStyle) : void
◆ static function Label(position : Rect, content : GUIContent, style : GUIStyle) : void
 参数
 position屏幕上用于标签的矩形区域
 text 显示在该标签上的文本
 image显示在该标签上的Texture
 content用于这个标签的文本，图形和提示
 style 使用的风格。如果不设置，将使用当前GUISkin的label
 描述：在屏幕上制作一个文本或者纹理标签.
 标签没有用户交互，不会获取鼠标点击并总是以普通风格渲染。如果你想制作一个可视化响应用户输入的控件，使用一个Box控件。
 例如：绘制一个传统的Hello world字符串
 function OnGUI
 {
  GUI.Label(Rect(10, 10, 100, 20), “Hello world”);
 }
 例如：在屏幕上绘制一个纹理。标签也用于显示纹理，而不仅是字符串。简单传递一个纹理。
 var textureToDisplay : Texture2D;
 function OnGUI()
 {
  GUI.Label(Rect(10, 40, textureToDisplay.width, textureToDiplay.height), textureToDisplay);
 }
◆ static function PasswordField(position : Rect, password : string, markChar : char) : string
◆ static function PasswordField(position : Rect, password : string, markChar : char,  maxLength : int) : string
◆ static function PasswordField(position : Rect, password : string, markChar : char, style :  GUIStyle) : string
◆ static function PasswordField(position : Rect, password : string, markChar : char,  markChar : char, style : GUIStyle) : string
 参数
 position屏幕上用于文本的矩形区域
 password  用于编辑的密码。这个函数返回值应该被赋回这个字符串。如下的例  子。
 markChar  用来隐藏密码的字符。
 maxLength  字符串的最大长度。如果不设置，用户可以一直输入。
 style使用的风格。不过不设置，将那个使用当前GUISkin的textField风格。
 返回string – 编辑过的密码
 描述：制作一个用户可以输入密码的文本域。
 var passwordToEdit = “My Password”;

function OnGUI()
 {
  //制作一个文本来调整stringToEdit。
  passwordToEdit = GUI.PasswordField(Rect(10, 10, 200, 20), passwordToEdit, “*”, 25);
 }

◆ static function RepeatButton(position : Rect, text : string) : bool
◆ static function RepeatButton(position : Rect, image : Texture) : bool
◆ static function RepeatButton(position : Rect, content : GUIContent) : bool
◆ static function RepeatButton(position : Rect, text : string, style : GUIStyle) : bool
◆ static function RepeatButton(position : Rect, image : Texture, style : GUIStyle) : bool
◆ static function RepeatButton(position : Rect, content : GUIContent, style : GUIStyle) : bool
 参数
 position  屏幕上用于按钮的矩形区域
 text显示在该按钮上的文本
 image  显示在该按钮上的Texture
 content  用于这个按钮的文本，图形和提示
 style使用的风格。不过不设置，将那个使用当前GUISkin的button风格。
 返回bool - /true/当用户单击按钮时。
 描述：制作一个按钮。当用户按住它时一直是激活的。
◆ static function ScrollTo(position : Rect) : void
 描述：滚动所有包含在scrollview中的数据以便position可见。
◆ static function SelectionGrid (position : Rect, selected : int, texts : string[], xCount : int) :  int
◆ static function SelectionGrid (position : Rect, selected : int, images : Texture[], xCount :  int) : int
◆ static function SelectionGrid (position : Rect, selected : int, content : GUIContent[],  xCount : int) : int
◆ static function SelectionGrid (position : Rect, selected : int, texts : string[], xCount : int,  style : GUIStyle) :  int
◆  static function SelectionGrid (position : Rect, selected : int, images : Texture[], xCount : int,  style : GUIStyle) :  int
◆ static function SelectionGrid (position : Rect, selected : int, content : GUIContent[],  xCount : int, style : GUIStyle) : int
 参数
 position屏幕上用于网格的矩形区域。
 selected选择的网格按钮的索引
 texts 显示在网格按钮上的字符串数组
 images显示在网格按钮上的纹理数组
 contents用于这个网格按钮的文本，图形和提示数组
 xCount在水平方向有多少个像素。空间将被缩放来适应，除非风格定义了一  个fixWidth。
 style 使用的风格。如果不设置，将使用当前GUISkin的button风格。
 返回int – 选择按钮的索引。
 描述：制作一个按钮网络。
◆ static function SetNextControlName(name : string) : void
 描述：设置下一个控件的名称。
 这是接下来的控件被注册。
◆ static function TextArea(position : Rect, text : string) : string
◆ static function TextArea(position : Rect, text : string, maxLength : int) : string
◆ static function TextArea(position : Rect, text : string, style : GUIStyle) : string
◆ static function TextArea(position : Rect, text : string, maxLength : int, style : GUIStyle) :  string
 参数
 position  屏幕上用于文本的矩形区域
 text用于编辑的文本。这个函数返回值应该被赋回这个字符串。如下的例子。
 maxLength 字符串的最大长度。如果不设置，用户可以一直输入。
 style使用的风格。如果不设置，将使用当前GUISkin的textArea。
 返回string – 编辑过的字符串
 描述：制作一个多行文本区域。这里用户可以编辑这个字符串。
 var stringToEdit = “Hello World\nI’ve got 2 lines…”;
 function OnGUI()
 {
  //制作一个多行文本区域来调整stringToEdit
  stringToEdit = GUI.TextArea(Rect(10, 10, 200, 100), stringToEdit, 200);
 }
◆ static function TextField(position : Rect, text : string) : string
◆ static function TextField(position : Rect, text : string, maxLength : int) : string
◆ static function TextField(position : Rect, text : string, style : GUIStyle) : string
◆ static function TextField(position : Rect, text : string, maxLength : int, style :  GUIStyle) : string
 参数
 position  屏幕上用于文本的矩形区域
 text用于编辑的文本。这个函数返回值应该被赋回这个字符串。如下的例子。
 maxLength 字符串的最大长度。如果不设置，用户可以一直输入。
 style使用的风格。如果不设置，将使用当前GUISkin的textField风格。
 返回string – 编辑过的字符串
 描述：制作一个单行文本域。这里用户可以编辑这个字符串。
 var stringToEdit = “Hello World”;

function OnGUI()
 {
  //制作一个文本域来调整stringToEdit
  stringToEdit = GUI.TextField(Rect(10, 10, 200, 20), stringToEdit, 25);
 }
◆ static function Toggle(position : Rect, value : bool, text : string) : bool
◆ static function Toggle(position : Rect, value : bool, image : Texture) : bool
◆ static function Toggle(position : Rect, value : bool, content : GUIContent) : bool
◆ static function Toggle(position : Rect, value : bool, text : string, style : GUIStyle) : bool
◆ static function Toggle(position : Rect, value : bool, image : Texture, style : GUIStyle) : bool
◆  static function Toggle(position : Rect, value : bool, content : GUIContent, style : GUIStyle) :  bool
 参数
 position屏幕上用于按钮的矩形区域
 value这个按钮是打开的或关闭
 text 显示在该按钮上的文本
 image显示在该按钮上的Texture
 content用于这个按钮的文本，图形和提示
 style 使用的风格。如果不设置，将使用当前GUISkin的toggle风格。
 返回bool – 按钮的新值
 描述：制作一个on/off开关按钮
◆ static function Toolbar(position : Rect, selected : int, texts : string[]) : int
◆ static function Toolbar(position : Rect, selected : int, images : Texture[]) : int
◆ static function Toolbar(position : Rect, selected : int, contents : GUIContent[]) : int
◆ static function Toolbar(position : Rect, selected : int, texts : string, style : GUIStyle[]) :  int
◆ static function Toolbar(position : Rect, selected : int, images : Texture, style : GUIStyle[]) :  int
◆  static function Toolbar(position : Rect, selected : int, contents : GUIContent[], style :  GUIStyle) :  int
 参数
 position屏幕上用于工具栏的矩形区域
 selected选择按钮的索引
 texts 显示在该工具栏上的字符串数组
 images显示在工具栏按钮上的纹理数组
 contents用于这个工具栏的文本，图形和提示数组。
 style 使用的风格。如果不设置，将使用当前GUISkin的button风格。
 返回int – 选择按钮的索引
 描述：制作一个工具栏

◆ static function UnfocusWindows() : void
 描述：从所有窗体上移除焦点。
◆ static function VerticalScrollbar(position : Rect, value : float, size : float, topValue : float,  buttonValue : float) : float
◆ static function VerticalScrollbar(position : Rect, value : float, size : float, topValue : float,  buttonValue : float, style : GUIStyle) : float
 参数
 position屏幕上用于滚动条的矩形区域。
 value在min和max之间的位置。
 size 能看见多大？
 topValue滚动条顶端的值
 bottomValue  滚动条底端的值
 style 使用的风格。如果不设置，将使用当前GUISkin的horizontalScrollbar  风格。
 返回float – 修改后的值。这可以通过拖动这滚动条，或者单击两端的箭头来改变。
 描述：制作一个垂直滚动条。滚动条可以用来滚动文档。大多数情况下，你会使用scrollViews代替。
 找到额外的元素：
 在滚动条两端的按钮将在当前皮肤中搜索“upbutton”和“downbutton”作为风格。滚动条的滑块（你拖动的东西）将搜索并使用名为“thumb”的风格。
 //这将使用下面的风格名来决定该按钮的尺寸位置。
 //MyVertScrollbarupbutton – 用于上端按钮的风格名称。
 //MyVertScrollbardownbutton – 用于下端按钮的风格名称。
 //MyVertScrollbarthumb – 用于滑块的风格名称。
 scrollPos = HorizontalScrollbar(Rect(0, 0, 100, 20), scrollPos, 1, 0, 100, “MyVertScrollbar”);

◆ static function VerticalSlider(position : Rect, value : float, topValue : float, buttonValue :  float) : float
◆ static function VerticalSlider(position : Rect, value : float, topValue : float, buttonValue :  float, slider : GUIStyle, thumb : GUIStyle) : float
 参数
 position屏幕上用于滑杆的矩形区域。
 value滑杆显示的值。这个决定可移动滑块的位置。
 topValue滑杆顶端的值
 bottomValue  滑杆底端的值
 slider用于显示拖动区域的GUIStyle。如果不设置，将使用当前GUISkin的horizontalSlider。
 thumb用于显示土洞区域的GUIStyle。如果不设置，将使用当前GUISkin的horizontalSliderThumb。
 返回float – 被用户设置的值。
 描述：一个用户可以拖动的垂直滑杆。可以在min和max之间改变一个值。
◆ static function Window(id : int, position : Rect, func : WindowFunction, text : string) : Rect
◆ static function Window(id : int, position : Rect, func : WindowFunction, image : Texture) :  Rect
◆ static function Window(id : int, position : Rect, func : WindowFunction, content :  GUIContent) : Rect
◆ static function Window(id : int, position : Rect, func : WindowFunction, text : string, style :  GUISytle) : Rect
◆ static function Window(id : int, position : Rect, func : WindowFunction, image : Texture,  style : GUIStyle) : Rect
◆ static function Window(id : int, clientRect : Rect, func : WindowFunction, title :  GUIContent, style : GUIStyle) : Rect
 参数
 id用于每个窗口的唯一ID。这是用于接口的ID。
 clientRect 屏幕上用于组的矩形区域。
 func在窗体内部创建GUI的函数。这个函数必须使用一个函数 – 当前创建  GUI的窗体id
 text作为窗体标签的文本。
 image  用于在标题栏上显示图片的Texture
 content  用于这个窗口的文本，图形和提示。
 style用于窗口的可选风格。如果不设置，将使用当前GUISkin的window。
 返回Rect – 窗口位于的矩形位置
 描述：制作一个弹出窗口
 窗口浮动在普通GUI控件之上，具有单击激活的特点并可以有选择的随意被端用户拖动。不像其他的控件，你需要传递给他们一个独立的功能并放置在窗口中。注意：如果你使用GUILayout在窗口中放置你的组件，你应该使用GUILayout.Window。这是一个小例子帮助你开始：
 var windowRect = Rect(20, 20, 120, 50);
 function OnGUI()
 {
  //注册窗口。注意第三个参数。
  windowRect = GUI.Window(0, windowRect, DoMyWindow, “My Window”);
 }
 //制作窗口内容
 function DoMyWindow(windowID : int)
 {
  if(GUI.Button(Rect(10, 20, 100, 20), ”Hello World”))
print(“Get a click”);
 }
 你可以使用相同的函数来创建多个窗口。需要确保每个窗口有一个自己的ID。例如：
 var windowRect0 = Rect(20, 20, 120, 50);
 var windowRect1 = Rect(20, 100, 120, 50);
 function OnGUI() 
  //注意窗口。我们创建了两个使用相同函数的窗体
  //注意他们的ID不同。
 windowRect0 = GUI.Window(0, windowRect0, DoMyWindow, “My Window”);
 windowRect1 = GUI.Window(1, windowRect1, DoMyWindow, “My Window”)
}
//制作窗口内容
function DoMyWindow(windowID : int)
{
 if(GUI.Button(Rect(10, 20, 100, 20), “Hello World”))
 print(“Get a click in window ” + windowID);
 //使窗口可以被拖动
 GUI.DragWindow(Rect(0, 0, 10000, 10000));
}
 停止显示窗口，简单的在DoGUI函数内停止调用GUI.Window。
//布尔变量以决定是否显示窗口
//从游戏GUI，脚本，检视面板中或者其他地方改变这个决定窗口是否可见。
var doWindow() = true;
//制作窗口内容
function OnGUI()
{
 //制作一个开关变量来隐藏或显示窗口
 doWindow() = GUI.Toggle(Rect(10, 10, 100, 20), doWindow(), “Window 0”);
 //确保仅在doWindow()为真时调用GUI.Window
 if(doWindow())
  GUI.Window(0, Rect(110, 10, 200, 60), DoWindow(), “Basic Window”);
}
 为了使窗口从自动GUI获取它的尺寸，使用GUILayout.Window。
 调用顺序
 窗口需要从后向前绘制。在其他窗口顶部的窗口需要在其他窗口之后绘制。这就意味着你不能指望你的DoWindow函数以任何特定的顺序被调用。为了让这个能够工作，当你的创建窗口时下面值被存储（使用Window函数），当DoWindow被调用时取回：GUI.skin, GUI.enabled, GUI.color, GUI.backgroundColor, GUI.contentColor, GUI.matrix
 这就是说很容易像这样制作彩色窗口：
 var windowRect0 = Rect(20, 20, 120, 50);
 var windowRect1 = Rect(20, 100, 120, 50);
 function OnGUI()
 {
  //这里我们制作了2个窗口，在这个之前设置GUI.color的值。
  GUI.color = Color.red;
  windowRect0 = GUI.Window(0, windowRect0, DoMyWindow, “Red Window”);
  GUI.color = Color.green;
  windowRect1 = GUI.Window(1, windowRect1, DoMyWindow, “Green Window”);
 }
//制作窗口内容
//GUI.color的值被设置为窗口被创建之前的值。
function DoMyWindow(windowID : int)
{
 if(GUI.Button(Rect(10, 20, 100, 20), “Hello world!”))
  print(“Got a click in window with color ” + GUI.color);
 //使窗口可以被拖动
 GUI.DragWindow(Rect(0, 0, 10000, 10000));
}
提示：你可以使用GUI.color的alpha组件来淡入淡出窗口。
参见：DragWindow, BringWindowToFront, BringWindowToBack
GeometryUtility
 类
 用于普通集合功能的工具类
类方法
◆ static function CalculateFrusturnPlanes(camera : Camera) : Plane[]
 描述：计算视锥平面
 这个函数取给定的相机视锥并返回它的六个面。
 参见：Plane, GeometryUtility.TestPlanesAABB
◆ static function CalculateFrusturnPlanes(worldToProjection : Matrix4x4) : Plane[]
 描述：计算视锥平面
 这个函数返回由给定的视和投影矩阵定义的视锥的六个面。
 参见：Plane, GeometryUtility.TestPlanesAABB
◆ static function TestPlanesAABB(planes : Plane[], bounds : Bounds) : bool
 描述：如果包围盒在平面数组内部返回真。
 如果包围盒在平面内部或者与任何平面交互返回真。
 参见：GeometryUtility.CalculateFrusturnPlanes。
Gizmos
 类
 Gizmos用于场景中给出一个可视化的调试或辅助设置。
 所有的Gizmos绘制都必须在脚本的OnDrawGizmos或OnDrawGizmosSelected函数中完成。
 OnDrawGizmos在每一帧都被调用。所有在OnDrawGizmos内部渲染的Gizmos都是可见的。
 OnDrawGizmosSelected尽在脚本所附加的物体被选中时调用。
类变量
◆ static var color : Color
 描述：设置下次绘制的Gizmos的颜色。
 function OnDrawGizmosSelected()
 {
  //在物体的前方绘制一个5米长的线
  Gizmos.color = Color.red;
  var direction = transform.TransformDirection(Vector3.forward) * 5;
  Gizmos.DrawRay(transform.position, direction);
 }
◆ static var matrix : Matrix4x4
描述：设置用于渲染所有gizmos的矩阵。
类方法
◆ Static function DrawCube(center:Vector3,size:Vector3):void
描述:用center和size绘制一个立方体.
Function OnDrawGizmosSelected(){
        //在变换位置处绘制一个变透明的蓝色立方体
        Gizmos.color=Color(1,0,0,5);
        Gizmos.DrawCube(transform.position,Vector3(1,1,1));
}
◆ Static function DrawGUITexture(screenRect:Rect,texture:Texture,mat:Material=null):void
描述：在屏幕坐标下绘制一个纹理。用于GUI背景。
◆ Static function DrawGUITexture(screenRect:Rect,texture:Texture,leftBorder:int,rightBorder:int,topBorder:int,bottomBorder:int,mat:Material=null):void
描述:在屏幕坐标下绘制一个纹理。用于GUI背景。
◆ Static function Drawicon(center:Vector3,name:string):void
描述:在世界位置center处绘制一个图标.
这个图标被命名为name并放置在Assets/Gizmos文件夹或Unity.app/Resoutces文件夹.DrawIcon允许你在游戏中快速选择重要的物体。
//在物体位置处绘制光源灯泡图标.
//因为我们在OnDrawGizmos函数内部调用它,在场景视图中
//这个图标总是可点选的.
function OnDrawGizmos(){
     Gizmos DrawIcon(transform.position,”Light Gizmo.tiff”);
}
◆ Static function DrawLine(from:Vector3,to:Vector3):void
描述:绘制一条线从from到to.
Var Larget:Transform;
function OnDrawGizmosSelected(){
        if(target != null)
        {
                 //从transform到target绘制一条蓝色的线
       Gizmos.color = Color.blue;
                  Gizmos.DrawLine(transform.position,target.position);
}
}
◆ static function DrawRay(r:Ray):void
static function DrawRay(from:Vector3,direction:Vector3):void
描述:绘制一个射线从from开始到from + direction.
◆ function OnDrawGizmosSelected(){
    Gizmos.color = Color.red;
    Direction = transform.TransformDirection(Vector3.forward)*5;
    Gizmos.DrawRay(transform.positon,direction); 
}
◆ Static function DrawSphere(center:Vector3,radius:flont):void
描述:用center和randins绘制一个球体.
Function OnDrawGizmosSelected(){
      //在变换位置处绘制一个黄色的球体
      Gizmos.color = Color.yellow;
      Gizmos.DrawSphere(transtorm.position,1);
}
◆ Static function DrawWireCube(center:Vector3, size: Vector3):void
描述:用center和radius绘制一个线框立方体.
Function OnDrawGizmosSelected(){
     //在变换位置处绘制一个黄色立方体
     Gizmos.color = Color.yellow;
     Gizmos.DrawWireCube (transtorm.position, Vector3(1,1,1));
}
◆ Static function DrawWireSphere(center:Vector3,radius:float):void
描述:用center和radius绘制一个线框球体.
Var explosionRadius = 5.0;
Function OnDrawGizmosSelected(){
     //选中的时候显示爆炸路劲
     Gizmos.color = Color.white;
     Gizmos.DrawSphere(transtorm.position,explpsionRadius);
}
Graphics
    类
  Unity绘制函数的原始接口。
  这个是高级快捷地进去Unity优化网格绘制的地方。只限于Unity Pro.
类方法
◆  static function DrawMesh(mesh:Mesh, position: Vector3, rotation: Quaternion, material: Material, layer: int, camera: Camera=null, submeshIndex: int, properties: MaterialPropertyBlock=null): void

◆  static function DrawMesh(mesh:Mesh,matrix:Matrix4x4,material:Material,layer:int,
camera:Camera = null,submeshIndex:int,properties:MaterialPropertyBlock=null):
void
参数
mesh                    用于绘制的Mesh.
position                 网格的位置。
rotation                 网格的旋转。
matrix                   网格的变换矩阵（由位置，旋转和变换x组合）
material                 使用的Material.
layer                      使用的Layer.
Camera                   如果是null(缺省)，该网格将在所有相机中被绘制，否则它将只会在给定的相机中渲染。
submeshIndex                 那个子网格被渲染。这只是在网格使用了多个材质的时候使用。
Properties                        在网格绘制前应用到才子的额外材质属性。参考MaterialPropertyBlock.
描述:绘制一个网格
DrawMesh     在一帧中绘制一个网格。这个网格将受到光照的影响，可以投射接收阴影并被投射器影响。就像它是某个物体的一部分。他可以绘制于所有相机，或者只是特定的一些相机
 在你想创建人景的网格，而又不想过多的创建和管理游戏物体的时候使用DrawMesh.注意，DrawMesh不会立即绘制网格；它仅仅提交它用于渲染。网格将被作为普通渲染过程的一部分。如果想立即绘制一个网格。使用Graphics.DrawMeshNow。
因为DrawMesh不会立即绘制网格，在调用这个函数之间修改材质属性并会使材质使用它们。如果你想绘制一系列相同材质的网格，但是稍微有些不同的属性（例如，改变每个网格的颜色），那么使用MaterialPropertyBlock参数。
参见：MateralPropertyBlock.
◆  Static  function DrawMeshNow(mesh:Mesh,position:Vector3,rotation:Quatemion):void
描述：在给定的position,用给定的rotation绘制一个mesh。
这个函数将设置模型视矩阵并绘制网络。当前设置材质的pass可以被使用（参考Setpass）
◆  Static function DrawMeshNow(mesh:Mesh,position:Vector3,rotation:Quatemion,materallndex:int):void
描述：在给定的position，用给定的rotation和一个materialIndex绘制一个mesh.
◆  Static function  DrawMeshNow(mesh:Mesh,matrx:Matrix4x4):void
描述:用给定的matrix绘制一个mesh.
如果这个矩阵有一个负的缩放这个函数将不会正确渲染物体。
◆  Static function DrawMeshNow(mesh:Mesh,matrx:Matrix4x4,materialIndex:int):void
描述：用给定的matrix和materialIndex绘制一个mesh.
如果这个矩阵有一个负的缩放这个函数将不会正确渲染物体。
◆  Static function DrawTexture(screenRect:Rect,texture:Texture,mat:Material = null):void
描述：在屏幕坐标下绘制一个纹理。
◆  Static function DrawTexture(screenRect:Rect,texture:Texture,leftBorder:int,rughtBord:int,topBorder:int,bottomBorder:int,mat:Material=null):void
描述：在屏幕坐标下绘制一个纹理。
◆  Static function DrawTexture(screenRect:Rect,texture:Texture,sourceRect:Rect,leftBorder:int,rughtBord:int,topBorder:int,bottomBorder:int,mat:Material=null):void
描述：在屏幕坐标下绘制一个纹理
◆  static function DrawTexture(screenReet:Rect,texture:Texture,sourceRect:Rect,leftBordr:int.rightBrder:int.topBorder:int,bottomBorder:int,color:Bolor,mat:Material=null):void
描述：在屏幕坐标下绘制一个纹理。
Hashtable
类
函数
◆  function Add(key:Object, value:Object)：void
描述：添加指定的键和值到哈希表。
◆  function Clear():void
描述：数量被设置为0，并且从该集合中元素到其他对象的引用也将被释放，容量没有改变。///这个方法是O(n)操作，这里n是元素数量。
◆  function Contains(key:object):bool
描述：决定该哈希表中是否包含指定的键。
◆  function ContainsKey (key:object):bool
描述：从哈希表中移除指定键的元素。
◆  function Remove(key:object):void
描述：从哈希表中移除指定键的元素。
HostData
类
这个是用来保存单个主机信息的数据结构。
从master服务器取回的主机列表，使用这个类表示单个主机。
变量
◆  var comment:string
描述：一个多用途的注释（可以保存数据）

◆  var conneetedfPlaycrs:int
描述：当前连接的玩家
◆  var gameName:stting
描述：游戏的名称（像John Doe's Game）
◆  var gameType:string
描述：游戏类型（像MyUniqueGameType）
◆  var ip:string[]
描述：服务器IP地址
◆  var passwordProtected:bool
描述：服务器需要密码吗？
◆  var playerLimit:int
描述：最大玩家限制
◆  var port:int
描述：服务器端口
◆  var nseNat:bool
描述：这个服务器需要NAT穿透吗？
input
类
到输入系统的接口。
使用这个类读取在Input Manager中设置的轴。
使用Input.GetAxis用下面的缺省轴读取轴心："Horizontal"和"Vertical"被映射到摇杆，A，W,S,D和方向键，"Mouse X"和"Mouse Y"被映射到鼠标添量，"Fire1"，"Fine2"，"Fine3"映射到Ctrl，Alt，Cmd键和鼠标的三键或腰杆按钮。新的输入轴可以在Input Manager中添加。
如果你在为任何一种运动行为使用输入，那么使用Inpur.GetAxis。它给你一种平滑的可配置的输入，这个输入可以被映射到键盘，摇杆或鼠标。
使用Input.GetButton用于像事件一样的行为，不要将它用于移动，Input.GetAxis将使脚本代码更小更简单。
类变量
◆  static var anyKey:bool
描述：当前按住了任何键或鼠标按钮吗？（读取）
◆  static var anyKeyDown:bool
描述：用户按下任何键或鼠标按钮返回（Rend Only）。直到用户释放所用键/按钮并再次接下任何键/按钮时才返回真。
◆ static var input: String
描述：返回这一帧中键盘的输入（只读）。
只有ASCII可以包含在inputString中。
该字符串可以包含两个能被处理的特殊字符：字符“\b”代表退格。
*符"\n"表示回车。
//显示如何从键盘读取输入
//（例如，用户输入它的名字）。
//你需要附加这个脚本到一个GUTText物体。function Updarc(){
for (var c;char in Input inputString){
//退格，移除最后一个字符
if(c=="\b") {
iftguiText.Lcngth.text.Substring(0,guiText.text Length-1);
}
//结束
efse if (e=="\n"){
prinr("Uscr cntered his name:"+guiText,text);
}
//正常的文本输入.附加到尾部
elsc
}
guiText.text+=c;
}
}
}
◆  static var mousePosition:Vcctor3
描述:当前鼠标在像素坐标下的位置。
屏幕或窗体的左下为(0,0)，屏幕或窗体的左上为(Screen.width,Screen.height).
var particle:GamcObject,
function Update() {
if (lnput,GctButtonDown{"Firel")){
//从当前鼠标坐标处创建一个射线
var ray=Camera.main.ScreenPointToRay(Input mousePositicn);
if{Physics.Raycast(ray)) {
//如果碰到创建一个粒子
Instontiatc(particlc,transfonn.position,transfonn.rotation);
}
}
}
类方法
◆  static function CetAxis(axinName:string):float
描述：设置由axinName确实虚拟轴的值。
对于键盘和摇杆输入，这个值将在-1...1。
一个非常简单的行驶在x-z平面的汽车。
var spced=10.0;
var cotatinnSpeed=100.0;
function update()
}
//获取水平和垂直轴，
//默认滴它们被映射到方向键
//这个值的范围在-1到1
var transtation=loput.getaxis("vertical")*spccd;
var rotation=inpul getaxis ("horizontal"*rotarionspeed)
//使它以10米/秒速度移动而不是10米/帧
translation*=time delta time
//沿着物体的Z轴移动变换
transtorm.transtate(1010translation);
//绕着Y轴旋转
transform.rotate(0.rotation.0);
}
//指定一个鼠标查看
var horizontalspccd=2.0;
var verticelspeed=2.0
function update()
{
获取鼠标增量，这个没有在范围-1...1之间
var h=horizontalspeed*inpul.getaxis("mouse X");
var v=verticalspeed*input.getaxis("mouse Y");
transform.rotate(v.h.0);
}
◆static function getaxisraw(axisname:string):float
描述：设置由axisname确定虚拟轴的值，并且没有使用平滑过滤，
对于键盘和摇杆输入，这个值将在-1...1的范围内。因为输入没有被平滑，
总是-1，0或1.如果你想自己处理所有键盘输入的平滑，这个是很有用的。
function update(){
var speed=input.getaxisraw("horizoatal"*time deta time);
transform rotate(0.speed.0);
}
◆static function getbutton(button name:string):bool
描述：当时由button name 确定的虚按钮被按住时返回真。
考虑自动开火-这个将在按钮被按住时一直返回真。
//如果每0.5秒实例化一个projcctile,
//如果firel按钮（默认为Ctrl）被按下
var projectile:game object;
var firerate=0.5;
private var nextfire=0.0;
function update()
{
fi(input getbutton("firel")&&time.time>nextfire){
nextfire=time.time+firerate;
clone=instantiate(peojecctile,teansform,position,transffrm,rotation);
}
}
只有使用这个实现事件行为例如，射击，使用input.getaxis 用于任意类型的移动行为
◆static function getbuttondown(button name:steing):bool
描述：当由：button name 确定的虚拟按钮被按下时返回真。
知道用户释放并再次按下时返回真。
//当用户按下firel按钮时实黎化一个projcctile
var projectile:gameobject;
function update(){
if(input getbution down("firel")){
elone=instantiate(projectile,transforrn,position.transforn.rotinon);
}
}
只使用这个实现事件行为例如，射击，使用lnput.GetAxis用于任意类型的移动行为。
◆  static function GetButton Up(buttonName:string):bool
描述：当由buttonName确定的虚拟按钮被释放时返回真.
直到用户按下按钮并再次松开时返回真。
//当用户按下Fire;按钮时实例化一个projectile.
var projectile:GameObject;
function Update O;
if(lnput GetButtonUp("Firel")){
clcne=lnstantiate{projectile,transtorm.position,transform.rotation);
  } 
}
只使用这个实现事件行为例如，射击。使用lnput.GetAXis用于任意类型的移动行为，
◆  static funcrion GetKey(name:string):bool
描述：当用户按住由name确定的键时返回真，考虑自动开火。
键标识列表参考输入管理器。在处理输入时建议使用lnput.GetAxis和lnput.GetButton
因为它允许端用户定义这些键.
funcrion Update(){
if(lnput.GetKey("up")){
   print("up arrow key is held down");
}
if(lnput.GetKey("down"))
}
   print("down arrow key is held down");
  } 
}
◆  static junction GetKey(key:keyGode):bool
描述：当用户按住由key KeyCode枚举参数确定的键时返回真.
funcrion Update(){
if(lnput.GetKey(KeyCode.UpArrow))}
   print("up arrow key is held down");
}
if(lnput.GetKey(KeyCode.DownArrow)){
   print("down arrow key is held down");
   }
}
◆  static function GetkeyDown(name:string):bool
描述：当用户开始按下由name确的键时返回真.
直到用户释放按钮并再次按下时返回真.
键标示列表参考lnput Manager.在处理输入时建议使用lnput.GetAxis和Input.GetBUtton
function Update();
if(input GetkeyDown("space"))
   print("space key was pressed");
  } 
}
static function GetKeyDown(Key:KeyCode):bool
描述：当用户按下由Key KeyCode枚举参数确定的键时返回真.
function Update();
 if{lnput GetKeyDown(KeyCode.Space))
print("space key was pressed");
}
}
◆  static function GetKeyUp(name:sting):bool
描述：当用户释放由name确定的键时返向真.
直到用户按下按钮并再次松开时返向真。
键标示列表参考lntpot Manager.在处理输入时建议使用lnput.GetAxis和lnput.GetButton
因为它允许端用户定义这些键.
function Update();{
if(lnput.GetKeyUp("space");
  } 
}
◆  static function GetKeyUP(Key:KeyCode):bool
描述：当用户释放由Key KeyCde 校举参数确定的键时返回真.
function Update(){
if(lnput,GetKeyUp(KeyCode.Space));
  print("space key was feleased");
  }
}
◆  statie function GetMouseButton(button:int):bool
描述：返回给定的鼠标按钮是否被按住。
/button/值为0表示左键，1表示右键，2表示中键.
◆  statie function GetMouseButtonDown(button:int)bool
描述：用户按下给定的鼠标按钮时返回真.
直到用户释放按钮并再次按下它时才返回真.button值为0表示中键左键，1表示右键，2表示中键.
◆  statie function GetMouseButtonUp(button:int)bool
描述：用户释放给定的鼠标按钮时返回真.
直到用户释放按钮并再次释放它时才返回真.button值为0表示中键左键，1表示右键，2表示中键.
◆  statie function ResetlnputAxes();Void
描述：重置所有输入。在ReaetlnputAxes之后所有轴将返回0并且所有按钮返回0.
这可用于当重生玩家，并且当你不想任何来自键盘的输入还处于按下时。
lnpu.ReaetlnputAxes();
jointDrive
结构
关节如何沿着本地X轴移动 
变量
◆  var maximumForce:float
描述：用于向指定的方向推动物体的力的量。仅在Mode包含Velocity时使用。
◆  var mode:jointDriveMode
描述：驱动是否尝试到这个位置和/或速度.
◆  var positionDamper:float
描述：位置弹簧的阻力强度，只用于mode包含位置的时候.
◆  var positionSpring:float
描述：朝着定义的方向推动的一个阻力强度。只用于mode包含位置的时候.
Jointlimits
结构
jointlimits被Hingejoint使用来限制关节角度.
参见:Hingejoint
变量
◆  var max:float
描述：关节的上限。当关节角度或位置的上限。
关节将使用力来约束它。
//设置最小链接角度为20度
hingejoint.limits.max=40;
◆  var maxBounce:float
描述：当关节碰到关节的上限时关节的弹力。
//设置关节反弹时的上限
hingejoint.limits.maxBounce=1;
◆  var min:float
描述：关节的下限。当关节角度或位置的下限。
关节将使用力来约束它。
//设置最小链接角度为20度
hingejoint.limits.min=20;
◆  var minBounce:float
描述：当关节碰到关节的下限时关节的弹力。
 //关节反弹时的下限
hingejoint.limits.minBounce=1;
jointMotor
结构
jointMotor用来旋转一个关节
例如：Hingejoint可以被告知以制定的速度和力旋转。关节然后用给定的最大力试图到达这个速度，参见：
变量
◆  var force：float
描述：动力将应用最大为force的力以便取得targetvelocity
◆  var freeSpin：bool
描述：如果freeSpin被启用动力将只加速而不会减速
◆  var targetvelocity：float
描述：动力将应用最大为force的力以便取得targetvelocity
Jointspring
结构
变量
◆  var damper：float
描述：用语阻尼弹簧的阻尼力。
◆  var spring：float
描述：用于达到目标位置的弹力
◆  var targetposition：float
描述：关节试图到达的目的位置
这里一个hingehoint目标位置是目标角度
Keyframe
结构
一个关键帧它可以插入动画的曲线
变量
◆  var in tangent:float
描述：在曲线上从下一个点到这个点时描述切线。
参加：outtangent
◆  var outtangent:float
描述：在曲线上从这个点到下一个点时描述切线。
参见：intangent
◆  var time：float
描述：关键帧时间
在一个2D图形中，你可以把这当做x值
参见：value
◆  var value：float
描述：该动画曲线在关键帧处的值
参见：time
构造函数
◆  static function keyframe（time：float，value：float）：keyfranie
描述：创建一个关键帧
◆  static function keyframe（time：float，value：float,intangent:float,outangent:float):keyframe
描述：创建一个关键帧
layermask
结构
layermask允许你在检视面板中显示layermask弹出菜单
类似与camera，cullingmask。layermasks 可以选择性地过滤物体，例如当投射射线，
//使用层蒙板投射一个射线
//它可以在检视面板中修改
var mask larermask=
function Update(){
if(Physics.Raycast(transform.position, transform.forward, 100, mask.value))
{
Debug.Log(“Hit something”;
}
}
变量
◆  var valuc：vin
描述：转化层蒙板的值为一个整形值
//使用层蒙板投射一个射线
//它可以在检视面板中修改
var mask：lnyermask=-1
fonction update（）{
if{physics.rayeast（transforn.position.transform.forwatd.100.mask.value))
{
Debug 
}
}
类方法
◆  static function LayerToName（layer ：in）：string
描述：给定一个层的数字。返回内置的或在tag Maneger中定义的层名称。
◆  static function NameToLayer（layerName ：string）：int
描述：给定一个层的名字。返回内置的或在tag Maneger中定义的层索引。
◆  static implicit function LayerMask(intva1:int):layermask
描述：隐式转化一个整数位已个层蒙板
Lightmapdata
类
光照贴图数据
一个场景可以有多个光照贴图储存在这里，renderer组建可以使用这些光照贴图，这就使得它能够在多个物体上使用相同的材质，而每个物体可以使用不同的光照贴图或同一个光照贴图的不同部分。
参见，linghrmapsettings类 renderer lightmapindex 属性
变量
◆  var lightmap:texture2D
描述：光照贴图的纹理
参见：lightmspsettings 类 renderer lighunaplndex属性
linghtmapsettings
类
储存这个场景的光照图
一个场景可以有多个光照贴图储存在这里，renderer组件可以使用这些光照贴图，这就使得它能够在多个物体上使用相同的材质，而每个物体可以使用不同的光照贴图或同一个光照贴图的不同部分。
参见：lightmapdata类renderer.lightmaplndex属性
类变量
◆  sartic var lightmaps:lightmapdata[]
描述：光照贴图数组
参见：lightmapdata类renderer.lightmaplndex属性。
Masterserver
类，主服务器用来使服务器和客服端匹配。
你可以建立以个游戏主机或为你的游戏类型取回主机列表。这里的这个函数用来与主服务器通信，主服务器位于不同的服务器上，如果必要这个服务器可以被定制，主服务器的概览和技术描述：参见master server manual page
类变量
◆  static var dedicatedserver:bool
描述:申明这台机器为专用服务器。
如果作为一个服务器运行，连接数定义了玩家的数量，当在主服务器上注册的时候这个被报告，默认情况下主服务器假定这个实例不是专用服务器，因此玩家数会增加1（占用服务器上的一个\“chent”\）如果不希望，这个变量可以设置为假，然后知有连接数被报告为玩家数。
function startserver{}{
nerwork lnitializeserver(32.25002):
masrerserver.dedicatedserver=true;
masterserver.registerhost("myuniquegametype","johndoes game","133tgame for all");
}
◆static var ip address:string
描述：主服务器的IP地址。
默认地这个是由unity技术运行的服务器。
function 
masterserver ip address="127.0.0.1";
master server.port=10002;
}
◆static var port:int
描述：主服务器的链接端口。
默认地这个是由unity技术云顶的服务器，
masterserver.ipaddress="127.0.0.1";
master server.port=100021;
}
◆static var updaterate:int
描述：为主服务器主机信息更新设置最小更新速率。
通常，主机更新只在主机信息被改变的时候发生（如连接的玩家）。更新率定义了主机更新之间的最小时间量，缺省值为60秒（检查更新）因此，如果以个主机更新呗发送然后一些域在10秒后改变，然后更新可能会在50秒之后发送（在下一次检查到改变的时候）。如果这个被设置为0，以后就没有更新被发送，只发送初始注册信息。
function startserver()
{
network lnitialigeserver(32.25002);
//在初始化注册之后没有主机信息更新
Masterserver.updaterate=0;
masterserver,registerhost("myuniquegametype","johndoes game","133tgame forall");
}
类方法
◆static function clearhostlist():void
描述：清楚由masterserver.pollhostlist接收到的主机列表。
如果你想更新列表并想确保你不使用较旧的数据时，使用这个，
function awakc()
{
//确保类表是空的并请求一个新的列表
masterserver clearhostlist();
masterserver.requesthostlist("myuniquegametype");
}
function lpdate()
{
//如果任何主机被接收，显示游戏名称，再次清理主机列表，}
if(masterserver.pollhostlist(),length!=0){
var hostdata;hostdata[]=masterserver.pollhostlist();
for(var i:int=0;i<hostdata.length;i++){
    debug,log("game name:"+hostdata[i]gamename);
}
masterserver,clearhostlist()
}
}
◆static function pollhostlist():hostdata[]
描述：使用master server.requeshostlist接收最新的主机列表
使用masterserver.clearhostlist清理当前主机列表。这样你可以确定返回的列表时最新的。
  function awaket(){
//确保列表时空的并请求一个新的列表
masterserver .clearhostlist();
masterserver.requesrhostlist("larustest"):
;
function update()
;
//如果任何主机被接收，显示游戏名称，再次清理主机列表；
if(masterserver.pollhostlist()length!=0){
varhostdata hostdata[]=masterserver.pollhostlist();
for(var i:int=0;i<hostdata.length;i++){
debug.log("game name"+hostdata[i].gamename);
}
masterserver.clearhostlist()
}
◆static function registerhost(gametypename:string,gamename:string.comment:string=""):void
描述：在主服务器注册这个服务器。
如果主服务器地址信息尚未改变，缺省的主服务器将被使用。
function ongui()
{
if(guilayout.button("stnrt server")){
//如果没有公有IP地址，使用NAT穿透
network。usenat=！network.havepublicaddrss();
network.lnitializeserver(32.25002);
masterserver.registerhost("myuniquegametype","johndoes game","133tgame for all");
}
}
◆static function RequestHosList(gameTypeName:string):void
描述：从主服务器请求一个主机列表。
当它完成的时候，这个列表可以通过MasterServer.PollHcstList使用。
function Awakc(){
//确保列表时空的并请求一个新的列表
MastcrScrver.RequestHostList();
MastcrScrver.RequestHostList("LarusTcst");
}
function Update()
}
//如果任何主机被接收，显示游戏名称，再次清理主机列表。
if(MastcrScrvcr.PollHcstLisx().length!=0)}
var hostData:HostData[]=MasterSer.pollHostList();
for (var i:int=();i<hostData.length;i++){
Debug.Log("Game namc;"+hostData[i].gamceName);
}
MastcrScrvcr.ClearHostList();
}
}
static function UnregisterHost():void
描述：从主服务器注销这个服务器。
如果服务器没有被注销或已经被注销，不做任何事。
function OnGUt() {
if(GUILayout.Button("Disconnect")){
Nctwork,Disconnect();
NastcrServer.UnregisterHost();
}
}
MaterialPropertyBlock
类
应用的一块材质值。
MateriaIPropcrtyBlock被Graphics.DrawMesh使用。当你想用相同的材质（但有稍微有些不同的属性）绘制多个物体时，使用这个。例如，如果你想稍微改变每个网络的颜色时。
出于性能原因，属性块只能包含有限数量的属性值。两个4x4矩阵，六个向量颜色或12个浮点数可以存储在这个块中，存储空间时共享，所以存储一个矩阵留下两倍少的空间来
 
存储向量和浮点数。
Graphics。DrawMesh 拷贝传递的属性块，因此最有效的方法是使用它来创建一个快并为所有DrawMesh 调用使用它。使用Clear来清除块的值，AddFloat，AddVector，AddColot，AddMatrix来添加值。
参见：Graphics，DrawMesh，Matcrial。
函数
◆  function AddColor(name：string，value:Colo):void

◆  function AddColor(nameID:int，value:Colo):void

描述：添加一个颜色材质属性。
出于性能原因，属性块只能包含有限量的属性值。两个4x4矩阵，六个向量/颜色或12个浮点数可以存储在这个块中。存储空间时共享，使用存储一个矩阵留下两个倍少的空间来存储向量和浮点数。当块的存储空间填满后，额外的Add调用将被忽略。
使用nameID的函数变量体更快，如果你重复添加相同名称的属性，使用Shader.propertyToID来获取不同的标示，并传递这个标示到AddColor。
◆  function AddFloat(name：string，value:float):void
◆  function AddFloat(nameID:int，value:float):void
描述：添加一个浮点材质属性。
出于性能原因，属性块只能包含有限数量的属性值。两个4x4矩形，六个向量/颜色或存12个浮点数可以存储在这个块中，存储空间是共享，所以存储一个矩阵留下两倍少的空间来存储向量和浮点数。当块的存储空间填满后，额外的Add调用将被忽略。
使用nameID的函数变体更快，如果你重复添加相同名称的属性，使用Shader.PropertyToID来获取不同的标示，并传递这个标示到AddFloat。
◆  function AddMatrix(name：string，value:Matrix4x4):void
◆  function AddMatrix(nameID:int，value:Matrix4x4):void

描述：添加一个矩阵材质属性。
处于性能原因，属性块只能包含有限数量的属性值。两个4x4矩阵，六个向量/颜色或12个浮点数可以存储在这个块中。存储空间时共享，所以存储一个矩阵留下两倍少的空间来存储向量和浮点数。当块的存储空间填满后，额外的Add调用将被忽略。
使用nameID的函数变体更快，如果你重复添加相同名称的属性，使用Shader.PropertyToID来获取不同的标示，并传递这个标示到AddMatrix。
◆  function AddVector(name：string，value:Vector4):void
◆  function AddVector(nameID:int，value:Vector4):void
描述：添加一个向量材质属性。
出于性能原因，属性块只能包含有限数量的属性值。两个4x4矩阵，六个向量/颜色或12个浮点数可以存储在这个块中。存储空间是共享，所以存储一个矩阵留下两倍少的空间来存储向量和浮点数。当块的存储空间填满后，额外的Add调用将被忽略。
使用nameID的函数变体更快，如果你重复添加相同名称的属性，使用
Shader.ProrertyToLD来获取不同的标示，并传递这个标示到AddVector。
◆  function Clear():void
描述，清除材质属性值。
GrawMesh 拷贝传递的属性块，因此最有效的方式是使用它来创建一个块并为
所有DrawMesh调用使用它。使用Clear来清除块的值,ADDFloat,AddVector,AddColor,AddMatrix来添加值.
Mathf
结构
常用数学函数的集合。
类变量
 ◆  static var Deg2Rad:float
 描述：度到弧度的转化常量（只读）。
 这个等于（PI*2)/360.
//转化30度为弧度
var deg=30.0;
var od=dcg*Mathf.Deg2Rad;
参见：Rad2Deg常量。
◆  static varEpsilon:float
描述：一个小的浮点数值（只读）
比较小于它的值没有多人意见，因为浮点数是不精确的。
print(MathfEpsilon);
◆  static var Infinity:float
描述：表示正无穷（只读）.
◆  static var NegativeIntinity:float
描述：表示负无穷（只读）.
◆  staic var PI:float
描述：3.14159265358979...值（只读）.
◆  static var Rad2deg:float
描述：弧度到度的转化常量（只读）.
这个等于360、（PI*2）.
 转化1弧度为度
var rad=1.0;
var deg=rad*Mathf.Rad2Deg.
参见：Deg2Rad常量
类方法
◆  staric function Abs(f:float):float
描述：返回f的绝对值。
//打印10.5
print(Mathf.Abs(-10.5)).
◆  staric function Abs(value:int):int
描述：返回value的绝对值。
//打印10
print(Mathf.Abs(-10));
◆  staric function Acos(f:float):float
描述:返回f的反余弦_一个弧度角它的余弦是f.
print(Mathf.AcOS(0.5);
◆  staric function Approximately(a:float,b:float):bool
描述：比较两个浮点数值看看它们是否近似。
由于浮点数值不精确，不建议使用等操作来比较它们。例如，1.0==10.0/10.0也许不会返回真。
if(Mathf.Approximately(1.0,10.0/10.0))
print("same");
◆  static function Asin(f:float):float
描述：返回f的反正弦_一个弧度角它的正弦是f.
print(Matht.Asin(0.5));
◆  staric function Atan(f:float):float
描述：返回f的反切_一个弧度角它的正切是f.
print(Mathf.Atan(0.5));
◆  staic function Atan2(y:float,x:float):float
描述：返回一个弧度角它的Tan为y/x。
返回的值是一个角度，该角表示x轴和开始于零并终结在（x,y）处的向量之间的角度。
//通常使用transform.lookAt.
//但这可以给你更多的对角度的控制
vartatget:Transform;
function Update()
{
var relativ=transfom.lnverseTeansformPoint(target.position);
var angle=Mathf.Atan2(reative,reative.z)*Mathf.Rad2Deg;
transform.Rotate(0,angle,0);
}
◆  static function Ceil(f:fioat):float
描述：返回大于等于f的最小整数.
◆  static function CeilTolnt(f:fioat):int
描述：返回大于等于f的最小整数.
◆  static function Clamp(value:float,min:float,max:float):float
描述：在一个最小的浮点数和最大的浮点数之间截剪。
//随着时间设置变换位置
//但是不会小于1或大于3
function Update()
{
transtorm,position.x=Mathf.Clamp(lime.time.1.0,3.0);
}
◆  staric function Clamp(value:int,min:int,max:int):int
描述：在min和max之间裁剪值并返回裁剪后的值。
//在1到3之间裁剪10，
//打印3到控制台
prnt(Mathf.Clamp(10,1,3))
◆  static function Clamp01(value;float):float
描述：在0和1之间裁剪值并返回裁剪后的值。
//随着时间设置变换位置
//但是不会小于0或大于1
function Update(){
transform.position.x=Mathf.Clamp01(Time.time);
}
◆  staic function ClosestPowerOflwo(value:int):int
描述：返回最直接的2的幂次值。
例如。7返回8或者19返回16
◆  staric function Cos(f:float):float
描述：返回弧度f的余弦值.
print(Mathf.Cos(3));
◆  staic function EXP(power:float):float
描述：返回e的特定次幂。
print(Mathf.Cos(6));
◆  static function Floor(f:float):float
描述:返回小于f的最大整数.
◆  static function FloorTolnt(f:float):int
描述：返回小于f的最大整数.
◆  static function lnverseLerp(from:float,to:float,value:float):float
描述：在两个值之间计算Lerp参数.
varwalkSpeed=5.0;
varunSpeed=10.0;
var speed=8.0;
//参数现在是3/5
vvar parameter=Mathf.laverseLerp(walkSpeed,runSpeed,speed);
◆  staic tunchon Lerp(a:float,b:float,t:float):float
描述：基本t在a到b之间插值。t本裁剪到0到1之间。
当t为0时返回from . 当t为1时返回to .当t=0.5时返回a和b的平均。
var minimum = 10.0;
var maximum = 20.0;
// 在一秒内从minimum渐变到maximum
Function Update()
{
transform.position.x = Mathf.lerp(minimum,maximum,Time.time);
}
◆ static function LerpAngle(a:float,b:float,t:float):float
描述：与Lerp相同，但是当它们可绕360度时确保插值正确，
变量a和b被认为是度。
//以2为底6的对数
//打印2.584963
print(Mathf.Log(6,2));
◆ static function Log(f:float):float
描述：返回一个数以自然（以e为底）对数。
//10的自然对数
//打印4.60517
print(Mathf.Log(10));
◆ static function Log10(f:float):float
描述：返回一个数以10为底的对数。
//以10为底100的对数
//打印2
print(Mathf.Log10(100));
◆ static function Max(a:float,b:float):float
描述：返回两个值中较大的一个。
//打印2
print(Mathf.Max(1,2));
◆ static function Max(a:int,b:int):int
描述：返回两个值中较大的一个。
//打印2
print(Mathf.Max(1,2));
◆ static function Min(a:float,b:float):float
描述：返回两个值中较小的一个。
//打印1
print(Mathf.Min(1,2));
◆ static function Min(a:int,b:int):int
描述：返回两个值中较小的一个。
//打印1
print(Mathf.Min(1,2));
◆ static function PingPong(t:float,length:float):float 
描述：来回改变t值，t值不会超过length，也不会小于0，只会在length和0之间循环。
function Update()
{
//让x位置在0到3之间循环
transform.position.x = Mahtf.PingPong(Time.time,3);
}
◆ static function Pow(f:float,p:float):float
描述：返回f的p次方。
print(Mahtf.Pow(6,1.8));
◆ static function Repeat(t:float,length:float):float
描述：使t值循环，不大于length不小于0。它与操作模板类似，但可以使用浮点数。
function Update()
{
//让x位置在0到3之间循环
transform.position.x = Mahtf.Repeat(Time.time,3);
}
◆ static function Sign(f:float):float
描述：返回f的符号。
当f为正或为0则返回1，为负返回-1。
◆ static function Sin(f:float):float
描述：返回以f为弧度的sin值。
print(Mahtf.Sin(3));
◆ static function SmoothDamp(current:float,target:float,ref currentVelocity:float,smoothTime:float,maxSpeed:float = Mahtf.Infinity,deltaTime:float =Time.deltaTime):float
描述：逐步的向期望值变化。
这个值就像被一个不会崩溃的弹簧防震器所影响。这个函数可以用来平滑任何类型的值，位置，颜色，标量。最常用于让一个跟随摄像机的速度变的平滑。
current就是当前位置。target是我们希望达到的位置。currentVelocity是当前速度，这个值在你访问这个函数的时候会被随时修改。smoothTime是要到达目标位置的近似时间，实际到达目标时要快一些。maxSpeed可以让你随意的设定最大速度。deltaTime是上次访问该函
数到现在的时间。缺省为Time.deltaTime。
//平滑到目标高度
var target : Transform;
var smoothTime = 0.3;
private var yVelocity = 0.0;
function Update ()
{
var newPosition = Mathf.SmoothDamp(transform.position.y, target.position.y,yVelocity, smoothTime);
transform.position.y = newPosition;
}
◆ Static function SmoothDampAngle(current: float, target: float, ref currentVelocity): float, smoothTime: float, maxSpeed: float=Mathf.Infinity, deltaTime: float=Time.deltaTime): float
描述： 基于Game Programming Gems4章节1.10
随着时间逐渐的改变一个角度为目的的角度。这个值被像弹簧阻尼一样的函数平滑。这个函数可以用来平滑任何一种值，位置，颜色，标量。最常见的是平滑一个跟随摄像机。
current是当前位置。target是我们试图到达的位置。currentVelocity是当前速度，这个值在每次你调用这个函数的时候都被修改。smoothTime是到达目的地近似时间，实际的时间将更短。maxSpeed为允许的最大速度。deltaTime为从上次调用该函数到现在的时间。缺省为Time.deltaTime。
//一个简单的平滑跟随摄像机。
//跟随目标的朝向
var target : Transform;
var smooth = 0.3;
var distance = 5.0;
private var yVelocity = 0.0;
function Update () 
{
//从目前的y角度变换到目标y角度
var yAngle = Mathf.SmoothDampAngle(transform.eulerAngles.y,target.eulerAngles.y, yVelocity, smooth);
//target的位置
var position = target.position;
//然后，新角度之后的距离便宜
position += Quaternion.Euler(0, angle, 0) * Vector3 (0, 0, -distance);
//应用位置
transform.position = position;
//看向目标
transform.LookAt(target);
}
◆ static function SmoothStep (from : float, to : float, t : float) : float
描述：在min与max中插值并在限定处渐入渐出
◆ static function Sqrt (f : float) : float 
描述：返回f的平方根  
print(Mathf.Sqrt(10));
◆ static function Tan (f : float) : float 
描述：返回弧度f的正切值 
print(Mathf.Tan(0.5));
Matrix4x4
一个标准的4x4变换矩阵。
一个变换矩阵可以执行任意的线形3D变换（例如，评议，旋转，缩放，切边等等）并且偷师变化使用齐次坐标。脚本中很少使用矩阵：最常用Vector3，Quaternion，而且Transform类的功能更简单。单纯的矩阵用于特殊情况，如设置非标准相机投影。
 参考任何图形学教程获取关于变换矩阵的深入揭示。
 在Unity中，Matrix4x4被Transform，Camera，Material和GL函数使用。
变量
◆ var inverse : Matrix4x4
描述：返回该矩阵的逆（只读）
如果用原始矩阵诚意逆矩阵结果为identity矩阵。
如果一些矩阵以一个特定的方式变换响亮，逆矩阵可以将他们变换回去。例如worldToLoclaMatrix和localToWorldMatrix是互逆的。
◆ var this[row : int,column : int]:float
描述：访问[row,column]处的元素。
row和column必须在0到3之间，矩阵是一个4x4的数组，你可以通过使用这个函数访问单个的元素。
注意标准数学符号-row是第一个索引。
◆ var this[index : int]:float
描述：按顺序索引存取元素（包括在0..15）
矩阵是一个4x4的数组，所以它的总数为16,。你可以使用一维索引来存取单个元素。index是row+column*4
◆ var transpose : Matrix4x4
描述：返回这个矩阵的转置（只读）。
转置矩阵是将原矩阵行列交换得到的（沿主对角线翻转）
函数
◆ function GetColumn(i : int):Vector4
描述：获取矩阵的一列。
第i列作为Vector4返回，i必须在0到3之间。
参见：SetColumn
◆ function GetRow(i : int):Vector4
描述：返回矩阵的一行。
第i行作为Vector4返回，i必须在0到3之间。
参见：SetRow
◆ function MultiplyPoint (v : Vector3):Vector3
描述：通过这个矩阵变换位置。
返回由任意矩阵变化得到的位置v。如果这个矩阵是一个正规的3D变换矩阵，使用MultiplyPoint3x4比它更快。MultiplyPoint是较慢的，但是能处理投影变换。
参见：MultiplyPoint，MultiplyVector。
◆ function MultiplyPoint3x4(v : Vector3):Vector3
描述：通过这个矩阵变换位置（快）。
返回由当前变换矩阵变换得到的位置v。这个函数是MultiplyPoint的快速版，但是它只能处理常规的3D变化。Multiplypoint是较慢的，但是能处理投影变换。
参见：MultiplyPoint，MultiplyVector。
◆ function MultiplyVector(v : Vector3):Vector3
描述：通过这个矩阵变换方向。
这个函数类似于MultiplyPoint，但它是变换方向而不是位置。变换方向时，只考虑矩阵的旋转部分。
参见：MultiplyPoint，MultiplyPoint3x4。
◆ function SectColumn(i : int,v:vector4):void
描述：设置矩阵的一列。
使用这个来构建一个变换矩阵，这个矩阵使用right，up和forward向量。
//从变换构建一个矩阵
var matrix = Matrix4x4();
//从变换构建一个矩阵
function Start () 
{
matrix.SetColumn (0, transform.right);
matrix.SetColumn (1, transform.up);
matrix.SetColumn (2, transform.forward);
var p = transform.position;
matrix.SetColumn (3, Vector4 (p.x, p.y, p.z, 1));
}
//设置第i列为v。i必须在0到3之间。
参见：GetColumn
◆ function SetRow(i : int,v:Vector4):void
描述：设置矩阵的一行。
设置第i行为v。i必须在0到3之间。
参见：GetRow
◆ function SetTRS(pos : Vector3, q:Quaternon, s:Vector3):void
描述：设置这个矩阵为一个变换，旋转和缩放矩阵。
当前的矩阵本修改一遍具有位置pos，旋转q和缩放s。
◆ function ToString():string
描述：返回已格式化的该矩阵的字符串。
类变量
◆ static var identity : Matrix4x4
描述：返回单位矩阵（只读）。
这个矩阵在使用的时候不会影响任何东西。它的主对角线上全是1，其他位置全是0。
1 0 0 0
0 1 0 0
0 0 1 0
0 0 0 1
参见：zero变量。

◆&n, bsp;static var zero : Matrix4x4
描述：返回所有元素都为零的矩阵（只读）。
0 0 0 0
0 0 0 0
0 0 0 0
0 0 0 0
参见：identity变量。
类方法
◆ static operator * (lhs : Matrix4x4,rhs : Matrix4x4) : Matrix4x4
描述：两个矩阵相乘。
返回lhs * rhs。
◆ static operator * (lhs : Matrix4x4,v:Vector4):Vector4
描述：由矩阵来变换一个Vector4。
◆ static function Ortho(left : float,right : float,bottom : float,top : float,zNear : float,zFar : float):Matirx4x4
描述：创建一个正交投影矩阵。
返回的矩阵是视口ledt到right，bottom到top的区域，zNear和zFar深度裁剪面板。
如果你想使用正交来做像素修正渲染，最好使用GL.LoadPixelMatrix，因为它会为Direct3D渲染器运用适当的half-texel便宜。
参见：GL.LoadPixelMatrix，GL.LoadProjectionMatrix，GUI.matrix
◆ static function Perspective(fov : float,aspect : float,zNear : float,zFar : float):Matrix4x4
描述：创建一个透视投影矩阵。
fov为透视矩阵的垂直视野，aspect为宽高比，zNear和zFar设置为深度裁剪面板。
参见：GL.LoadPixelMatrix，GL.LoadProjectionMatrix，GUI.matrix
◆ static function Scale(v:Vector3):Matrix4x4
 描述：穿件一个缩放矩阵。
 返回沿着坐标轴被响亮v缩放的矩阵，该矩阵看起来像这样：
v x 0 0 0
0 v y 0 0
0 0 v z 0
0 0 0 1
◆ static function TRS(pos:Vector3,q:Quaternion,s:Vector3):Matrix4x4
 描述：创建一个变换，旋转和缩放矩阵。
返回的矩阵具有位置pos，旋转q和缩放s。
NetworkMessageInfo
这个数据结构包含一个刚收到的来自网络的消息。
它揭示了它从哪来，发送的时间和由什么网络视图发送的。
变量
◆ var networkView : NetworkView
描述：发送这个消息的NetworkView
◆ var sender : NetworkPlayer
 描述：发送这个网络信息（拥有者）的玩家。
◆ var TimeStamp : double
描述：当消息被发送时的时间戳，以秒计。
时间邮戳可以用于实现插值或者连续刘宝的预测，时间戳被作为双精度数传递，以避免游戏运行长一段时间后溢出。内置的时间戳被设置为32位整数，以毫秒为精度以便节省带宽。时间戳现对于Network.time自动调整。因此Network.time-messageInfo.timeStamp是抱在传输时花费的时间。
var something : float;
var transitTime: double;
function OnSerializeNetworkView (stream : BitStream, info : NetworkMessageInfo) {
var horizontalInput : float = 0.0;
if (stream.isWriting) {
// 发送
horizontalInput = transform.position.x;stream.Serialize (horizontalInput);
} else {
// 接收
transitTime = Network.time - info.timestamp;
stream.Serialize (horizontalInput);
something = horizontalInput;
}
}
function OnGUI() {
GUILayout.Label("Last transmission time: "+ transitTime);
}
NetworkPlayer
 NetworkPlayer是一个数据结构，通过它你可以通过网络定位其他玩家。
例如，你可以直接发送一个消息给其他玩家。
变量
◆ var externalIP : string
描述：返回网络接口的外部IP地址。这个只能在建立了外接连接以后才能输入。
◆ var externalPort : int
描述：返回网络接口的外部接口。这个只能在建立了外接连接以后才能输入。
◆ var ipAddress : string
描述：该玩家的IP地址。
◆ var port : int
描述：该玩家的端口号。
构造函数
◆ static function NetworkPlayer(ip : string , port : int) : NetworkPlayer
描述：
函数
◆ function ToString() : string
描述：返回该网络玩家的指数。
类方法
◆ static operator != (lhs : NetworkPlayer,rhs : NetworkPlayer):bool
描述：如果两个NetworkPlayers不是同一个玩家返回真
◆ static operator == (lhs : NetworkPlayer,rhs : NetworkPlayer):bool
描述：如果两个NetworkPlayers是同一个玩家返回真
NetworkPlayer
 NetworkPlayer是一个数据结构，通过它你可以通过网络定位其他玩家。
例如，你可以直接发送一个消息给其他玩家。
变量
◆ var externalIP : string
描述：返回网络接口的外部IP地址。这个只能在建立了外接连接以后才能输入。
◆ var externalPort : int
描述：返回网络接口的外部接口。这个只能在建立了外接连接以后才能输入。
◆ var ipAddress : string
描述：该玩家的IP地址。
◆ var port : int
描述：该玩家的端口号。
构造函数
◆ static function NetworkPlayer(ip : string , port : int) : NetworkPlayer
描述：
函数
◆ function ToString() : string
描述：返回该网络玩家的指数。
类方法
◆ static operator != (lhs : NetworkPlayer,rhs : NetworkPlayer):bool
描述：如果两个NetworkPlayers不是同一个玩家返回真
◆ static operator == (lhs : NetworkPlayer,rhs : NetworkPlayer):bool
描述：如果两个NetworkPlayers是同一个玩家返回真
NetworkViewID
 在一个多玩家游戏中，NetworkViewID是用于网络视实例的唯一标识符。
这个是重要的，因为这个在所有客户端是唯一的数字，并且客户端自己可以产生这些数字，否则网络同步将被断开。
变量
◆ var isMine : bool
描述：如果是被我实例化的，返回真。
◆ var owner : NetworkPlayer
描述：拥有NetworkView的NetworkPlayer。可以是服务器。
函数
◆ function ToString() : string
描述：返回NetworkViewID中的格式化字符串细节。
类方法
◆ static operator != (lhs : NetworkViewID,rhs : NetworkViewID):bool
描述：如果两个NetworkViewIDs不是同一个玩家返回真
◆ static operator == (lhs : NetworkViewID,rhs : NetworkViewID):bool
描述：如果两个NetworkViewIDs是同一个玩家返回真
Network
类
网络类是网络实现的核心并提供核心函数。
这个类定义了网络接口和所有网络参数。你可以使用它来设置一个服务器或链接到一个服务器并有一些列辅助函数来帮助你完成这些功能。获取更多关于编辑器中的信息请参考Network Maner component reference。
消息传递
◆ function OnConnectedToServer() : void
描述：当成功链接到服务器上时，在客户端调用这个函数。
function OnConnectedToServer() {
Debug.Log("Connected to server");
}//发送本地玩家名称到服务器
◆ function OnDisconnectedFromServer(mode : NetworkDisconnection):void
描述：客户端从服务器上断开时在客户端上调用，但当连接被断开时在服务器上调用。
当链接丢失或被服务器断开时，在客户端调用这个函数。NetworkDisconnection枚举将标示连接是否断开或是否连接丢失。连接成功断开时再服务器上调用这个函数（在Network.Disconnect之后）。
function OnDisconnectedFromServer(info : NetworkDisconnection) {
if (Network.isServer) {
Debug.Log("Local server connection disconnected");
}
else {
if (info == NetworkDisconnection.LostConnection)
Debug.Log("Lost connection to the server");
else
Debug.Log("Successfully diconnected from the server");
}
}
◆ function OnFailedToConnect(error : NetworkConnectionError):void
描述：当连接因为某些原因失败时，在客户端上调用该函数。
失败的原因作为NetworkConnectionError枚举传入。
function OnFailedToConnect(error: NetworkConnectionError){
Debug.Log("Could not connect to server: "+ error);
}
◆ function OnFailedToConnectToMasterServer(error : NetworkConnectionError):void
描述：当连接到主服务器出现问题时，在客户端或服务器端调用该函数。
错误原因作为NetworkConnectionError枚举传入。
function OnFailedToConnectToMasterServer(info: NetworkConnectionError){
Debug.Log("Could not connect to master server: "+ info);
}
◆ function OnNetworkInstantiate(info : NetworkMessageInfo):void
描述：当一个物体使用NetworkInstantiate进行网络初始化时在该物体上调用这个函数。这个对于禁用或启用一个已经初始化的物体组件来说是非常有用的，它们的行为取决于他们是本地还是远端。注意：在NetworkMessageInfo里的networkView属性不能在OnNetworkInstantiate里使用。
function OnNetworkInstantiate (info : NetworkMessageInfo) {
Debug.Log("New object instantiated by " + info.sender);
}
 描述：当一个新的玩家成功连接时再服务器上调用这个函数。
private var playerCount: int = 0;
function OnPlayerConnected(player: NetworkPlayer) {
Debug.Log("Player " + playerCount++ + " connected from " + player.ipAddress + ":" + player.port);
}// 用玩家信息构建一个数据结构
◆ function OnPlayerDisconnected(player : NetworkPlayer) : void
描述：当玩家从服务器断开时再服务器上调用这个函数。
function OnPlayerDisconnected(player: NetworkPlayer) {
Debug.Log("Clean up after player " + player);
Network.RemoveRPCs(player);
Network.DestroyPlayerObjects(player);
}
◆ function OnSerializeNetworkView(stream : BitStream, info : NetworkMessageInfo) : void
描述：用来在一个被网络视架空的抄本中自定义变量同步。
它自动决定被序列化的变量是否应该发送或接收。这个依赖于谁拥有这个物体，例如，拥有者发送，而其他所有的接收。
//该物体的生命值信息
var currentHealth : int;
function OnSerializeNetworkView(stream : BitStream, info : NetworkMessageInfo){
var health : int = 0;
if (stream.isWriting){
health = currentHealth;
stream.Serialize(health);
}
else{
stream.Serialize(health);
currentHealth = health;
} 
}
◆ function OnServerInitialized() : void
描述：当Network . InitializeServer 被调用并完成时，在服务器上调用这个函数。
function OnServerInitialized() {
Debug.Log("Server initialized and ready");
}
类变量
◆ static var connections : NetworkPlayer[]
描述：所有连接上的玩家。在客户端中，该变量只包含服务器。
function OnGUI() {
if (GUILayout.Button ("Disconnect first player")) {
if (Network.connections.length > 0) {
Debug.Log("Disconnecting: "+Network.connections[0].ipAddress+":"+Network.connections[0].port);
Network.CloseConnection(Network.connections[0], true);
} 
} 
}
◆ static var ConnectionTesterIP:string
描述：用在Network.TestConnection中的连接测试的IP地址。
function ResetIP() {
Network.connectionTesterIP = "127.0.0.1";
Network.connectionTesterPort = 10000;
}
◆ static var connectionTesterPort:int
描述：用在Network.TestConnection中的连接测试的IP端口。
function ResetIP() {
Network.connectionTesterIP = "127.0.0.1";
Network.connectionTesterPort = 10000;
}
◆ static var incomingPassword:string
描述：为这个服务器设置密码（对于进入的连接）。这个必须与客户端上Network.Connect中的相同，传递””表示没有密码（默认）。
function ConnectToServer () {
Network.Connect("127.0.0.1", 25000, "HolyMoly");
}
function LaunchServer () {
Network.incomingPassword = "HolyMoly";
Network.InitializeServer(32, 25000);
}
◆ static var isClinet:bool
描述：如果你的端类型是客户端则返回真。
function OnGUI() {
if (Network.isServer)
GUILayout.Label("Running as a server");
else if (Network.isClient)
GUILayout.Label("Running as a client");
}
◆ static var isMessageQueueRunning:bool
描述：启用或禁用网络消息处理。如果这个被禁用，没有RPC调用或网络视同步会替代。Network level loading有如何使用这个函数的例子。
◆ static var isServer:bool
描述如果你的端类型是服务器端则返回真。
function OnGUI() {
if (Network.isServer)
GUILayout.Label("Running as a server");
else if (Network.isClient)
GUILayout.Label("Running as a client");
}
◆ static var maxConnections:int
描述：设置允许的连接/玩家的最大数量。设置0，以为这没有心的连接可以被建立。但现有保持连接。设置为-1表示最大连接数被设置为与当前开发的连接数相同。在这种情况下，如果一个玩家掉线，那么这个空位还是为他开放的。这个不能设置为高于Network.InitializeServer设置的连接数。
function StartGameNow() {
// 不允许更多玩家
Network.maxConnections = -1;
}
◆ static var minimumAllocatableViewIDs:int
描述：在ViewIDc池中获取或设置服务器分配给客户端ViewID的最小数。当玩家使用新的数字连接并被刷新时，ViewID池被分配给每个玩家。服务器和客户端应该同步这个值。在服务器上设置的更高，将会发送比它们真正需要的更多视ID数到客户端。在客户端上设置更高，意味着它们需要更多视ID。例如当池需要的ID数，服务器中并不包含足够的数量，则会在一行中使用两次。默认值为100。如果一个游戏通过网络实例化大量新的物体，例如每秒超过100个的网络实例，那么这个值需要被设置的更高。
function Awake () {
// 使用更大的视ID池来分配
Network.minimumAllocatableViewIDs = 500;
}
◆ static var natFacilitatorIP:string 
描述：NAT穿透辅助的IP地址。通常这与服务器相同。
function ResetIP() {
Network.natFacilitatorIP = "127.0.0.1";
Network.natFacilitatorPort = 10001;
}
static var natFacilitatorPort:int 
描述：NAT穿透辅助的端口。
function ResetIP() {
Network.natFacilitatorIP = "127.0.0.1";
Network.natFacilitatorPort = 10001;
}
◆ static var peerType:NetworkPeerType
描述：端类型状态。例如，断开连接，连接，服务器或客户端。
function OnGUI() {
if (Network.peerType == NetworkPeerType.Disconnected)
GUILayout.Label("Not Connected");
else if (Network.peerType == NetworkPeerType.Connecting)
GUILayout.Label("Connecting");
else
GUILayout.Label("Network started");
}
◆ static var player:NetworkPlayer 
描述：获取本地NetworkPlayer实例。
◆ static var ProxyIP:string
描述：代理服务器的IP地址。
 
function Awake(){
Network.proxyIP = "1.1.1.1";
Network.proxyPort = 1111;
}
◆ static var proxyPassword:string
描述：设置代理服务器密码。可以制作你自己的代理服务器。在这种情况下，你也许想用密码保护它。然后Unity玩家必须正确的设置这个值。
function Awake(){
//设置自定义代理服务器地址和密码
Network.proxyIP = "1.1.1.1";
Network.proxyPort = 1111;
Network.proxyPassword = "secret";
}
◆ static var proxyPort:int  描述：代理服务器的端口。
function Awake(){
Network.proxyIP = "1.1.1.1";
Network.proxyPort = 1111;
}
◆ static var sendRate:float  描述：用于所有网络视的默认网络更新发送速率。
function Awake () {
//增加默认的发送速率
Network.sendRate = 25;
}
◆ static var sendRate:float
描述：获取当前网络时间（秒）。这个可以用来比较NetworkMessageInfo中返回的时间。这个实例脚本需要附加到一个带有网络视的物体上，并使网络视监视这个脚本。它管理时间，发送这个物体的同步X位置消息。
var something : float;
var transitTime: double;
function OnSerializeNetworkView (stream : BitStream, info : NetworkMessageInfo) {
var horizontalInput : float = 0.0;
if (stream.isWriting) {//发送
horizontalInput = transform.position.x;
stream.Serialize (horizontalInput);
}
 else {//接收
transitTime = Network.time - info.timestamp;
stream.Serialize (horizontalInput);
something = horizontalInput;
}
}
function OnGUI() {
GUILayout.Label("Last transmission time: "+ transitTime);
}
◆ static var useNat:bool
 
描述：当连接（客户端）或接收连接（服务器）时，我们应该使用NAT穿透吗？如果这个在在服务器上设置，只有具有NAT穿透的客户端才能连接到它。但是如果服务器有一个NAT地址，这个需要打开以便连接。有些路由器不知道如何做NAT穿透。因此对于这些玩家唯一的方法就是修改路由器以便打开合适的转发端口（游戏端口）。参考Network.TestConnection和Network.TestConnectionNAT获取如何自动检测端用户的方法。
function OnGUI() {
if (GUILayout.Button ("Start Server"))
{
//如果没有共有IP地址，使用NAT穿透
Network.useNat = !Network.HavePublicAddress();
Network.InitializeServer(32, 25002);
MasterServer.RegisterHost("MyUniqueGameType", "JohnDoes game", "l33t game for all");
}
}
◆ static var useProxy:bool
描述：标示是否需要代理服务器支持，在这种情况下流量通过代理服务器被延迟。代理伺服器是一种与服务器和客户端连接性问题的解决方案。当机器有一个非NAT穿透能力的路由器，其连接的选择非常优先。一个游戏不能没有外部连接（只有客户端在本地网络中）。通过使用代理服务器，该机器可以具有完全的连接性，但是额外的代价是所有的流量都会被延迟。一个没有NAT穿透能力的客户端通过代理能够连接到任何服务器，只要代理服务器正确的设置。官方并不提供代理服务器为公众使用。所以你需要自己建立代理服务器。当然，用共有IP地址设置代理服务器并保证有大量可用带宽是明智的。当作为客户端运行时，只要启用Network .useProxy就可以。想往常昂使用Network . Connect连接到服务器。所有通过代理服务器的流量将被延迟。服务器的外部IP和内部IP还像往常一样工作。这样如果它们位于同一网络中，客户端可以直接连接到它而不需要代理。作为一个服务器运行时，OnServerInitialized(NetworkPlayer)返回一个NetworkPlayer结果表明游戏服务器中转的IP端口，代理服务器分配给游戏服务器的端口是什么。这个是其他客户端可以连接到的IP端口。当连接到服务器时，客户端不会将这个服务器与其他服务器区别对待。严格的说，它们不需要知道这个服务器得到代理服务器的帮助。当使用主服务器时，你不能只依赖于它在使用代理服务器时为服务器注册的IP端口。服务器使用的代理服务器的IP地址和端口，可以防止在数据域的注释中来发送给主服务器。从主服务器接收主机信息的客户端可以去除注释域并查看它是否能够为那个主机使用另一个可选的IP端口。
重要：你不应该同时为连接到它的服务器和客户端启用代理支持，会发生意想不到的事情。
var imaserver: boolean;
var serverIP: String;
var serverPort: int;
var serverUsesNAT: boolean;
function Awake(){
//设置自定义代理服务器地址
Network.proxyIP = "1.1.1.1";
Network.proxyPort = 1111;
if (imaserver)
StartServerWithProxy();
else
ConnectToServerWithProxy();
}
function StartServerWithProxy(){
Network.useProxy = true;
Network.InitializeServer(2,25000);
}
function OnServerInitialized(player: NetworkPlayer){
if (Network.useProxy)
Debug.Log ("Successfully started server with proxy support. We are connectable through "+ player.ipAddress + ":" + player.port);
}
function OnFailedToConnect(msg: NetworkConnectionError){
if (Network.useProxy && imaserver){
Debug.LogError("Failed to connect to proxy server: " + msg);
}
}
function ConnectToServerWithProxy(){
Network.useProxy = true;
Network.useNat = serverUsesNAT;
Network.Connect(serverIP, serverPort);
}
function OnConnectedToServer(){
Debug.Log("Connected successfully to server");
}
类方法
◆ static function AllocateViewID():NetworkViewID
描述：查询下一个可用的网络视ID数并分配它（保留）。这个数字又可以被赋予一个实例化物体的网络视。注意，为了使其可正常工作，必须有一个NetworkView附加到这个物体，这个物体必须有这个脚本并必须使这个脚本作为它的观察属性。必须有一个Cube预设，带有一个NetworkView它监视某些东西（例如该Cube的Transform）。脚本中的cubePrefab变量必须设置为立方体预设。使用智能的AllocateViewID是最简单的方法。如果有超过一个NetworkView附加在初始化的Cube上着将变得更复杂。
var cubePrefab : Transform;
function OnGUI (){
if (GUILayout.Button("SpawnBox")){
var viewID = Network.AllocateViewID();
networkView.RPC("SpawnBox", RPCMode.AllBuffered, viewID, transform.position); 
}
}
@RPC
function SpawnBox (viewID : NetworkViewID, location : Vector3) {
//实例化本地的prefab
var clone : Transform;
clone = Instantiate(cubePrefab, location, Quaternion.identity);
var nView : NetworkView;
nView = clone.GetComponent(NetworkView);
nView.viewID = viewID;
} 
◆ static function CloseConnection (target : NetworkPlayer, sendDisconnectionNotification : bool) : void  
描述：关闭与其他系统的连接。/target/定义连接到的那个系统将被关闭，如果我们是客户端，连接到服务器的连接将会关闭。如果我们是服务器目标玩家，将会被踢出。sednDisconnectionNotification启用或禁用通知将被发送到另一端。如果禁用连接被丢弃，如果没有断开连接通知被发送到远端，那么之后的连接将被丢弃。
function OnGUI() {
if (GUILayout.Button ("Disconnect from server")) {
if (Network.connections.length == 1) {
Debug.Log("Disconnecting: "+Network.connections[0].ipAddress+":"+Network.connections[0].port);
Network.CloseConnection(Network.connections[0], true);
} 
else if (Network.connections.length == 0)
Debug.Log("No one is connected");
else if (Network.connections.length > 1)
Debug.Log("Too many connections. Are we running a server?");
}
if (GUILayout.Button ("Disconnect first player")) {
if (Network.connections.length > 0) {
Debug.Log("Disconnecting: "+Network.connections[0].ipAddress+":"+Network.connections[0].port);
Network.CloseConnection(Network.connections[0], true);
} 
} 
}
◆ static function Connect (IP:string, remotePort:int, password:string = ""):NetworkConnectionError
描述：连接到特定的主机（IP或域名）和服务器端口。参数是主机的IP地址，点IP地址或一个域名。remotePort，指定连接到远端机器的端口。password，它是一个可选的用于服务器的密码。这个密码必须设置为与服务器的Network.incomingPassword相同。
function ConnectToServer () {
Network.Connect("127.0.0.1", 25000);
}
◆ static function Connect(IPs:string[], remotePort:int, password:string = ""):NetworkConnectionError
描述：该函数与Network.Connect类似，但是可以接受一个IP地址数组。当从一个主服务器的主机信息返回多个内部IP地址时，IP数据结构可以被直接传入这个函数。它将实际的连接到相应ping的第一个IP（可连接）。
◆ static function Destroy (viewID : NetworkViewID) : void
描述：跨网络销毁与该视ID相关的物体。本地的于远端的都会被销毁。
var timer : float;
function Awake () {
timer = Time.time;
}
//通过网络销毁拥有该脚本的物体
//其必须具备NetworkView属性
function Update() {
if (Time.time - timer > 
2)
{
Network.Destroy(GetComponent(NetworkView).viewID);
}
} 
function Update() {
if (Time.time - timer > 2){
Network.Destroy(GetComponent(NetworkView).viewID);
}
}
◆ static function Destroy (gameObject : GameObject) : void
描述：跨网络销毁该物体。本地的与远端的都会被销毁。
var timer : float;
function Awake () {
timer = Time.time;
}//通过网络销毁拥有该脚本的物体
function Update() {
if (Time.time - timer > 2){
Network.Destroy(gameObject);
}
}
◆ static function DestroyPlayerObjects (playerID : NetworkPlayer) : void
描述：基于视ID销毁所有属于这个玩家的所有物体。这个只能在服务器上调用。例如，清理一个已断开的玩家留下的网络物体。
function OnPlayerDisconnected(player: NetworkPlayer) {
Debug.Log("Clean up after player " + player);
Network.RemoveRPCs(player);
Network.DestroyPlayerObjects(player);
}
◆ static function Disconnect (timeout : int = 200) : void
描述：关闭所有开放的连接并关闭网络接口。timeout参数表示网络接口在未收到信号的情况下，多长时间会关闭。网络状态，入安全和密码，也会被重置。
function OnGUI() {
if (GUILayout.Button ("Disconnect")) {
Network.Disconnect();
MasterServer.UnregisterHost();
}
}
◆ static function GetAveragePing (player : NetworkPlayer) : int
描述：到给定player的最后平均ping时间，以毫秒计。如果没有发现玩家，返回-1。Ping会每隔几秒自动发出。
function OnGUI() {
var i: int;
GUILayout.Label("Player ping values");
for (i=0; i < Network.connections.length; i++) {
GUILayout.Label("Player " + Network.connections[i] + " - " + Network.GetAveragePing(Network.connections[i]) + " ms");
}
}、

◆ static function GetLastPing (player : NetworkPlayer) : int
描述：到给定player的最后平均ping时间，以毫秒计。 
如果没有发现玩家，返回-1。Ping会每隔几秒自动发出。
function OnGUI() {
var i: int;
GUILayout.Label("Player ping values");
for (i=0; i < Network.connections.length; i++) {
GUILayout.Label("Player " + Network.connections[i] + " - " + Network.GetLastPing(Network.connections[i]) + " ms");
}
}
◆ static function HavePublicAddress () : bool
描述：检查该机器是否有一个公共IP地址。检查所有接口来获取Ipv4公共地址。如发现返回真。
function OnGUI() {
if (GUILayout.Button ("Start Server")){
// 如果没有公共IP地址，使用NAT穿透
Network.useNat = !Network.HavePublicAddress();
Network.InitializeServer(32, 25002);
MasterServer.RegisterHost("MyUniqueGameType", "JohnDoes game", "l33t game for all");
}
}
◆ static function InitializeSecurity () : void
描述：初始化安全层。你需要再Network.InitializeServer调用之后在服务器上调用这个函数。不要再客户端调用该函数你的在线游戏达到一定知名度时就有人试图作弊。你讲需要再游戏层和网络层处理这个。如果你希望使用它们，Unity可以通过提供安全连接处理网络层。
使用AES加密，阻止未授权读取并阻止重复攻击，添加CRC来检测数据篡改，使用随机的、加密的SYNCookies来组织未授权登录，使用RSA加密保护这个AES密钥
大多数游戏将使用安全连接。然后，它们会向每个数据包添加15自己并需要时间计算，所以你也许想限制使用此功能。
function Start (){
Network.InitializeSecurity();
Network.InitializeServer(32, 25000);
}
◆ static function InitializeServer (connections:int,listenPort:int) : NetworkConnectionError
描述：初始化安全层。connections是允许进入的连接或玩家的数量。listenPort是我们要监听的端口。
function LaunchServer () {
Network.incomingPassword = "HolyMoly";
Network.InitializeServer(32, 25000);
}
◆ static function Instantiate (prefab:Object, position:Vector3, rotation:Quaternion, group:int):Object
描述：网络实例化预设。给定的预设将在所有的客户端上初始化。同步被自动设置所以没有额外的工作需要做。位置、旋转和网络组数值作为给定的参数。这是一个RPC调用，因此
 
当Network.RemoveRPCs为这个组调用的使用，这个物体将被移除。注意在编辑器中必须设置playerPrefab，你能在Object.Instantiate物体参考中获取更多实例化信息。
//当成功连接到服务器上时
//立即实例化新连接的玩家角色
var playerPrefab : Transform;
function OnConnectedToServer (){
Network.Instantiate(playerPrefab, transform.position, transform.rotation, 0);
}
◆ static function RemoveRPCs (playerID : NetworkPlayer) : void
描述：移除所有属于这个玩家ID的RPC函数。
function OnPlayerDisconnected(player: NetworkPlayer) {
Debug.Log("Clean up after player " + player);
Network.RemoveRPCs(player);
Network.DestroyPlayerObjects(player);
}
◆ static function RemoveRPCs (playerID : NetworkPlayer, group : int) : void
描述：移除所有属于这个玩家ID并给予给定组的所有RPC函数。
◆ static function RemoveRPCs (viewID : NetworkViewID) : void
描述：移除所有与这个视ID数相关的RPC函数调用。
◆ static function RemoveRPCsInGroup (group : int) : void
描述：移除所有属于给定组数值的RPC函数。
◆ static function SetLevelPrefix (prefix : int) : void
描述：设置关卡前缀，然后所有网络视ID都会使用该前缀。此处提供了一些保护，可以防止来自前一个关卡的旧的网络更新影响新的关卡。此处可以设置为任何数字并随着新关卡的加载而增加。这不会带来额外的网络负担，只会稍微减小网络视ID池。Network level loading有如何使用该函数的例子。
◆ static function SetReceivingEnabled (player : NetworkPlayer, group : int, enabled : bool) : void
描述：启用或禁用特定组中来自特定玩家的信息接收。在你不希望任何网络消息进入的时候可以使用这个函数，然后在你准备好的时候启用。例如，可用于停止网络消息，知道关卡被加载。
//停止接收来自所有玩家（客户端）的组0的信息
for (var player : NetworkPlayer in Network.connections)
Network.SetReceivingEnabled(player, 0, false);
◆ static function SetSendingEnabled (group : int, enabled : bool) : void
描述：启用或禁用特定网络组上的信息传输和RPC调用。当你知道你不发送任何有用的信息到其他客户端时，可以设置这个。例如在你完全你家在关卡之前。Network level loading中有例子。
static function SetSendingEnabled (player : NetworkPlayer, group : int, enabled : bool) : void 
描述：基于目标玩家和网络组启用或禁用消息传说和RPC调用。当在客户端使用时，唯一可能的NetworkPlayer就是服务器。
◆ static function TestConnection (forceTest : bool = false) : ConnectionTesterStatus
描述：测试这个机器的网络连接。执行两种测试，这取决机器有公用IP还是只有一个私有IP。公用IP测试主要用于服务器，不需要测试具有公用地址的客户端。为了公用IP测试成功，必须开启一个服务器实例。一个测试服务器将尝试连接到本地服务器的IP地址和端口，因此它被显示在服务器中位可连接状态。如果不是，那么防火墙是最有可能阻断服务端口的。服务器实例需要运行以便测试服务器能连接到它。另一个试验检测NAT穿透能力。服务器和客户端都可以进行，无需任何事先设定。如果用于服务器NAT测试失败，那么不设置端口转发是一个坏主意。本地LAN网络之外的客户端将不能连接。如果测试失败，客户端就不能使用NAT连接到服务器，这些服务器将不会提供给用户作为主机。这个函数是异步的，并可能不会返回有效结果。因为这个测试需要一些时间来完成（1-2秒）。测试完成后，测试的结果只在函数被再次调用时返回。这样，频繁访问该函数是安全的。如果需要其他的测试，入网络连接已改变，那么forcTest参数应该为真。该函数返回一个ConnectionTesterStatus枚举。
//是否应该在主机列表上隐藏NAT主机？
private var filterNATHosts = false;
private var doneProbingPublicIP = false;
function OnGUI (){
//开始/轮询连接测试
//在标签上显示结果并按照结果做出相应的反应
natCapable = Network.TestConnection();
if (natCapable == -2)
GUILayout.Label("Problem determining NAT capabilities");
else if (natCapable == -1)
GUILayout.Label("Undetermined NAT capabilities");
else if (natCapable == 0){
GUILayout.Label("Cannot do NAT punchthrough, " +"filtering NAT enabled hosts for client connections, " +"impossible to run a server.");
filterNATHosts = true;
Network.useNat = false;
}
else if (natCapable == 1){
if (doneProbingPublicIP)
GUILayout.Label("Non-connectable public IP address (port "+ serverPort +" blocked), NAT unchthrough can circumvent the firewall.");
else
GUILayout.Label("NAT punchthrough capable. " +"Enabling NAT punchthrough functionality.");
//一旦服务器开始NAT功能被启用
//客户端是否开启这个基于主机是否需要
Network.useNat = true;
}
else if (natCapable == 2){
GUILayout.Label("Directly connectable public IP address.");
Network.useNat = false;
}
else if (natCapable == 3){
GUILayout.Label("Non-connectble public IP address (port " + serverPort +" blocked), running a  
server is impossible.");
Network.useNat = false;
if (!doneProbingPublicIP){
natCapable = Network.TestConnectionNAT();
doneProbingPublicIP = true;
}
}
else if (natCapable == 4){
GUILayout.Label("Public IP address but server not initialized, "+"it must be started to check server accessibility.");
Network.useNat = false;
}
if (GUILayout.Button ("Retest connection")){
Debug.Log("Redoing connection test");
doneProbingPublicIP = false;
natCapable = Network.TestConnection(true);
}
}
◆ static function TestConnectionNAT () : ConnectionTesterStatus
描述：测试NAT穿透的连接性。这个就像Network.TestConnection，只不过NAT穿透是强制的，即使该机器有一个公用地址。请参考Network.TestConnection。
Object
类
Unity所涉及的所有物体的基类。任何从Object继承的公有变量将作为一个目标显示在监视面板中，允许你从GUI中设置。
变量
◆ var hideFlags : HideFlags 描述：该物体是否被隐藏，保存在场景中或被用户修改。
◆ var name : string
描述：对象的名称。组件与游戏物体和所有附加的组件共享相同名称。
//改变物体的名称为Hello
name = "Hello";
函数
◆ function GetInstanceID () : int 描述：返回该物体的实例id。一个物体的实例ID总是唯一。
描述：返回该物体的实例id。
一个物体的实例id总是唯一的。
print(GetInstanceID());
类方法
◆ static function Destroy (obj : Object, t : float = 0.0F) : void
描述：移除一个游戏物体，组件或资源。物体obj将被小火或者t秒后被销毁。如果obj是一个Component它将被从GameObject中移除。如果obj是一个GameObject它将销毁这个GameObject，以及它的组件和所子对象。实际的销毁总是推迟到下个Update来临时，但总在渲染前完成。
//销毁这个游戏物体
Destroy (gameObject);
//从物体上移除该脚本
Destroy (this);
//从游戏物体上移除刚体组件
Destroy (rigidbody);
//加载该游戏物体后5秒删除
Destroy (gameObject, 5);
//当玩家按下Ctrl时移除名为FoooScript的脚本
function Update () {
if (Input.GetButton ("Fire1") && GetComponent (FooScript))
Destroy (GetComponent (FooScript));
}
◆ static function DestroyImmediate (obj : Object, allowDestroyingAssets : bool = false) : void

描述：立即销毁物体。强烈建议使用Destroy代替它。该函数应该只在编写编辑器代码时使用，因为延迟的销毁将不会再编辑器模式调用。游戏代码中建议使用Destroy。Destroy总是延迟的（但是在同一帧执行）。小心使用该函数，因为它能永久的销毁资源。
◆ static function DontDestroyOnLoad (target : Object) : void
描述：加载新场景时确保物体target不被自动销毁。当加载一个新的关卡时，场景中的所有物体都会被销毁，然后心关卡中的物体将被加载。为了在关卡加载的时候保持物体在上面调用DontDestroyOnLoad。如果物体是一个组件或游戏物体，那么它的整个变换层次将不会被销毁。
//保证该游戏物体及其变化子物体在载入新场景时不会被销毁。
function Awake () {
DontDestroyOnLoad (this);
}
◆ static function FindObjectOfType (type : Type) : Object
描述：返回第一个类型为Type的已激活加载的物体。参见Object.FindObjectsOfType 。
◆ static function FindObjectsOfType (type : Type) : Object[]
描述：返回所有类型为Type的已激活加载的物体。 
参见Object.FindObjectsOfType 。
它将返回任何资源（网格、纹理、预设等）或已激活加载的物体。
//当点击该物体，它将禁用场景中所有铰链中的弹簧。
function OnMouseDown () {
hinges = FindObjectsOfType (HingeJoint);
for (var hinge : HingeJoint in hinges) {
hinge.useSpring = false;
}
} 
c#版
public class Something : MonoBehaviour{
void OnMouseDown(){
HingeJoint[] hinges = FindObjectsOfType<HingeJoint>();
for (HingeJoint hinge in hinges) {
hinge.useSpring = false;
}
}
}
◆ static function Instantiate (original : Object, position : Vector3, rotation : Quaternion) : Object
描述：克隆original物体并返回该克隆。防御position兵设置旋转为rotation，然后返回该克隆。本职上与cmd-d相同，并移动到给定位置。如果一个游戏物体、组件或脚本实例被传入，Instantiate将克隆整个游戏物体层次，所有的子对象也被克隆。所有游戏物体被激活。参加：预设实例化的深入讨论。
//实例化预设的10个拷贝，间隔为2单位。
var prefab : Transform;
for (var i=0;i<10;i++) {
Instantiate (prefab, Vector3(i * 2.0, 0, 0), Quaternion.identity);
}
Instantiate更多常用于实例化投射物、AI敌人，粒子爆炸或b破损的物体。
//实例化一个刚体，然后设置速度。
var projectile : Rigidbody;
function Update () {
//按下ctrl时，发射一个物体
if (Input.GetButtonDown("Fire1")) {
//以该变化位置与旋转实例化投射物
var clone : Rigidbody;
clone = Instantiate(projectile, transform.position, transform.rotation);
//沿当前物体Z轴，给克隆体一个初始速度
clone.velocity = transform.TransformDirection (Vector3.forward * 10);
}
}
实例化也能直接克隆脚本实例。整个游戏物体层级将被克隆，并且克隆脚本的实例将被返回。
//初始化一个附加了Missile脚本的预设
var projectile : Missile;
function Update () {
//按下ctrl时，发射一个物体
if (Input.GetButtonDown("Fire1")) {
//以该变化位置与传转实例化投射物
var clone : Missile;
clone = Instantiate(projectile, transform.position, transform.rotation);
//设置火箭超市销毁为5秒
clone.timeoutDestructor = 5;
}
}
克隆一个物体之后可以使用GetComponet来设置附加到克隆物体上的特定组件的属性。
◆ static function Instantiate (original : Object) : Object 
描述：克隆original物体并返回该克隆。这个函数保留克隆物体的位置与赋值命令相同（cmd-d）。
//当任何刚体进入这个触发器时实例化预设。
//它保留预设的原始位置与旋转。
var prefab : Transform;
function OnTriggerEnter () {
Instantiate (prefab);
}
◆ static operator != (x : Object, y : Object) : bool 
描述：比较两个物体是否不同。
var target : Transform;
function Update (){
//如果target不同于我们的变换。
if (target != transform){
print("Another object"); 
}
}
◆ static operator == (x : Object, y : Object) : bool 
描述：比较两个物体是否相同。
var target : Collider;
function OnTriggerEnter (trigger : Collider){
if (trigger == target)
print("We hit the target trigger");
}
var target : Transform;
function Update (){
//该物体已被销毁。
if (target == null)
return;
}
◆ static implicit function bool (exists : Object) : bool 
描述：这个物体是否存在？
if（rigidbody） 
等同于
if（rigidbody != null）
AnimationClip
类，继承自Object。
存贮基于动画的关键帧。
AnimationClip被Animation使用来播放动画。 
变量
◆ var frameRate : float
描述：关键帧被残阳的帧率。这个与用来制作动画/模型的动画程序相同。
//打印动画剪辑的帧率到控制台。
print(animation["walk"].clip.frameRate);
◆ var length : float 
描述：动画播放的描述。
animation.Play(animation.clip);
//等待动画完成。
yield WaitForSeconds (animation.clip.length);
◆ var wrapMode : WrapMode 
描述：在动画状态中设定默认的卷模式。
构造函数
◆ static function AnimationClip () : AnimationClip 
描述：创建一个新的动画剪辑。
函数
◆ function AddEvent (evt : AnimationEvent) : void
描述：创建一个新的动画剪辑。这将添加这个时间直到退出播放模式或玩家退出。如果你想从编辑器添加一个固定的剪辑到AnimationEvent，使用UnityEditorAnimationUtility.SetAnimationEvents。
◆ function ClearCurves () : void 
描述：从剪辑中清理所有曲线。
◆ function SetCurve (relativePath : string, type : Type, propertyName : string, curve : AnimationCurve) : void
参数
relativePath  应用这个曲线的游戏物体的路径。relativePath被格式化为一个路径名。入：“root/spine/leftArm”如果relativePath为空，表示该动画剪辑所附加的游戏物体。
type  被进行动画处理的组件的类类型。
propertyName 被动画处理的属性的名称或路径。
curve 动画曲线。
描述：给动画指定一个特定的曲线属性。如果曲线为null该曲线将被移除。如果曲线为null该曲线将被移除。如果曲线属性已经存在，则会被替换。通常的名称是：“localPostion.x”，“localPostion.y”，“localPostion.z”，“localRotation.x”，“localRotation.y”，“localRotation.z”，“localRotation.w”，“localScale.x”，“localScale.y”，“localScale.z”。出于性能考虑Transform的位置、旋转和缩放只能被所谓一个动画属性。
 
//对x坐标的位置进行动画处理
function Start (){
//创建曲线
var curve = AnimationCurve.Linear(0, 1, 2, 3);
//用曲线创建剪辑
var clip = new AnimationClip();
clip.SetCurve("", Transform, "localPosition.x", curve);
//添加并播放剪辑
animation.AddClip(clip, "test");
animation.Play("test");
}
@script RequireComponent(Animation)
Material属性可以使用shader到处的名称制作动画属性。通常的属性名称是：“_MainTex”，“_BumpMap”，“_LightMap”，“_Color”，“_SpecColor”，“_Emmission”。
Float属性“PropertyName”
Vector4属性“PropertyName.x”“PropertyName.x” “PropertyName.x” “PropertyName.x” Color属性“PropertyName.r”“PropertyName.g”“PropertyName.b”“PropertyName.a”
UV旋转属性“PropertyName.rotation”；UB便宜和缩放“PropertyName.offset.x”“PropertyName.offset.y”“PropertyName.scale.x”“PropertyName.scale.y”
对于在同一个Renderer上的多个索引材质，你可以像这样加前缀“[1]._MainTex.offset.y”。
//对alpha值和主要材质地平线补偿进行动画处理
function Start () {
var clip = new AnimationClip ();
clip.SetCurve ("", typeof(Material), "_Color.a",AnimationCurve (Keyframe(0, 0, 0, 0), Keyframe(1, 1, 0, 0)));
clip.SetCurve ("", typeof(Material), "_MainTex.offset.x",AnimationCurve.Linear(0, 1, 2, 3));
animation.AddClip (clip, clip.name);
animation.Play(clip.name);
}
@script RequireComponent(Animation)
继承的成员
继承的变量 
name 对象名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectsOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
AssetBundle

类，继承自Object。AssetBundles让你通过WWW类流式加载额外的资源并在运行时实例化它们。AssetBundles通过BuildPipeline.BuildAssetBundle创建。参见：WWW.assetBundle ，Loading Resources at Runtime ，BuildPipeline.BuildPlayer
function Start () {
var www = new WWW ("http://myserver/myBundle.unity3d");
yield www;
//获取指定的主资源并实例化
Instantiate(www.assetBundle.mainAsset);
}
变量
◆ var mainAsset : Object
描述：竹资源在构建资源boundle时指定（只读）。该功能可以方便的找到bundle内的主资源。例如，你也许想将预设一个角色并包括所有纹理、材质、网格和动画文件。但是完全操纵角色的预设应该是你的mainAsset并且可以被容易的访问。
function Start () {
var www = new WWW ("http://myserver/myBundle.unity3d");
yield www;
//获取指定的主资源并实例化
Instantiate(www.assetBundle.mainAsset);
}
函数
◆ function Contains (name : string) : bool 
描述：如果AssetBundle的名称中包含特定的对象则进行检索。如果包含则返回真。
◆ function Load (name : string) : Object 
描述：从bundle中加载名为name的物体。
◆ function Load (name : string, type : Type) : Object
描述：从bundle中加载名为name的type类物体。
◆ function LoadAll (type : Type) : Object[ ]
描述：加载所有包含在资源bundle中且继承自type的物体。
◆ function LoadAll () : Object[ ]
描述：加载包含在资源bundle中的所有物体。
◆ function Unload (unloadAllLoadedObjects : bool) : void
描述：写在bundle中的所有资源。Unload释放bundle中所有序列化数据。当unloadAllLoaderObjects为假，bundle内的序列化数据将被写在，但是任何从这个bundle中实例化的物体都将完好。当然，你不能从这个bundle中加载更多物体。当unloadAllLoaderObjects为真，所有从该bundle中加载的物体也将被销毁。如果
场景中有游戏物体引用该资源，那么引用也会丢失。
继承的成员
继承的变量 
name 对象名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectsOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
AudioClip
类，继承自Object。音频数据的容器。一个AudioClip以压缩或未压缩的格式存储音频文件。AudioClips被AudioSources参考或引用来播放声音。参见组件参考的AudioClip.component。
变量
◆ var isReadyToPlay : bool
描述：有没流式音频剪辑准备播放？（只读）如果AudioClip是从网站上下载的，此变量用来判断下载到的数据是否足够不间断的播放。对于不是来自web的流的AudioClips，该值总是真。
function Start (){
www=new WWW(url);
audio.clip=www.audioClip;
}
function Update (){
if(!audio.isPlaying && audio.clip.isReadyToPlay)
audio.Play();
}
◆ var length : float
 描述：音频剪辑的长度，以秒计（只读）。
audio.Play();
//等待音频播放完成
yield.WaitForSeconds(audio.clip.length);
继承的成员
继承的变量 
name 对象名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectsOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
Component
类，继承自Object。音频数据的容器。所有附加到游戏物体上的对象的基类。
变量
◆ var animation : Animation
描述：附加到这个GameObject的Animation。（没有则为null）
◆ var audio : AudioSource
描述：附加到这个GameObject的AudioSource。（没有则为null）
audio.Play()
◆ var camera : Camera
描述：附加到这个GameObject的Camera。（没有则为null）
◆ var collider : Collider
描述：附加到这个GameObject的Collider。（没有则为null）
collider.material.dynamicFriction =1
◆ var constantForce : ConstantForce
描述：附加到这个GameObject上的ConstantForce（没有则为null）。
◆ var gameObject : GameObject 
描述：这个组件所附加的游戏物体。组件总是附着在游戏物体上。
print(gameObject.name);
◆ var guiText : GUIText
描述：附加到这个GameObject上的GUIText（没有则为null）。
guiText.text = "Hello World";
◆ var guiTexture : GUITexture
描述：附加到这个GameObject上的GUITexture（只读）（没有则为null）。
◆ var hingeJoint : HingeJoint
描述：附加到这个GameObject的HingeJoint（没有则为null）。
hingeJoint.motor.targetVelocity = 5;
◆ var hingeJoint : HingeJoint
描述：附加到这个GameObject的HingeJoint（没有则为null）。
◆ var light : Light
描述：附加到这个GameObject的Light（没有则为null）。
◆ var networkView : NetworkView
描述：附加到这个GameObject的NetworkView（只读）（没有则为null）。
networkView.RPC("MyFunction", RPCMode.All, "someValue");
◆ var particleEmitter : ParticleEmitter
描述：附加到这个GameObject的ParticleEmitter（没有则为null）。
particleEmitter.emit = true;
◆ var renderer : Renderer
描述：附加到这个GameObject的Renderer。（没有则为null）
◆ var rigidbodyr : Rigidbody
描述：附加到这个GameObject的rigidbody。（没有则为null）
◆ var tag : string
描述：附加到这个GameObject的rigidbody。标签可以用来标识一个游戏物体。标签在使用前必须在标签管理器中定义。
◆ var transform : Transform
描述：附加到这个GameObject的Transform。（没有则为null）
transform.Translate(1, 1, 1);
函数
◆ function BroadcastMessage (methodName : string, parameter : object = null, options : 
SendMessageOptions = SendMessageOptions.RequireReceiver) : void
描述：在这个游戏物体或其任何子物体上的每个MonoBehaviour上调用methodName方法。通过使用零参数，结婚搜方法可以选择忽略parameter。如果options被设置为SednMessageOptions.RequireReceiver，那么如果这个消息没有被任何组件接受时，将打印一个错误信息。
//使用值5调用ApplyDamage
BroadcastMessage ("ApplyDamage", 5.0);
//每个附加到该游戏物体及其所有子物体上含有ApplyDamage函数的脚本都会被调用
function ApplyDamage (damage : float) {
print (damage);
}
◆ function CompareTag (tag : string) : bool 
描述：这个游戏物体有被标签为tag吗？
//立即销毁触发器，销毁任何进入到触发器的碰撞器，这些碰撞器被标记为Player
function OnTriggerEnter (other : Collider) {
if (other.CompareTag ("Player")) {
Destroy (other.gameObject);
}
}
◆ function GetComponent (type : Type) : Component
描述：如果游戏物体上附加了这个组件，则返回一个Type类，如果没有则返回null。
//等同于Transform curTransform = transform
var curTransform : Transform = GetComponent (Transform);
//你可以像访问其他组件一样的访问脚本组件
function Start () {
var someScript : ExampleScript = GetComponent (ExampleScript);
someScript.DoSomething ();
}
for c#
public class Something : MonoBehaviour{
void Start(){
ExampleScript someScript = GetComponent<ExampleScript>();
someScript.DoSomething ();
}
}
◆ function GetComponent (type : string) : Component
描述：如果游戏物体上附加了这个组件，则返回一个Type类，如果没有则返回null。处于性能原因，最好用Type调用GetComponent而不是字符串。不过有时你可能无法得到Type。例如当是同从Javascript中访问c#时。这时你可以简单的通过名称而不是类型访问该组件。
//为了访问附加在同一物体上的脚本中的公有变量与函数
script = GetComponent(ScriptName);
script.DoSomething ();
◆ function GetComponentInChildren (t : Type) : Component
描述：返回type类型组件，这个组件位于GameObject或任何它的子物体上，使用深度优先搜索。只有激活的最贱会被返回。
var script : ScriptName = GetComponentInChildren(ScriptName);
script.DoSomething ();
for c#
ScriptName script = GetComponentInChildren<ScriptName>();
script.DoSomething ();
◆ function GetComponents (type : type) : Component[]
描述：返回GameObject上所有type类型组件。
//关闭该游戏物体铰链上的所有弹簧 
var hingeJoints = GetComponents (HingeJoint);
for (var joint : HingeJoint in hingeJoints) {
joint.useSpring = false;
}
for c#
HingeJoint[] hingeJoints = GetComponents<HingeJoint>();
for (HingeJoint joint in hingeJoints) {
joint.useSpring = false;
}
◆ function GetComponentsInChildren (t:Type，includeInactive:bool=false) : Component[]
描述：返回GameObject上或其子物体上所有type类型组件。
//关闭该游戏物体极其子物体上的铰链上的所有弹簧
var hingeJoints = GetComponentsInChildren (HingeJoint);
for (var joint : HingeJoint in hingeJoints) {
joint.useSpring = false;
}
for c#
HingeJoint[] hingeJoints = GetComponentsInChildren<HingeJoint>();
for (HingeJoint joint in hingeJoints) {
joint.useSpring = false;
}
继承的成员
继承的变量 
name 对象名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectsOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
Behaviour
类，继承自Component。Behaviours是可以被启用或禁用的组件。参见MonoBehaviour和Component。
变量
◆ var enabled : bool
描述：启用Behaviours被更新，禁用Behaviours不被更新。这将在behaviour的坚实面板中显示为一个小的复选框GetComponent(PlayerScript)enabled = false;
继承的成员
继承的变量 
transform 附加到该GameObject的Transform（没有返回null）
rigidbody 附加到该GameObject的Rigidbody（没有返回null）
camera 附加到该GameObject的Camera（没有返回null）
light 附加到该GameObject的Light（没有返回null）
animation 附加到该GameObject的Animation（没有返回null）
constantForce 附加到该GameObject的ConstantForce（没有返回null）
renderer 附加到该GameObject的Renderer（没有返回null）
audio 附加到该GameObject的Audio（没有返回null）
guiText 附加到该GameObject的GuiText（没有返回null）
networkView 附加到该GameObject的NetworkView（没有返回null）
guiTexture 附加到该GameObject的GuiTexture（没有返回null）
collider 附加到该GameObject的Collider（没有返回null）
hingeJoint 附加到该GameObject的HingeJoint（没有返回null）
particleEmitter 附加到该GameObject的ParticleEmitter（没有返回null）
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetComponent 如果游戏附体上附加了一个，则返回type类组件，没有则返回null
GetComponentInChildren 如果该组件位于GameObject或任何其子物体上，返回type类组件，使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject或任何它的子物体上，返回type类组件。
GetComponents 返回GameObject上所有type类的组件
CompareTag 该游戏物体被是否被标签为tag？
SendMessageUpwards 在该游戏物体的每个MonoBehaviour和该行为的父对象上调用名为methodName的方法
SendMessage 在该游戏物体的每个MonoBehaviour上调用methodName方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour上调用methodName
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
Animation
类，继承自Behaviour，可枚举。动画组件用来播放动画。你可以给动画组件赋予一个动画剪辑，并从脚本中控制它的播放。Unity中的动画系统是基于权值的，并且支持动画混合、附加动画、动画合成、层和所有动画播放方面的完全控制。
为了播放动画可使用Animation.Play。
为了在动画间渐变可使用Animation.CrossFade。
为了改变动画的层可使用AnimationState.layer。
为了改变动画的包裹模式（循环、单次、往返）可使用Animation.wrapMode或
AnimationState.wrapMode。
AnimationState可以被用来调整播放速度和直接控制混合语合成。
Animation也支持枚举，因此你可以像这样循环所有的AnimationStates。
//使该角色上所有动画半速播放
for (var state : AnimationState in animation) {
state.speed = 0.5;
}
变量
◆ var animateOnlyIfVisible : bool
描述：启用后，Unity会在认为动画不可见的时候停止播放。该选项可以节省资源。
◆ var animatePhysics : bool
描述：启用后，动画奖在物理循环中执行。这只在与运动学刚体结合时有用。一个动画平台可以应用速度和摩擦到其顶部的刚体。为了利用这个，animatePhysics必须被启用，并且动画物体必须为一个运动学刚体。
◆ var clip : AnimationClip
描述：默认动画。
animation.Play(animation.clip);
//等待动画完成
yield WaitForSeconds (animation.clip.length);
◆ var isPlaying : bool
描述：是否正在播放动画？
//在动画没有播放时播放这个动画。
function OnMouseEnter() {
if (!animation.isPlaying)animation.Play();
}
◆ var playAutomatically : bool
描述：默认的动画剪辑（Animation.clip）是否在开始时自动播放？
animation.playAutomatically = true;
◆ var this[name : string] : AnimationState
描述：返回名为name的动画状态。
//获取walk动画状态并设置它的速度
animation["walk"].speed = 2.0;
//获取run动画状态并设置它的速度
animation["run"].weight = 0.5;
◆ var wrapMode : WrapMode
描述：超出剪辑播放时间之外时如何处理？
WrapMode.Default:从剪辑中获取回绕模式（默认为Once）。
WrapMode.Once:当时间到达末尾时停止动画。
WrapMode.Loop:当时间到达末尾时从头开始播放。
WrapMode.PingPong:在开始和结束之间来回播放。
WrapMode.ClampForever:播放动画。当它到达末端时，它将保持在最后一帧。
//让动画循环
animation.wrapMode = WrapMode.Loop;
函数
◆ function AddClip (clip : AnimationClip, newName : string) : void
描述：添加一个clip到Animation，它的名称为newName。
var walkClip : AnimationClip;
animation.AddClip(walkClip, "walk");
◆ function AddClip (clip : AnimationClip, newName : string, firstFrame : int, lastFrame : int, addLoopFrame : bool = false) : void
描述：添加clip只在firstFrame和lastFrame之间播放。这个新的剪辑也将被使用名称newName并添加到Animation。addLoopFrame：是否要插入额外的帧一边匹配第一帧？如果制作循环动画就要打开这个。如果存在一个同名的剪辑，老的将被覆盖。
//分割默认的剪辑为shoot，walk和idle动画
animation.AddClip(animation.clip, "shoot", 0, 10);
//walk和idle将在末尾添加额外的循环真
animation.AddClip(animation.clip, "walk", 11, 20, true);
animation.AddClip(animation.clip, "idle", 21, 30, true);
◆ function Blend (animation : string, targetWeight : float = 1.0F, fadeLength : float = 0.3F) : void
描述：在接下来的time内混合名为animation的动画得到targetWeight。其他动画播放不会受影响。
◆ function CrossFade (animation : string, fadeLength : float = 0.3F, mode : PlayMode = PlayMode.StopSameLayer) : void
描述：淡入名为animation的动画，并在time内淡出其他动画。如果模式是PlayMode.StopSameLayer，在同一层上淡入的动画将会被淡出。如果模式是PlayMode.StopAll，当动画被淡入后，所有动画都会被淡出。如果动画被设置为循环，在播放后将停止并回放。
//淡入walk循环并淡出同一层上所有其他动画。
//0.2秒内完成淡入
animation.CrossFade("Walk", 0.2);
//当玩家想要移动的时候，使角色动画在Run和Idle动画之间渐变。
function Update (){
if (Mathf.Abs(Input.GetAxis("Vertical")) > 0.1)animation.CrossFade("Run");
else
animation.CrossFade("Idle");
}
◆ function CrossFadeQueued (animation : string, fadeLength : float = 0.3F, queue : QueueMode = QueueMode.CompleteOthers, mode : PlayMode = PlayMode.StopSameLayer) : AnimationState
描述：在前一动画播放完后渐变到下一个动画。例如你可以播放一个特定的动画序列。动画在播放前复制自身，因此你可以再相同的动画间渐变，这可用来重叠两个相
同的动画。例如你可能有一个挥剑的动画，玩家快速挥动了2次，你可以回放这个动画并从开始播放它，但会跳帧。
下面是可用的queue modes：
下面是可用的queue modes：
如果queue为QueueMode.CompleteOthers这个动画纸在所有其他动画都停止播放时才开始。
如果queue为QueueMode.PlayNow这个动画将以一个复制的动画状态立即开始播放。
动画播放完成后它将自动清除它自己。在它播放完成后使用赋值的动画将导致一个异常。
function Update (){
if (Input.GetButtonDown("Fire1")) 
animation.CrossFadeQueued("shoot", 0.3, QueueMode.PlayNow);
}
◆ function GetClipCount () : int
描述：获取当前animation的剪辑数。
◆ function IsPlaying (name : string) : bool
描述：名为name的动画是否在播放？
function OnMouseEnter() {
if (!animation.IsPlaying("mouseOverEffect"))
animation.Play("mouseOverEffect");
}
◆ function Play (mode : PlayMode = PlayMode.StopSameLayer) : bool
function Play (animation : string, mode : PlayMode = PlayMode.StopSameLayer) : bool
描述：立即播放该动画，没有任何混合。Play()将会开始播放名为animation的动画，或者播放默认动画，且会在没有混合的情况下突然播放。如果模式为PlayMode.StopSameLayer所有在同一层上的动画都将被停止。如果模式是PlayMode.StepAll所有当前播放的动画都将被停止。如果动画正在播放，其他动画将被停止，但该动画会回到开始位置。如果动画没有被设置为循环，播放完后将停止并回放。如果动画无法被播放（没有该剪辑或没有默认动画），Play()会返回假。
//播放默认动画
animation.Play ();
//播放walk动画，停止该层内所有其他动画
animation.Play ("walk");
//播放walk动画，停止其他所有动画
animation.Play ("walk", PlayMode.StopAll);
◆ function PlayQueued (animation : string, queue : QueueMode = QueueMode.CompleteOthers, mode : PlayMode = PlayMode.StopSameLayer) : AnimationState
描述：在前一动画播放完后渐变一个动画。例如你可以播放一个特定的动画序列。动画状态在播放前复制自身，因此你可以再相同的动画之间渐变。这可用来重叠两个相同的动画。例如你可能有一个挥剑的动画。玩家快速的砍了两次，你可以回放这个动画，并且从开始播放，只不过会跳帧。
下面是可用的queue modes：
如果queue为QueueMode.CompleteOthers这个动画纸在所有其他动画都停止播放时才开始。
如果queue为QueueMode.PlayNow这个动画将以一个复制的动画状态立即开始播放。
动画播放完成后它将自动清除它自己。在它播放完成后使用赋值的动画将导致一个异常。
function Update (){
if (Input.GetButtonDown("Fire1")) 
animation.PlayQueued("shoot", QueueMode.PlayNow);
}
◆ function RemoveClip (clip : AnimationClip) : void
描述：从动画列表中移除剪辑。这将移除该剪辑及所有棘突它的动画状态。
◆ function RemoveClip (clipName : string) : void
描述：从动画列表中移除剪辑。这将移除指定名称的动画状态。
◆ function Rewind (name : string) : void
描述：回退名为name的动画。
//回退walk动画到开始
animation.Rewind("walk");
◆ function Rewind () : void
描述：回退所有动画。
//回退所有动画到开始
animation.Rewind();
◆ function Sample () : void
描述：在当前状态采样动画。如果想要设置一些动画状态，并采样一次，可以用这个。
//设置一些状态
animation["MyClip"].time = 2.0;
animation["MyClip"].enabled = true;
//采样动画
animation.Sample();
animation["MyClip"].enabled = false;
◆ function Stop () : void
描述：停止所有由这个Animation开始的动画。停止一个动画并回退到开始。
//终止所有动画
animation.Stop();
◆ function Stop (name : string) : void
描述：停止名为name的动画。停止一个动画并回退到开始。
//停止walk动画
animation.Stop ("walk");
◆ function SyncLayer (layer : int) : void
描述：同步所有在该层的动画的播放速度。当混合两个循环动画时，它们通常有不同长度。例如一个walk循环要比run更长。当混合它们时，你需要确保行走于跑循环中脚的位置相同。也就是说，动画的播放速度必须被调整一边动画同步。SyncLayer将给予它们的混合权值计算在该层上所有动画播放的平均诡异化速度，然后对该层上的动画使用播放速度。
//放置walk和run动画在同一层，并同步它们的速度
animation["walk"].layer = 1;
animation["run"].layer = 1;
animation.SyncLayer(1);
继承的成员
继承的变量 
enable 启用则Behaviour被更新，不启用则不更新
transform 附加到该GameObject的Transform（没有返回null）
rigidbody 附加到该GameObject的Rigidbody（没有返回null）
camera 附加到该GameObject的Camera（没有返回null）
light 附加到该GameObject的Light（没有返回null）
animation 附加到该GameObject的Animation（没有返回null）
constantForce 附加到该GameObject的ConstantForce（没有返回null）
renderer 附加到该GameObject的Renderer（没有返回null）
audio 附加到该GameObject的Audio（没有返回null）
guiText 附加到该GameObject的GuiText（没有返回null）
networkView 附加到该GameObject的NetworkView（没有返回null）
guiTexture 附加到该GameObject的GuiTexture（没有返回null）
collider 附加到该GameObject的Collider（没有返回null）
hingeJoint 附加到该GameObject的HingeJoint（没有返回null）
particleEmitter 附加到该GameObject的ParticleEmitter（没有返回null）
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetComponent 如果游戏附体上附加了一个，则返回type类组件，没有则返回null
GetComponentInChildren 如果该组件位于GameObject或任何其子物体上，返回type类组件，使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject或任何它的子物体上，返回type类组件。
GetComponents 返回GameObject上所有type类的组件
CompareTag 该游戏物体被是否被标签为tag？
SendMessageUpwards 在该游戏物体的每个MonoBehaviour和该行为的父对象上调用名为methodName的方法
SendMessage 在该游戏物体的每个MonoBehaviour上调用methodName方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour上调用methodName
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
AudioListener
类，继承自Behaviour。标示在三维空间中的侦听器。这个类可实现麦克风一样的设备。它记录周围的声音，并通过玩家的扬声器播, 放。在场景中只能有一个侦听器。参见组件参考中AudioSource,AudioListener,component。
变量
◆ var velocityUpdateMode : AudioVelocityUpdateMode
描述：可让你设置Audio Listener是否应该用固定或动态方式更新。如果你遇到了多普勒效应问题，请确保设置这个更新于Audio Listener的移动在同一循环内。如果它被附加到一个刚体，默认设置将自动设置该侦听器在固定的更新周期内更新，动态的以其他方式。
listener.velocityUpdateMode = AudioVelocityUpdateMode.Fixed;
类变量
◆ static var pause : bool
描述：音频的暂停状态。如果设置为真，该侦听器将不会产生声音。类似于设置音量为0.0
AudioListener.pause = true;
◆ static var volume : float
描述：控制游戏的音量。
AudioListener.volume = 0.5;
继承的成员
继承的变量 
enable 启用则Behaviour被更新，不启用则不更新
transform 附加到该GameObject的Transform（没有返回null）
rigidbody 附加到该GameObject的Rigidbody（没有返回null）
camera 附加到该GameObject的Camera（没有返回null）
light 附加到该GameObject的Light（没有返回null）
animation 附加到该GameObject的Animation（没有返回null）
constantForce 附加到该GameObject的ConstantForce（没有返回null）
renderer 附加到该GameObject的Renderer（没有返回null）
audio 附加到该GameObject的Audio（没有返回null）
guiText 附加到该GameObject的GuiText（没有返回null）
networkView 附加到该GameObject的NetworkView（没有返回null）
guiTexture 附加到该GameObject的GuiTexture（没有返回null）
collider 附加到该GameObject的Collider（没有返回null）
hingeJoint 附加到该GameObject的HingeJoint（没有返回null）
particleEmitter 附加到该GameObject的ParticleEmitter（没有返回null）
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetComponent 如果游戏附体上附加了一个，则返回type类组件，没有则返回null
GetComponentInChildren 如果该组件位于GameObject或任何其子物体上，返回type类组件，使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject或任何它的子物体上，返回type类组件。
GetComponents 返回GameObject上所有type类的组件
CompareTag 该游戏物体被是否被标签为tag？
SendMessageUpwards 在该游戏物体的每个MonoBehaviour和该行为的父对象上调用名为methodName的方法
SendMessage 在该游戏物体的每个MonoBehaviour上调用methodName方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour上调用methodName
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
AudioSource
类，继承自Behaviour。标示三位空间中的音频源。AudioSource被附加到GameObject以便在三位环境中播放声音。单声道声音以3D播放。为了播放三位声音，也需要一个AudioListener。音频侦听器通常附加在使用的相机上。立体声总是不以距离为基础衰减。你可以使用Play，Pause，Stop来播放音频剪辑。也可以再播放时使用volume属性调整音量，或者使用time来定位。多个声音可以使用PlayOneShot在一个AudioSource上播放。可以使用PlayClipAtPoint在三位空间中的一个静态位置播放剪辑。参见AudioListener，AudioClip，AudioSource component。
变量
◆ var clip : AudioClip
描述：默认播放的AudioClip。
var otherClip: AudioClip;
// 播放默认声音
audio.Play();
// 等待音频结束
yield WaitForSeconds (audio.clip.length);
// 指定其他音频并播放
audio.clip = otherClip;
audio.Play();
◆ var ignoreListenerVolume : bool
描述：这使音频源不考虑音频侦听器的音量。播放背景音乐时可启用这个。当播放背景音乐时，你希望音乐不受普通音量设置的影响，可以使用该变量。
audio.ignoreListenerVolume = true;
◆ var isPlaying : bool
描述：clip现在生意否在播放？
//当音频组件停止播放时，播放otherClip
var otherClip : AudioClip;

function Update (){
if (!audio.isPlaying) {
audio.clip = otherClip;
audio.Play();
}
}
◆ var loop : bool
描述：音频剪辑是否循环？如果你在一个正在播放的AudioSource上禁用循环，声音将在当前循环结束后停止。
// 停止声音循环
audio.loop = false;
◆ var maxVolume : float
描述：音频剪辑播放时的最大音量。不论你距离多近，声音不会比这个值更大。
audio.maxVolume = 0.5;
参见：minVolume, rolloffFactor.
◆ var minVolume : float
描述：音频剪辑播放时的最小音量。不论你距离多远，声音不会比这个还小。
audio.minVolume = 0.5;
参见：maxVolume, rolloffFactor.
◆ var pitch : float
描述：音频源的音调。
audio.pitch = 1.0;
◆ var playOnAwake : bool
描述：如果设置为真，音频源江在awake时自动播放。
if(! audio.playOnAwake) {
audio.Play();// 如果没有设置为Awake时播放，那么播放该剪辑
}
◆ var rolloffFactor : float
描述：设置声音衰减的速度。该值越大，侦听器必须更接近才能听到声音。
audio.rolloffFactor = 0.1;
参见：minVolume, maxVolume.
◆ var time : float
描述：以秒计算的播放位置。使用这个来读当前播放时间或寻找新的播放时间。
◆ var velocityUpdateMode : AudioVelocityUpdateMode
描述：Audio Source是否应该以固定或动态的方式更新？如果你遇到了这个源的多普勒效应问题，请确保设置这个更新与Audio Source的移动
在同一循环内。如果它被附加到一个刚体，默认设置将自动设置该源在固定的更新周期内更新，以动态的以及其他方式。
◆ var volume : float
描述：音频源的音量。
audio.volume = 0.2;
函数
◆ function Pause () : void
描述：暂停播放clip。
audio.Pause();
参见：Play，Stop函数
◆ function Play () : void
描述：播放clip。
audio.Play();
参见：Pause，Stop函数
◆ function PlayOneShot (clip : AudioClip, volumeScale : float = 1.0F) : void
描述：播放一个AudioClip。
//与其他物体碰撞时播放impact音频剪辑
var impact : AudioClip;
function OnCollisionEnter () {
audio.PlayOneShot(impact);
}
◆ function Stop () : void
描述：停止播放clip。
audio.Stop();
参见：Play，Pause函数
类方法
◆ static function PlayClipAtPoint (clip : AudioClip, position : Vector3, volume : float = 1.0F) : void
描述：在制定位置上播放剪辑。播放完成后自动消除音频源。正在播放的声音的音频源被返回。
//在制定位置播放clip
var clip : AudioClip;
AudioSource.PlayClipAtPoint(clip, Vector3 (5, 1, 2));
如果想进一步控制播放，可以使用下面代码。
var theClip : AudioClip;
PlayAudioClip(theClip, transform.position, 1);
function PlayAudioClip (clip : AudioClip, position : Vector3, volume : float)
{
var go = new GameObject ("One shot audio");
go.transform.position = position;
var source : AudioSource = go.AddComponent (AudioSource);
source.clip = clip;
source.volume = volume;
source.Play ();
Destroy (go, clip.length);
return source;
}
Destroy (go, clip.length);
return source;
}
继承的成员
继承的变量 
enable 启用则Behaviour被更新，不启用则不更新
transform 附加到该GameObject的Transform（没有返回null）
rigidbody 附加到该GameObject的Rigidbody（没有返回null）
camera 附加到该GameObject的Camera（没有返回null）
light 附加到该GameObject的Light（没有返回null）
animation 附加到该GameObject的Animation（没有返回null）
constantForce 附加到该GameObject的ConstantForce（没有返回null）
renderer 附加到该GameObject的Renderer（没有返回null）
audio 附加到该GameObject的Audio（没有返回null）
guiText 附加到该GameObject的GuiText（没有返回null）
networkView 附加到该GameObject的NetworkView（没有返回null）
guiTexture 附加到该GameObject的GuiTexture（没有返回null）
collider 附加到该GameObject的Collider（没有返回null）
hingeJoint 附加到该GameObject的HingeJoint（没有返回null）
particleEmitter 附加到该GameObject的ParticleEmitter（没有返回null）
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetComponent 如果游戏附体上附加了一个，则返回type类组件，没有则返回null
GetComponentInChildren 如果该组件位于GameObject或任何其子物体上，返回type类组件，使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject或任何它的子物体上，返回type类组件。
GetComponents 返回GameObject上所有type类的组件
CompareTag 该游戏物体被是否被标签为tag？
SendMessageUpwards 在该游戏物体的每个MonoBehaviour和该行为的父对象上调用名为methodName的方法
SendMessage 在该游戏物体的每个MonoBehaviour上调用methodName方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour上调用methodName
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
Camera
类，继承自Behaviour。Camera是一个设备，玩家通过它来看世界。屏幕空间点用像素定义。屏幕左下为(0,0)；右上是(pixelWidth.pixelHeight)。z的位置是以世界单位衡量到相机的距离。视口空间点是归一化的并且是相对于相机的。相机左下为(0,0)；右上是(1,1)。z的位置是以世界单位衡量到相机的距离。世界空间点是以全局坐标定义的（例如Transform.position）。
参见：camera component
变量
◆ var aspect : float
描述：长宽比（宽度除以高度）。默认的长宽比是从屏幕的长宽比计算得到的，即使相机没有被渲染到全屏。如果修改了相机的aspect比，这个值将保持到你调用camera.ResetAspect()；这将充值猖狂比为屏幕的长宽比。
if(camera.aspect > 1.0)
print ("Screen is more wide than tall!");
else
print ("Screen is more tall than wide!");
参见：camera component，Screen类。
◆ var backgroundColor : Color
描述：屏幕将被清理未这个颜色。只能在clearFlags被设置为CameraClearFlags.SolidColor（或设置为CameraClearFlags.Skybox但没有设置天空盒）时使用。
//来回变化背景色
var color1 = Color.red;
var color2 = Color.blue;
var duration = 3.0;
//设置清楚标记为该颜色
camera.clearFlags = CameraClearFlags.SolidColor;
function Update () {
var t = Mathf.PingPong (Time.time, duration) / duration;
camera.backgroundColor = Color.Lerp (color1, color2, t);
}
参见：camera component,Camera.clearFlags属性。
◆ var cameraToWorldMatrix : Matrix4x4
描述：从相机空间到世界空间的变换矩阵（只读）。使用次变量计算相机空间中的一个点在世界坐标中的什么位置。注意相机空间与openGL的约定相同。相机前味z轴负方向。这不同于Unity的约定，向前微z轴争相。
//以distance单位，沿着相机所看到的方向，在屏幕中绘制一个黄色的球，
var distance = -1.0;
function OnDrawGizmosSelected () {
var m = camera.cameraToWorldMatrix;
var p = m.MultiplyPoint (Vector3(0,0,distance));
Gizmos.color = Color.yellow;
Gizmos.DrawSphere (p, 0.2);
}
◆ var clearFlags : CameraClearFlags
描述：相机如何清楚背景。可以是CameraClearFlags.Skybox，CameraClearFlags.SolidColor，CameraClearFlags.Depth，CameraClearFlags.Nothing。
//用背景色清除（忽略天空盒）
camera.clearFlags = CameraClearFlags.SolidColor;
◆ var cullingMask : int
描述：这个用来选择性的渲染部分场景。如果GameObject的layerMask与相机的cullingMask进行AND操作后为0，则这个游戏物体对于该相机是不可见的。参考Layers获取更多信息。
//只渲染在第一层中的物体（默认层）
camera.cullingMask = 1 << 0;
参见：camera component
◆ var depth : float
描述：相机在渲染顺序上的深度。具有较低深度的相机将在较高深度的相机之前渲染。如果有多个相机并其中一些不需要覆盖整个屏幕，可以使用这个来控制相机的绘制次序。
//设置该相机在主相机之后渲染
camera.depth = Camera.main.depth + 1;
参见：camera component，Camera.rect属性
◆ var farClipPlane : float
描述：远裁剪面的距离。
camera.farClipPlane = 100.0;
参见：camera component
◆ var fieldOfView : float
描述：相机的视野，以度为党委。这是垂直视野。水平FOV取决于视口的宽高比。当相机是正交时，fieldOfView被忽略。（参考orthographic）。
//设置附加到同一个游戏物体上的相机的FOV位60
camera.fieldOfView = 60;
//设置主相机的视野为80
Camera.main.fieldOfView = 80;
参见：camera component
◆ var nearClipPlane : float
描述：近才见面的距离。
camera.nearClipPlane = 0.1;
参见：camera component
◆ var orthographic : bool
描述：相机是正交的（true）还是透视的（false）？如果orthographic为true，相机的视野由orthographicSize定义。如果orthographic为false，相机的视野由fieldOfView定义。
//设置相机为正交
camera.orthographic = true;
//设置主相机为正交
Camera.main.orthographic = true;
参见：camera component
◆ var orthographicSize : float
描述：在正交模式下相机的一半尺寸。这个为视体垂直大小的一半。相机不是正交时，水平视大小拒绝于视口的长宽比。
//设置相机的正交尺寸为5
camera.orthographic = true;
camera.orthographicSize = 5;
//设置主相机的正交尺寸为5
Camera.main.orthographic = true;
Camera.main.orthographicSize = 5;
参见：camera component
◆ var pixelHeight : float
描述：相机的像素高度（只读）。
print ("Camera is " + camera.pixelHeight + " pixels high");
◆ var pixelRect : Rect
描述：相机被渲染到屏幕像素坐标中的位置。
function Update () {
var r = camera.pixelRect;
print ("Camera displays from " + r.xMin + " to " + r.xMax + " pixel");
}
◆ var pixelWidth : float
描述。相机的像素宽度（只读）。
print ("Camera is " + camera.pixelWidth + " pixels wide");
◆ var projectionMatrix : Matrix4x4
描述：设置自动以的投影矩阵。如果你改变该矩阵，相机的渲染将不再给予它的fieldOfView更新，直到调用到ResetProjectionMatrix。只有当真正需要一个非标准的投影时，才使用自定义投影。该属性被Unity的水渲染使用来设置一个oblique.projection矩阵。使用自定义投影需要了解变换和投影矩阵。
//让相机以有节奏的方式晃动
var originalProjection : Matrix4x4;
originalProjection = camera.projectionMatrix;
function Update () {
var p = originalProjection;
//改变原始矩阵的某些值
p.m01 += Mathf.Sin (Time.time * 1.2) * 0.1;
p.m10 += Mathf.Sin (Time.time * 1.5) * 0.1;
camera.projectionMatrix = p;
}
//设置一个变异中心的投影，这里透视的消失点没有必要在屏幕的中心。left/right/top/bottom定义近裁剪面大小。例如相机的近裁剪面偏移中心的距离，改变该值就可以看到相机视图的变化。
@script ExecuteInEditMode
var left = -0.2;
var right = 0.2;
var top = 0.2;
var bottom = -0.2;
function LateUpdate () {
var cam = camera;
var m = PerspectiveOffCenter(left, right, bottom, top,cam.nearClipPlane, cam.farClipPlane );
cam.projectionMatrix = m;
}
static function PerspectiveOffCenter(left : float, right : float,bottom : float, top : float,near : float, far : float ) : Matrix4x4{ 
var x = (2.0 * near) / (right - left);
var y = (2.0 * near) / (top - bottom);
var a = (right + left) / (right - left);
var b = (top + bottom) / (top - bottom);
var c = -(far + near) / (far - near);
var d = -(2.0 * far * near) / (far - near);
var e = -1.0;
var m : Matrix4x4;
m[0,0] = x; m[0,1] = 0; m[0,2] = a; 
m[0,3] = 0;
m[1,0] = 0; m[1,1] = y; m[1,2] = b; m[1,3] = 0;
m[2,0] = 0; 
m[2,1] = 0; m[2,2] = c; m[2,3] = d;
m[3,0] = 0; m[3,1] = 0; m[3,2] = e; 
m[3,3] = 0;
return m;
}
◆ var rect : Rect
描述：相机被渲染到屏幕归一化坐标中的位置。rect的范围从0（左/下）到1（右/上）。
//每次按下空格键时改变视口宽度
function Update () {
if (Input.GetButtonDown ("Jump")) {
//随机选择边缘
var margin = Random.Range (0.0, 0.3);
//设置矩形
camera.rect = Rect (margin, 0, 1 - margin * 2, 1);
}
}
◆ var targetTexture : RenderTexture
描述：目标渲染纹理（只限UnityPro）。
◆ var velocity : Vector3
描述：获取世界空间中相机的速度（只读）这是相机在上一帧以秒为单位的运动。
function Update () {
print ("Camera moving at " + camera.velocity.magnitude + " m/s");
}
◆ var worldToCameraMatrix : Matrix4x4
描述：从世界到相机空间的变换矩阵。用这个计算物体的相机空间位置或提供自定义相机的位置。这个位置不是基于变化的。注意相机空间与openGL的约定相同：相机的前面为Z轴负方向。这不同于Unity的约定，向前微Z轴争相。如果你改变该矩阵，相机的渲染将不再基于它的Transform更新。知道调用ResetWorldToCameraMatrix。
//从offset位置偏移相机的渲染
var offset = Vector3 (0,1,0);
function LateUpdate () {
//构建一个沿着Z轴偏移与镜像的矩阵。因为相机已经为Z轴镜像，并用于其余部分
var camoffset = Vector3 (-offset.x, -offset.y, offset.z);
var m = Matrix4x4.TRS (camoffset, Quaternion.identity, Vector3 (1,1,-1));
//重载worldToCameraMatrix为偏移镜像变换矩阵
camera.worldToCameraMatrix = m * transform.worldToLocalMatrix;
}
函数
◆ function CopyFrom (other : Camera) : void
描述：使该相机的设置于其他相机相同。这将从er相机拷贝到所有相机变量（视野，清楚标记，裁剪蒙版）。这也将使相机的变换与other相机相同，相机的层也与other相机相同。在做自定义渲染效果的时候，这可以用来设置一台具有与其他相机设置完全相同的相机。例如在使用RenderWithShader时。
◆ function Render : void
描述：手动渲染相机。这个将使用相机的清除标记，目标纹理和所有其他设置。相机将发送OnPreCull，OnPreRender和OnPostRender到任何附加的脚本上，并渲染任何最后的图像滤镜。这个用来精确的控制渲染次序，为了使用这个特性，创建一个相机并禁用它。然后在它上面调用Render。参见：RenderWithShader。
◆ function RenderToCubemap (cubemap : Cubemap, faceMask : int = 63) : bool
描述：从这个相机渲染到一个立方贴图。这个是非常有用的。可以再编辑器中烘焙场景的静态立方贴图。参考下面的想到实例。相机的位置，清除标志和裁剪面距离将被使用来渲染到立方贴图表面。faceMask是一个比特域，标示哪个立方贴图面应该被渲染。每个位对应于一个面。比特数是CubemapFace枚举的整型值。默认的所有六个立方贴图面都将被渲染（默认值63最低的6位是打开的）。如果渲染失败，这个函数将返回false。某些显卡不支持这个函数。参见：Cubemap assets，Reflective shaders。
//从给定的点渲染场景到以静态立方贴图放置这个脚本到工程的Editor文件夹中，然后用一个Reflective shader来使用立方贴图
class RenderCubemapWizard extends ScriptableWizard{
var renderFromPosition : Transform;
var cubemap : Cubemap;
function OnWizardUpdate () {
helpString = "Select transform to render from and cubemap to render into";
isValid = (renderFromPosition != null) && (cubemap != null);
}
function OnWizardCreate () {
//为渲染创建临时相机
var go = new GameObject( "CubemapCamera", Camera );//放置到物体上
go.transform.position = renderFromPosition.position;
go.transform.rotation = Quaternion.identity;
//渲染到立方贴图
go.camera.RenderToCubemap( cubemap );
//销毁临时相机
DestroyImmediate( go );
}
@MenuItem("GameObject/Render into Cubemap")
static function RenderCubemap () {
ScriptableWizard.DisplayWizard(
"Render cubemap", RenderCubemapWizard, "Render!");
}
}
◆ function RenderToCubemap (cubemap : RenderTexture, faceMask : int = 63) : bool
描述：从这个相机渲染到一个立方贴图。用于实时反射到立方贴图渲染纹理，也是非常耗时的，尤其是所有六个立方贴图面在每一帧中都被渲染。相机的位置，清楚标志和裁剪面距离将被使用来渲染到立方贴图表面。faceMask是一
个比特域，标示哪个立方贴图面应该被渲染。每个位对应于一个面。比特数是CubemapFace枚举的整型值。默认的所有六个正方贴图面都将被渲染（默认值63的最低6位是打开的）。如果渲染失败该函数会返回false。某些显卡不支持该函数。参加：RenderTexture.isCubemap, Reflective shaders。
//将该脚本附加到使用了Reflective shader的物体上实时反射立方贴图
script ExecuteInEditMode
var cubemapSize = 128;
var oneFacePerFrame = false;
private var cam : Camera;
private var rtex : RenderTexture;
function Start () {
//启动时渲染所有6个面
UpdateCubemap( 63 );
}
function LateUpdate () {
if (oneFacePerFrame) {
var faceToRender = Time.frameCount % 6;
var faceMask = 1 << faceToRender;
UpdateCubemap (faceMask);
} 
else {
UpdateCubemap (63); //所有6个面
}
}
function UpdateCubemap (faceMask : int) {
if (!cam) {
var go = new GameObject ("CubemapCamera", Camera);
go.hideFlags = HideFlags.HideAndDontSave;
go.transform.position = transform.position;
go.transform.rotation = Quaternion.identity;
cam = go.camera;
cam.farClipPlane = 100; //不渲染较远的部分
cam.enabled = false;
}
if (!rtex) { 
rtex = new RenderTexture (cubemapSize, cubemapSize, 16);
rtex.isPowerOfTwo = true;
rtex.isCubemap = true;
rtex.hideFlags = HideFlags.HideAndDontSave;
renderer.sharedMaterial.SetTexture ("_Cube", rtex);
}
cam.transform.position = transform.position;
cam.RenderToCubemap (rtex, faceMask);
}
function OnDisable () {
DestroyImmediate (cam);
DestroyImmediate (rtex);
}
◆ function RenderWithShader (shader : Shader, replacementTag : string) : void
描述：用shader替换渲染相机。参考Rendering with Replaced Shaders获取细节。此函数将渲染相机。这将使相机的的清除标记、目标纹理和所有其他设置。这个相机不会发送OnPreCull, OnPreRender 或者 OnPostRender到已附加的脚本上。
图像滤镜 
也不会被渲染。该函数可以用于特效，例如渲染整个场景屏幕空间缓冲，热效果等。为了使用该特性，创建一个相机并禁用它。然后在它上面调用RenderWithShader。参见：Rendering with Replaced Shaders, SetReplacementShader, Render。
◆ function ResetAspect () : void
描述：返回猖狂比为屏幕的长宽比。调用这个结束aspect的效果。
camera.ResetAspect();
◆ function ResetProjectionMatrix () : void
描述：让投影反映正常的相机参数。调用这个结束projectionMatrix的效果。
camera.ResetProjectionMatrix();
◆ function ResetReplacementShader () : void
描述：从相机上移除shader替换。调用这个结束SetReplacementShader效果。
◆ function ResetWorldToCameraMatrix () : void
描述：在场景中让渲染位置反映相机位置。调用这个结束worldToCameraMatrix的效果。
camera.ResetWorldToCameraMatrix();
◆ function ScreenPointToRay (position : Vector3) : Ray
描述：返回从相机出发，穿过屏幕点的一个射线。产生的射线是在世界空间中，从相机的近裁剪面开始并穿过屏幕position(x,y)像素坐标（position.z被忽略）。屏幕空间以像素定义。屏幕的左下为(0,0)；右上是(pixelWidth,pixelHeight)。
//在屏幕视图中绘制一条线，穿过一个到屏幕左下角200像素的点
function Update () {
var ray = camera.ScreenPointToRay (Vector3(200,200,0));
Debug.DrawRay (ray.origin, ray.direction * 10, Color.yellow);
}
◆ function ScreenToViewportPoint (position : Vector3) : Vector3
描述：从屏幕空间到视口空间变换position。屏幕空间以像素定义。屏幕的左下为(0,0)；右上是(pixelWidth,pixelHeight)。z的位置是以世界单位衡量的刀相机的距离。视口空间是归一化的并相对于相机的。相机的左下为(0,0)；右上是(1,1)。z的位置是以世界单位衡量的刀相机的距离。
◆ function ScreenToWorldPoint (position : Vector3) : Vector3
描述：从屏幕空间到世界空间变换position。屏幕空间以像素定义。屏幕的左下为(0,0)；右上是(pixelWidth,pixelHeight)。z的位置是以世界单位衡量的到相机的距离。
//在所选相机的近裁剪面上绘制一个黄色的球，在离左下100像素的位置
function OnDrawGizmosSelected () {
var p = camera.ScreenToWorldPoint (Vector3 (100,100,camera.nearClipPlane));
Gizmos.color = Color.yellow;
Gizmos.DrawSphere (p, 0.1);
}
◆ function SetReplacementShader (shader : Shader, replacementTag : string) : void
描述：使相机用shader替换来渲染。参考Rendering with Replaced Shaders。调用该函数后，相机将使用替换的shader来渲染它的视图。调用ResetReplacementShader来重置为普通渲染。参见：Rendering with Replaced Shaders, ResetReplacementShader, RenderWithShader。
◆ function ViewportPointToRay (position : Vector3) : Ray
描述：返回从相机出发穿过视点的一个射线。产生的射线是在世界空间中，从相机的近裁剪面开始并穿过视口position(x,y)坐标（position.z被忽略）。视口坐标是归一化的并相对于相机的。相机的左下为(0,0)；右上为(1,1)。
//打印相机直接看到的物体名称
function Update () {
//获取穿过屏幕中心的射线
var ray = camera.ViewportPointToRay (Vector3(0.5,0.5,0));
//投射
var hit : RaycastHit;
if (Physics.Raycast (ray, hit)) {
print ("I'm looking at " + hit.transform.name);
} 
else {
print ("I'm looking at nothing!");
}
}
◆ function ViewportToScreenPoint (position : Vector3) : Vector3
描述：从视口空间到屏幕空间变换position。视口空间是归一化的并相对于相机的。相机的左下为(0,0)；右上为(1,1)。z的位置是以世界单位衡量的刀相机的距离。屏幕空间以像素定义。屏幕左下为(0,0；右上为(pixelWidth,pixelHeight)。z的位置是以世界单位衡量的到相机的距离。
◆ function ViewportToWorldPoint (position : Vector3) : Vector3
描述：从视口空间到屏幕空间变换position。视口空间是归一化的并相对于相机的。相机的左下为(0,0)；右上为(1,1)。z的位置是以世界单位衡量的刀相机的距离。屏幕空间以像素定义。屏幕左下为(0,0；右上为(pixelWidth,pixelHeight)。z的位置是以世界单位衡量的到相机的距离。
//在进裁剪面的右上角，针对在场景视图中选中的相机绘制一个黄色的球
function OnDrawGizmosSelected () {
var p = camera.ViewportToWorldPoint (Vector3 (1,1, camera.nearClipPlane));
Gizmos.color = Color.yellow;
Gizmos.DrawSphere (p, 0.1);
}
◆ function WorldToScreenPoint (position : Vector3) : Vector3
描述：从世界空间到屏幕空间变换position。屏幕空间以像素定义。屏幕的左下为(0,0；右上为(pixelWidth,pixelHeight)。z的位置是 
以世界单位衡量的刀相机的距离。
var target : Transform;
function Update () {
var screenPos = camera.WorldToScreenPoint (target.position);
print ("target is " + screenPos.x + " pixels from the left");
}
◆ function WorldToViewportPoint (position : Vector3) : Vector3
描述：从世界空间到视口空间变换position。视口空间是归一化的并相对于相机的。相机的左下为(0,0)；右上为(1,1)。z的位置是以世界单位衡量的到相机的距离。
//找出target在屏幕的左边还是右边
var target : Transform;
function Update () {
var viewPos = camera.WorldToViewportPoint (target.position);
//视口坐标范围从0到1
if( viewPos.x > 0.5 )
print ("target is on the right side!");
else
print ("target is on the left side!");
}
消息传递
◆ function OnPostRender () : void
描述：OnPostRender在相机渲染场景之后调用。这个消息被发送到所有附加在相机上的脚本。
◆ function OnPreCull () : void
描述：OnPreCull在相机开始裁剪场景之前调用。OnPreCull仅仅在这个过程之间被调用。这个消息被发送到所有附加在相机上的脚本。如果你想改变相机的视觉参数（例如，fieldOfView或者仅仅是变换），就在这里做这个。场景物体的可见性将给予相机的参数在OnPreCull之后确定。
◆ function OnPreRender () : void
描述：OnPreCull在相机开始渲染场景之前调用。这个消息被发送到所有附加在相机上的脚本。注意如果你在这里改变了相机的视野参数（例如fieldOfView），它们将只影响下一帧。用OnPreCull代替。
◆ function OnRenderImage (source : RenderTexture, destination : RenderTexture) : void
描述：OnRenderImage在所有渲染完成后被调用，来渲染图片的后记处理效果（仅限UnityPro）。该函数允许使用给予shader的过滤器来处理最后的图片。进入的图片是source渲染纹理。结果是destination渲染纹理。当多个图片过滤器附加在相机上时，它们序列化的处理图片，将第一个过滤器的目标作为下一个过滤器的源。
该消息被发送到所有附加在相机上的脚本。参见：UnityPro中的image effects。
◆ function OnRenderObject (queueIndex : int) : void
描述：该函数被用来渲染你自己的物体，使用Graphics.DrawMeshNow或者其他函数。queueIndex指定用来渲染物体的render queue。可以使用RenderBeforeQueues属性来指定你想绘制这个物体到哪个渲染队列。
◆ function OnWillRenderObject () : void
描述：如果物体可见，每个相机都会调用OnWillRenderObject。该函数在裁剪过程中被调用。可用该函数创建具有依赖性的渲染纹理。只有在被渲染的物体可见时，才更新该渲染纹理。例如，水组件就使用了这个。Camera.current将被设置为要渲染这个物体的相机。
类变量
◆ static var allCameras : Camera[]
描述：返回场景中所有启用的相机。
var count = Camera.allCameras.length;
print ("We've got " + count + " cameras");
◆ static var current : Camera
描述：当前用于渲染的相机，只用于低级的渲染控制（只读）。多数时候你会使用Camera.main。只有在执行下面时间的时候使用该函数：MonoBehaviour.OnRenderImage, MonoBehaviour.OnPreRender, MonoBehaviour.OnPostRender。
◆ static var main : Camera
描述：第一个启用的被标记为“MainCamera”的相机（只读）。如果场景中没有这个相机返回null。
继承的成员
继承的变量 
enable 启用则Behaviour被更新，不启用则不更新
transform 附加到该GameObject的Transform（没有返回null）
rigidbody 附加到该GameObject的Rigidbody（没有返回null）
camera 附加到该GameObject的Camera（没有返回null）
light 附加到该GameObject的Light（没有返回null）
animation 附加到该GameObject的Animation（没有返回null）
constantForce 附加到该GameObject的ConstantForce（没有返回null）
renderer 附加到该GameObject的Renderer（没有返回null）
audio 附加到该GameObject的Audio（没有返回null）
guiText 附加到该GameObject的GuiText（没有返回null）
networkView 附加到该GameObject的NetworkView（没有返回null）
guiTexture 附加到该GameObject的GuiTexture（没有返回null）
collider 附加到该GameObject的Collider（没有返回null）
hingeJoint 附加到该GameObject的HingeJoint（没有返回null）
particleEmitter 附加到该GameObject的ParticleEmitter（没有返回null）
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetComponent 如果游戏附体上附加了一个，则返回type类组件，没有则返回null
GetComponentInChildren 如果该组件位于GameObject或任何其子物体上，返回type类组件，使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject或任何它的子物体上，返回type类组件。
GetComponents 返回GameObject上所有type类的组件
CompareTag 该游戏物体被是否被标签为tag？
SendMessageUpwards 在该游戏物体的每个MonoBehaviour和该行为的父对象上调用名为methodName的方法
SendMessage 在该游戏物体的每个MonoBehaviour上调用methodName方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour上调用methodName
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
ConstantForce
类，继承自Behaviour。一个不间断的力。这是一个小的物理工具类，用来将一个连续的力应用到一个物体上。Rigidbody.AddForce只在一帧中应用力道Rigidbody，因此你不得不持续调用这个函数。
领以方面ConstantForce将在每一帧中应用这个力，知道改变这个力或例举为一个新的值。参见Rigidbody。
变量
◆ var force : Vector3
描述：这个力在每帧中应用到刚体。
//在世界坐标系中向上移动刚体。
constantForce.force = Vector3.up * 10;
◆ var relativeForce : Vector3
描述：力-相对于刚体坐标系统-在每帧中应用。
//向前移动刚体。
constantForce.relativeForce = Vector3.forward * 10;
◆ var relativeTorque : Vector3
描述：力矩-相对于刚体坐标系统-在每帧中应用。
//绕着其X轴旋转该物体。
constantForce.relativeTorque = Vector3.right * 2;
◆ var torque : Vector3
描述：这个力矩在每帧中应用到刚体。
//绕着世界的Y轴旋转该物体。
constantForce.torque = Vector3.up * 2;
继承的成员
继承的变量 
enable 启用则Behaviour被更新，不启用则不更新
transform 附加到该GameObject的Transform（没有返回null）
rigidbody 附加到该GameObject的Rigidbody（没有返回null）
camera 附加到该GameObject的Camera（没有返回null）
light 附加到该GameObject的Light（没有返回null）
animation 附加到该GameObject的Animation（没有返回null）
constantForce 附加到该GameObject的ConstantForce（没有返回null）
renderer 附加到该GameObject的Renderer（没有返回null）
audio 附加到该GameObject的Audio（没有返回null）
guiText 附加到该GameObject的GuiText（没有返回null）
networkView 附加到该GameObject的NetworkView（没有返回null）
guiTexture 附加到该GameObject的GuiTexture（没有返回null）
collider 附加到该GameObject的Collider（没有返回null）
hingeJoint 附加到该GameObject的HingeJoint（没有返回null）
particleEmitter 附加到该GameObject的ParticleEmitter（没有返回null）
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetComponent 如果游戏附体上附加了一个，则返回type类组件，没有则返回null
GetComponentInChildren 如果该组件位于GameObject或任何其子物体上，返回type类组件，使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject或任何它的子物体上，返回type类组件。
GetComponents 返回GameObject上所有type类的组件
CompareTag 该游戏物体被是否被标签为tag？
SendMessageUpwards 在该游戏物体的每个MonoBehaviour和该行为的父对象上调用名为methodName的方法
SendMessage 在该游戏物体的每个MonoBehaviour上调用methodName方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour上调用methodName
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
GUIElement
类，继承自Behaviour。用于显示在GUI上的图片和文本字符串的基类。这个类处理所有GUI元素的基本功能。
函数
◆ function GetScreenRect (camera : Camera = null) : Rect
描述：在屏幕坐标返回GUIElement的包围矩阵。如果没有camera被指定，一个填充整个游戏窗口的相机将被使用。
function Start () {
var r = guiTexture.GetScreenRect ();
print ("This gui element is %d pixel wide.",r.width);
var r = guiText.GetScreenRect();
print ("This gui element is %d pixel wide.",r.width);
}
◆ function HitTest (screenPosition : Vector3, camera : Camera = null) : bool
描述：屏幕上的点在是否在元素内部？如果screenPositon包含在这个GUIElement内部时返回真，screenPosition以屏幕坐标指定，例如由Input.mousePosition属性返回的值。如果没有camera被指定，一个填充整个游戏窗口的相机将被使用。注意，如果位置在元素内部，true将被返回。即使游戏物体属于Ignore Raycast层（通常鼠标事件不会发送到Ignore Raycast物体）。参见GUILayer.HitTest。
if (guiTexture.HitTest (Vector3 (360, 450, 0.)))
print ("This gui texture covers pixel 360, 450");
if (guiText.HitTest (Vector3(360, 450, 0.)))
print ("This gui texture covers pixel 360, 450");
继承的成员
继承的变量 
enable 启用则Behaviour被更新，不启用则不更新
transform 附加到该GameObject的Transform（没有返回null）
rigidbody 附加到该GameObject的Rigidbody（没有返回null）
camera 附加到该GameObject的Camera（没有返回null）
light 附加到该GameObject的Light（没有返回null）
animation 附加到该GameObject的Animation（没有返回null）
constantForce 附加到该GameObject的ConstantForce（没有返回null）
renderer 附加到该GameObject的Renderer（没有返回null）
audio 附加到该GameObject的Audio（没有返回null）
guiText 附加到该GameObject的GuiText（没有返回null）
networkView 附加到该GameObject的NetworkView（没有返回null）
guiTexture 附加到该GameObject的GuiTexture（没有返回null）
collider 附加到该GameObject的Collider（没有返回null）
hingeJoint 附加到该GameObject的HingeJoint（没有返回null）
particleEmitter 附加到该GameObject的ParticleEmitter（没有返回null）
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetComponent 如果游戏附体上附加了一个，则返回type类组件，没有则返回null
GetComponentInChildren 如果该组件位于GameObject或任何其子物体上，返回type类组件，使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject或任何它的子物体上，返回type类组件。
GetComponents 返回GameObject上所有type类的组件
CompareTag 该游戏物体被是否被标签为tag？
SendMessageUpwards 在该游戏物体的每个MonoBehaviour和该行为的父对象上调用名为methodName的方法
SendMessage 在该游戏物体的每个MonoBehaviour上调用methodName方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour上调用methodName
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
GUIText
类，继承自GUIElement。显示在一个GUI中的文本字符。
变量
◆ var alignment : TextAlignment
描述：文本的对齐。
guiText.alignment = TextAlignment.Left;
◆ var anchor : TextAnchor
描述：文本的锚点。
guiText.anchor = TextAnchor.MiddleCenter;
◆ var font : Font
描述：用于文本的字体。
var font : Font;
guiText.font = font;
◆ var lineSpaceing : float
描述：行间距倍数。这个可以使被定义在字体中行间距增加。
//双倍行间距
guiText.lineSpacing = 2.0;
◆ var material : Material
描述：用于渲染的Material。赋予一个新的材质来改变渲染处理。改变这个材质来改变渲染的字体。如果赋值null到material，将使用内置基本字体。
//改变这个材质显示绿色文本。
guiText.material.color = Color.green;
参见：font variable
◆ var pixelOffset : Vector2
描述：文本的像素偏移。文本从它的原始位置偏移的量。
guiText.pixelOffset = Vector2 (10, 10);
◆ var tabSize : float
描述：这个标签增加的宽度。
guiText.tabSize = 4.0;
◆ var text : string
描述：需要显示的文本。
GUITexture
类，继承自GUIElement。用于2D GUI的纹理图片。
变量
◆ var color : Color
描述：GUI纹理的颜色。
//改变纹理的颜色为绿色
guiTexture.color = Color.green;
◆ var pixelInset : Rect
描述：pixellnset用来调整尺寸和位置。为了使GUI纹理总是原始大小，设置transform.localScale为Vector3.zero。
transform.position = Vector3.zero;
transform.localScale = Vector3.zero;
guiTexture.pixelInset = Rect (50, 50, 100, 100);
◆ var texture : Texture
描述：用于绘制的纹理。
//将someTexture赋值给guiTexture。
var someTexture : Texture2D;
guiTexture.texture = someTexture; 
继承的成员
继承的变量 
enable 启用则Behaviour被更新，不启用则不更新
transform 附加到该GameObject的Transform（没有返回null）
rigidbody 附加到该GameObject的Rigidbody（没有返回null）
camera 附加到该GameObject的Camera（没有返回null）
light 附加到该GameObject的Light（没有返回null）
animation 附加到该GameObject的Animation（没有返回null）
constantForce 附加到该GameObject的ConstantForce（没有返回null）
renderer 附加到该GameObject的Renderer（没有返回null）
audio 附加到该GameObject的Audio（没有返回null）
guiText 附加到该GameObject的GuiText（没有返回null）
networkView 附加到该GameObject的NetworkView（没有返回null）
guiTexture 附加到该GameObject的GuiTexture（没有返回null）
collider 附加到该GameObject的Collider（没有返回null）
hingeJoint 附加到该GameObject的HingeJoint（没有返回null）
particleEmitter 附加到该GameObject的ParticleEmitter（没有返回null）
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetComponent 如果游戏附体上附加了一个，则返回type类组件，没有则返回null
GetComponentInChildren 如果该组件位于GameObject或任何其子物体上，返回type类组件，使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject或任何它的子物体上，返回type类组件。
GetComponents 返回GameObject上所有type类的组件
CompareTag 该游戏物体被是否被标签为tag？
SendMessageUpwards 在该游戏物体的每个MonoBehaviour和该行为的父对象上调用名为methodName的方法
SendMessage 在该游戏物体的每个MonoBehaviour上调用methodName方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour上调用methodName
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
GUILayer
类，继承自Behaviour。
函数
◆ function HitTest (screenPosition : Vector3) : GUIElement
描述：在屏幕的制定位置获取GUI元素。返回屏幕上指定点的GUIElement。如果screenPosition在某个GUIElement内部，那个元素将被返回。如果这个位置没有在任何GUI元素内部，返回null。输入Ignore Raycast层的GUI元素将被忽略，就像它们不存在。screenPosition在屏幕坐标系下，就像由Input.mousePosition属性返回的值。参见：GUIElement.HitTest，Input.mousePositon。
继承的成员
继承的变量 
enable 启用则Behaviour被更新，不启用则不更新
transform 附加到该GameObject的Transform（没有返回null）
rigidbody 附加到该GameObject的Rigidbody（没有返回null）
camera 附加到该GameObject的Camera（没有返回null）
light 附加到该GameObject的Light（没有返回null）
animation 附加到该GameObject的Animation（没有返回null）
constantForce 附加到该GameObject的ConstantForce（没有返回null）
renderer 附加到该GameObject的Renderer（没有返回null）
audio 附加到该GameObject的Audio（没有返回null）
guiText 附加到该GameObject的GuiText（没有返回null）
networkView 附加到该GameObject的NetworkView（没有返回null）
guiTexture 附加到该GameObject的GuiTexture（没有返回null）
collider 附加到该GameObject的Collider（没有返回null）
hingeJoint 附加到该GameObject的HingeJoint（没有返回null）
particleEmitter 附加到该GameObject的ParticleEmitter（没有返回null）
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetComponent 如果游戏附体上附加了一个，则返回type类组件，没有则返回null
GetComponentInChildren 如果该组件位于GameObject或任何其子物体上，返回type类组件，使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject或任何它的子物体上，返回type类组件。
GetComponents 返回GameObject上所有type类的组件
CompareTag 该游戏物体被是否被标签为tag？
SendMessageUpwards 在该游戏物体的每个MonoBehaviour和该行为的父对象上调用名为methodName的方法
SendMessage 在该游戏物体的每个MonoBehaviour上调用methodName方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour上调用methodName
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
LensFlare
类，继承自Behaviour。用于Lensflare组件的借口。这允许你在运行时改变镜头闪光的亮度和颜色。
变量
◆ var brightness : float
描述：闪光的强度。这个控制发光元素的尺寸和亮度。
参见：Lens flare component, flare assets。
◆ var color : Color
描述：闪光的颜色。这控制闪光元素的颜色（那些启用了use light color的）。
参见：Lens flare component, flare assets。
◆ var flare : Flare
描述：使用的flare asset。
参见：Lens flare component, flare assets。
继承的成员
继承的变量 
enable 启用则Behaviour被更新，不启用则不更新
transform 附加到该GameObject的Transform（没有返回null）
rigidbody 附加到该GameObject的Rigidbody（没有返回null）
camera 附加到该GameObject的Camera（没有返回null）
light 附加到该GameObject的Light（没有返回null）
animation 附加到该GameObject的Animation（没有返回null）
constantForce 附加到该GameObject的ConstantForce（没有返回null）
renderer 附加到该GameObject的Renderer（没有返回null）
audio 附加到该GameObject的Audio（没有返回null）
guiText 附加到该GameObject的GuiText（没有返回null）
networkView 附加到该GameObject的NetworkView（没有返回null）
guiTexture 附加到该GameObject的GuiTexture（没有返回null）
collider 附加到该GameObject的Collider（没有返回null）
hingeJoint 附加到该GameObject的HingeJoint（没有返回null）
particleEmitter 附加到该GameObject的ParticleEmitter（没有返回null）
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
GetComponent 如果游戏附体上附加了一个，则返回type类组件，没有则返回null
GetComponentInChildren 如果该组件位于GameObject或任何其子物体上，返回type类组件，使用深度优先搜索
GetComponentsInChildren 如果这些组件位于GameObject或任何它的子物体上，返回type类组件。
GetComponents 返回GameObject上所有type类的组件
CompareTag 该游戏物体被是否被标签为tag？
SendMessageUpwards 在该游戏物体的每个MonoBehaviour和该行为的父对象上调用名为methodName的方法
SendMessage 在该游戏物体的每个MonoBehaviour上调用methodName方法
BroadcastMessage 在这个游戏物体或其任何子物体上的每个MonoBehaviour上调用methodName
GetInstanceID 返回该物体的实例id
继承的类函数 
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体、组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代理。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator!= 比较两个物体是否不同。
DontDestroyOnLoad 加载新场景时确保目标物体不被自动销毁。
Light
类，继承自Behaviour。用于light components的脚本接口。使用这个来控制Unity光源的所有方面。这个属性完全与现实在监视面板中的值相同。通常光源都是在编辑器中创建，但是有时候需要从脚本中创建。
function Start () {
//制作一个游戏物体
var lightGameObject = new GameObject ("The Light");
//添加光源组件
lightGameObject.AddComponent (Light);
//设置颜色和位置
lightGameObject.light.color = Color.blue;
//在添加光照组件后，设置位置（或任何变换组件）
lightGameObject.transform.position = Vector3 (0, 5, 0);
}
变量
◆ var attenuate : bool
描述：光源是否随着距离衰减？对于Directional光源衰减总是关闭的。
//关闭光源衰减。
light.attenuate = false;
参见：Light component
◆ var color : Color
描述：光源的颜色。为了修改光源的强度你需要改变光源颜色的亮度。光源总是增加亮度，因此一个黑色的光源与没有光源相同。光源是否随着距离衰减？对于Directional光源衰减总是关闭的。
//在2秒内使颜色变黑。
function Update () {
light.color -= Color.white / 2.0 * Time.deltaTime;
}
//在2个颜色之间来回插值光源颜色。
var duration = 1.0;
var color0 = Color.red;
var color1 = Color.blue;
function Update () {
//设置光源颜色
var t = Mathf.PingPong (Time.time, duration) / duration;
light.color = Color.Lerp (color0, color1, t);
}
参见：Light component。
◆ var cookie : Texture
描述：被盖光源投影的cookie纹理。如果cookie是一个立方体贴图，光源将变为一个点光源。注意cookie只在像素光源下显示。
//在监视面板中公开一个纹理的引用
var newCookie : Texture2D;
//赋cookie
light.cookie = newCookie;
参见：Light component
◆ var cullingMask : int
描述：这个用来选择性的照亮部分场景。如果GameObject的layerMask与光源的cullingMask进行AND操作后为0.，那么这个游戏物体不能被这个光源照亮。参考Layers获取更多信息。
//只照亮第一层中的物体（默认层）
light.cullingMask = 1 << 0;
参见：Light component
◆ var flare : Flare
描述：为这个光源使用的flare asset。
//在监视面板中公开一个闪光的引用
var newFlare : Flare;
//赋值闪光
light.flare = newFlare;
参见：Light component和flare asset。
◆ var intensity : float
描述：光源的强度被光源的颜色乘。该值可以介于0~8之间。允许你创建明亮的灯光。
//随时间改变光照强度
var duration = 1.0;
function Update() {
//余弦理论
var phi = Time.time / duration * 2 * Mathf.PI;
//获取余弦，并将范围从-1~1变为0~1
var amplitude = Mathf.Cos( phi ) * 0.5 + 0.5;
//设置光的颜色
light.intensity = amplitude;
}
◆ var range : float
描述：光源的范围。
即使光源关闭了attenuate，它还是只影响在它范围内的物体。
//在原始范围与原始范围一般处变换光照范围
var duration = 3.0;
private var originalRange : float;
originalRange = light.range;
function Update() {
var amplitude = Mathf.PingPong( Time.time, duration );
//将0..持续时间改为0.5..1范围
amplitude = amplitude / duration * 0.5 + 0.5;
//设置光照范围
light.range = originalRange * amplitude;
}
参见：Light component。
◆ var renderMode : LightRenderMode
描述：如何渲染该光源？此处可以是LightRenderMode.Auto， LightRenderMode.ForceVertex 或 LightRenderMode.ForcePixel。像素光渲染比较慢但是看起来较好，尤其是对那些没有较高面数的几何体。一些效果（例如凹凸）只会在像素光照下显示。
//使光源只以点光照模式渲染
light.renderMode = LightRenderMode.ForceVertex;
参见：Light component
◆ var shadowConstantBias : float
描述：阴影偏移常量。
参见：shadows，shadowObjectSizeBias。
◆ var shadowSizeBias : float
描述：阴影偏移常量。
参见：shadows，shadowConstantBias。
◆ var shadows : LightShadows
描述：这个光源是否投射阴影？
//设置光源为投射硬阴影
light.shadows = LightShadows.Hard;
参见：LightShadows, shadowStrength property, Renderer.castShadows, Renderer.receiveShadows
◆ var shadowStrength : float
描述：光源阴影的强度？
//使光源的阴影非常弱
light.shadowStrength = 0.3;
参见：shadows property, Renderer.castShadows, Renderer.receiveShadows。
◆ var spotAngle : float
描述：光源的投射光角度。主要用于Spot光源。改变Directional光源的cookie尺寸。对Point光源没有影响。
//在”minAngle”与”maxAngle”之间随机改变投射角度
//每’interval’秒改变一次.
var interval=0.3;
var minAngle=10;
var maxAngle=90;
private var timeLeft:float;
teimleft=interval;
light.type=LightType.Spot;
function Update()
{
 timeLeft=Time.deltaTime;
if(timeLeft<0.0){
 //开始改变
timeLeft=interval;
light.spotAngle=Random Range(minAngle,maxAngle);
};
}
参见：Light component
? var type：LightType
描述：光源的类型
可以是LightType.Spot,LightType.Directional,LightType.Point.
//制作一个投射光源
Light.type=LightType.Spot;
参见：Light component
继承的成员
继承的变量
Enabled 启用Behaviours被更新，禁用Behaviours不被更新。
Transform附加到这个GameObject的Transform（如果没有为null）。
Rigidbody附加到这个GameObject的Rigidbody（如果没有为null）。
Camera 附加到这个GameObject的Camera（如果没有为null）。
Light  附加到这个GameObject的Light（如果没有为null）。
Animation附加到这个GameObject的Animation（如果没有为null）。
constantForce附加到这个GameObject的ConstantForce（如果没有为null）。
Renderer 附加到这个GameObject的Renderer（如果没有为null）。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView附加到这个GameObject的NetworkView（如果没有为null）。
Collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag  这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改？
继承的函数
GetComponet返回type类型的组件，如果游戏物体上附加一个，如果没有返
                      回null。
GetComponentInchildren 返回type类型的组件，这个组件位于GameObject或者任何它的子物体上，使用深度优先搜索。
GetComponentsInchildren 返回所有type类型的组件，这些组件位于GameObject或者任何它的子物体上。
GetComponets返回Gameobject所有type类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards  在这游戏物体的每个MonoBehaviour和该行为的组先上调用名为methodName方法。
SendMessage 在这游戏物体的每个MonoBehaviour上调用名为
methodName方法。
BoradcastMessage  在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
继承的类函数
Operator bool 这个物体存在吗？
Instatiate  克隆original物体并返回这个克隆。
Destroy  移除一个游戏物体，组件或资源。
DestroyImmediate立即销毁物体obj。强烈建议使用Destroy代替
FindObjectsOfType返回所有类型为type的激活物体。
FindObjectOfType返回第一个类型为type的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
MonoBehaviour
类，继承自Behaviour
MonoBehaviour是每个脚本所继承的基类。
每个使用Javascript的脚本自动地从MonoBehaviour继承。当使用C#或Boo时你必须显式从MonoBehaviour继承。
参见：手册中的chapter on scripting.
函数
◆function Cancellnvoke():void
描述：取消所有在这个MonoBehaviour上调用
//在2秒时开始
//一个projectile所在每0.3秒时运行
var projectile:Rigidbody;
InvokeRepeating(“LaunchProjectile”,2,0.3);
//当用户按下ctrl按钮时，
//取消重复调用
Function Update()
{
 If(Input.GetButton(“Fire1”)){
  Cancellnvoke();
 
 }
}
Function LaunchProjectile(){
 Instance=Instantiate(prtfab);
Instance.velocity=Random.insideUnitSphere*5;
}
◆function Cancellvoke(methodName:string):void
描述：撤销该行为中名为methodName的所有调用。
//在2秒时开始
//一个projectile将在每0.3秒时运行
var projectile :Rigidbady;
invokeRepeating(“LaunchProjectile”,2,0.3);
//当用户按下crtl按钮时
//取消重复调用
Function Update(){
 If(Input.GetButton(Fire1)){
  Cancellnvode(“LaunchProjectile”);
 }
}
Function LanuchProjectile(){
 instance=Instntiate(prefab);
 instance.velocity=Random.insideUnitSphere*5;
}
◆function Invoke(methodName:string,time:float):void
描述：在time秒调用methodName方法。
//在两秒时发射一个投射物
var  Projectile:rigidbady;
Invoke(“LaunchProjectile”,2);
Function LaunchProjectile(){
 Instance=Instantiate(prefab);
 Instance.velocity=Random.insideUnitSphere*5;
}
◆function InvokeRepeating(methodName:string,time:float,repeatRate:float):void
描述：在time秒调用methodName方法。
第一次调用之后，每repeatRate秒重复调用这个函数
//在2秒时开始
//一个Projectile将在每0.3秒运行
var projectile:Rigidbody;
InvokeRepeating(“LaunchProjectile”,2,0.3);
Function LaunchProjectile(){
 instance=Instantiate(prefab);
 instance.velocity=Random.insideUnitSphere*5;
}
◆function IsInvoking(methodName:string)
描述：是否有任何对methodName的调用在等待？
◆function IsInvoking(methodName:string):bool
描述：是否有任何MonoBehaviour的调用在等待？
◆Function StartCoroutine(routine:IEnumerator):Coroutine
描述：开始一个coroutine
一个coroutine的执行可以任何位置使用yield语句暂停，当coroutine继续的时候yield返回值，当行为需要跨越多个帧的时候，Coroutines是非常好的，当Coroutines几乎没有性能负担。StartCoroutine函数总是立即返回，然而你能够yidle结果，这个将等待直到coroutine执行完成。
当使用javascript时，没有必要使用StartCorutine,编译器会为你做这件事。在写C#代码的时候你必须调用StartCoroutine
//在这个例子中我们显示如何并行调用
//一个coroutine并继续执行这个函数。
//0秒后,打印”Starting0.0”
//0秒后,打印”Before WaitAndPrint Finishes0.0”
//2秒后，打印”WaitAndPrint 2.0”
print(“Starting”+Time.time);
//WaitAndPrint作为一个coroutine开始，并等待直到它完成
WaitAndPrint(2.0)
Print(“Before WaitAndPrint Finishes”+Time.time);
function WaitAndPrint(waitTime:float){
 //暂停执行waitTime秒
 Yield WaitForSeconds(waitTime);
 Print(“WaitAndPrint”+Time.time);
//WaitAndPrint作为一个coroutine开始,并等待直到它完成
Yield WaitAndPrint(2.0);
Print(“Done”+Time.time);
}
C#例子代码如下
//C#例子,在这个例子中我们显示如何并行调用
//一个coroutine并继续执行这个函数
void Start(){
//0秒后，打印”Starting0.0”
//0秒后，打印”Before WaitAndPrint Finishes0.0”
//2秒后，print”waitAndPrint2.0”
Print(“Starting”+Time.time);
StartCoroutine(WaitAndPrint(2.0F));
Print(“Before WaitAndPrint Finishes”+Time.time);
}
IEnumerator WaitAndPrint(float waitTime){
// 暂停waitTime秒
Yield return new WaitForSeconds(waitTime);
Print(“WaitAndPrint”+Time);
}
//c#例子
//在这个例子中我们展示如何调用一个coroutine并等待直到它完成
IEnumerator Start(){
//0秒后，打印”strating0.0”
//2秒后，prints”WaitAndPrint2.0”
//2秒后，打印”Done 2.0”
Print(“Starting”+Time.time);
Yield return StartCoutine(WaitAndPrint(2.0f);
Print(“Done”+Time.time);
}
IEnumerator WaitAndPrint(float waitTime){
//暂停waitTime秒
 Yield return new WaitForSeconds(waitTime);
Print(“WaitAndPrint”+Time.time);
}
◆Function StartCoroutine(methodName: string, value: object=null): Coroutine
描述：开始为methodName的Coroutine。
在大多数情况下，你要用StartCoroutine的变体。然而，使用一个字符串方法名的StartCoroutine允许StopCoroutine使用一个特定的方法名称。字符串级本的特定时它有较高的运行时开销来开始coroutine，并且你只能传递一个参数。
//在则合格例子中我们现实如何一个字符串名调用一个coroutine并停止它
Function Start(){
StartCoroutine(“DoSomething”,2.0);
Yield WaitForSeconds(1);
StopCoroutine（”DoSomething”）;
}
Function DoSomething(someParameter: float){
While(true)
{
Print(”DoSomething Loop”）;
Yield
}
}
◆Function StopAllCoroutines(): void
描述：停止所有运行在这个行为上的Coroutine。
//开始coroutine
StartCoroutine(“DoSomething”);
//紧跟着取消coroutine
Function DoSomething(){
While(true){
Yield;
}
}
StopAllCoroutines();
◆Function StopCoroutine(methodName: string): void
描述：停止所有运行在这个行为上的名为methodName的Coroutine。
请注意只使用一个字符串方法名的StartCoroutine才能使用StopCoroutine停止。
//在这个例子中我们显示如何使用一个字符串名调用一个coroutine并停止它
Function Start(){
StartCoroutine(“DoSomething”,2.0);
Yield WaitForSeconds(1);
StopCoroutine（”DoSomething”）;
}
Function DoSomething(someParameter: float){
While(true)
{
Print(”DoSomething Loop”）;
Yield
} 
}
重载函数
◆Function Awake(): void
描述：当脚本实例被加载时，Awake 被调用。
在游戏开始前，使用Awake 来初始化任何变量或游戏状态。在脚本实例的生命期内Awake 只被调用一次。Awake 在所有物体被初始化之后被调用，因此你可以安全地告诉其他物体或使用如GameObject.FindWithTag来查询它们。每个游戏物体的Awake 以随机的顺序被调用。因此，你应该使用Awake 来再脚本之间设置引用，并使用Start来传递消息。Awake 总是在任何Start函数之前调用。这允许你调整脚本的初始化顺序。Awake 不能作为一个Coroutine
注意对于C#哈Boo用户：使用Awake 而不是构造函数来初始化，因为组件的序列化状态在构造的时候还没有确定。Awake 只被调用一次，就像构造函数。
Private var target: GameObject;
Function Awake(){
Target=GameObject.FindWithTag(‘”Player”)
}
Awake不能作为一个coroutine。
◆Function FixedUpdate (): void
描述：如果MonoBehaviour被启用，这个函数将以固定的帧率调用。
当处理Rigidbody是应该使用FixedUpdate而不是使用Update。例如，当添加一个力到刚体时，你必须在FixedUpdate内以固定的帧率应用而不是在Update内。
//应用一个向上的力到刚体
Function FixedUpdate(){
Rigidbody.AddForce(Vector3.up);
}
力伟到从上一次调用Update的消逝时间，使用Time.deltaTime，这个函数只在Behaviour被启用时调用。重载这个函数，以便给你的组件提供功能。
◆Function LateUpdate (): void
描述：如果该Behaviour被启用，LateUpdate将在每帧中调用。
LateUpdate在所有Update函数被调用后调用。这可用于调整脚本执行顺序。例如，一个跟随相机应该总是在LateUpdate中实现，因为他跟踪Update中移动的物体。
//向前以1米/秒的速度移动物体
Function LateUpdate (){
transfor.Translate(0,0,Time.deltaTime*1);
}
为了得到从最后一个调用LateUpdate的消逝时间，使用Time.deltaTime。如果该Behaviour被启用，该函数将在每帧中调用。重载这个函数，以便给你的组件提供功能。
◆Function OnApplicationPause(pause: bool): void
描述：当玩家暂停时发送到所有游戏物体。
OnApplicationPause可以是一个coroutine，简单地在这个函数中使用yield语句。
◆Function OnApplicationQuit(): void
描述：在应用退出之前发送到所有游戏物体。
在编辑器中当用户停止播放模式时这个被调用。在网页播放器中当web被关闭时这个函数被调用。
◆Function OnBecameInvisible(): void
描述：OnBecameInvisible函数在这个渲染上的脚本。OnBecameVisible和OnBecameInvisible可以用于只需要在需要在物体可见时才进行的计算。
//当它不可见时禁用这个行为
Finction OnBecameInvisible(){
Enabled=false;
}
OnBecameInvisible可以是一个coroutine，简单地在这个函数中使用yield语句。当在编辑器中运行时，场景试图相机也会导致这个函数被调用。
◆Function OnBecameVisible(): void
描述：OnBecameVisible函数在这个渲染器对任何相机变得可见时被调用。
这个消息被发送到所有附加在渲染器上的脚本。OnBecameVisible和OnBecameInvisible可以用于只需要在需要在物体可见时才进行的计算。
//当它不可, 见时禁用这个行为
Finction OnBecameVisible(){
Enabled=false;
}
OnBecameVisible可以是一个coroutine，简单地在这个函数中使用yield语句。当在编辑器中运行时，场景试图相机也会导致这个函数被调用。
◆Function OnCollisionEnter(collisionInfo: Collision): void
描述：
当这个碰撞器/刚体开始接触另一个刚体/碰撞器时OnCollisionEnter被调用。
相对于OnTriggerEnter，OnCollosionEnter传递Collision类而不是Collider，Collision类包含接触点，碰撞速度等细细。如果在函数中不使用CollisionInfo，省略CollisionInfo参数以避免不西药的计算。注意如果碰撞器附加了一个非动力学刚体，也只发送碰撞事件。
Function OnCollisionEnter(collision: Collision){
//调试绘制所有的接触点和法线
For(var contact: ContactPoint in collision.oontacts){
Debug.DrawRay(contact.point, contact.normal, Color.white);
}
//如果碰撞物体有较大的冲击就播放声音
If(collision.relativeVelocity.magnitude>2)
Audio.Play();
}
OnCollisionEnter可以是一个coroutine，简单地在这个函数中使用yield语句。
◆Function OnCollisionExit(collisionInfo: Collision): void
描述：当这个碰撞器/刚体开始接触另一个刚体/碰撞器时OnCollisionEnter被调用。
相对于OnTriggerExit，OnCollosionExit传递Collision类而不是Collider. Collision类包含接触点，碰撞速度等细细。如果在函数中不使用CollisionInfo，省略CollisionInfo参数以避免不西药的计算。注意如果碰撞器附加了一个非动力学刚体，也只发送碰撞事件。
Function OnCollisionExit(collision: Collision){
Print(“No longer in contact with”+collisionInfo.transform.name);
}
OnCollisionExit可以是一个coroutine，简单地在这个函数中使用yield语句。
◆function OnCollisionStay(collisionInfo:collision):void
描述：对于每个与刚体碰撞器相触碰的碰撞器刚体，OnCollisionStay将在每一帧中被调用。
相对于OnTriggerStay,OnCollisionStay 传递Collision类而不是Collider.Collision类包含接触点，碰撞速度等细节。如果在函数中不使用collisionInfo省略collisionInfo参数以避免不要必要的计算。注意如果碰撞器附加了一个非动力学刚体，也只发送碰撞事件。
function OnCollisionStay(CollisionInfo:Collision){
 //调试绘制所有的接触点和法线
 for (var contact:ContactPoint in collision.contacts){
  Debug.DrawRay(contact.point,contact.normal,Color.white);
 }
}
OnCollisionStay可以是一个coroutine，也简单地在这个函数中使用yield语句
◆function OnConnectedToServer():void
描述：当成功链接到服务器时在客户端调用这个函数。
function OnConnectedToServer(){
Debug.Log(“Connected to server”);
//发送到本地玩家名称到服务器
}
◆function OnControllerColliderHit(Hit:controllerColliderHit):void
描述：在移动的时候，控制器碰到一个碰撞器时，OnControllerColliderHit被调用。
这可以用来在角色碰到物体时推开物体。
//这个脚本推开所有角色碰到物体时推开物体
Var pushPower=2.0;
Function OnControllerColliderHit(hit: OnControllerColliderHit){
 Var body:Rigidbody=hit.collider.attachedRigidboby;
 //无刚体
 If(body==null||body.isKinematic)
  return;
//不推开我们身后的物体
If(hit.moveDirection.y<-0.3)
 Return;
//从移动方向计算推的方向
//只推开物体到旁边而不是上下
Var pushDir=Vector3(hit.moveDirection.x,0,hit.moveDirection.z)
//如果知道角色移动有多快
//然后你就可以用它乘以推动速度
//使用推力
Body.velocity=pushDir*pushPower;
}
◆function OnDisable():void
描述：当这个行为禁用或不活动时这个函数被调用。
当物体被销毁的时候这个函数也会被调用并可以用于任何清理的代码。当脚本在编译结束后被加载时，OnDisable将被调用，然后脚本加载完成后OnEnable被调用。
Function OnDisable(){
Print("scrip was remove”);
}
OnDisabe 不能作为一个coroutine.
◆function OnDisconnectedFromServer(mode:NetworkDisconnection):void
描述：当链接挂失或服务器断开时在客户端用这个函数。
Function OnDisconnectedFromServer(info.NetworkDisconnection){
 Debug.Log(“Disconnected from server”+info);
}
◆function OnDrawGizmos():void
 描述：如果你想绘制可被点的Gizmos时，实现OnDrawGizmos,
 这允许你在场景中快速选择重要的物体。
//在物体的位置上绘制光源灯泡
function OnDrawGizmos(){
 Gizmos.DrawIcon(transform.position,”light Gizmo.tiff”);
}

◆function OnDrawGizmosSelected():void
描述：如果你想在物体被选择时绘制gizmos，实现这个OnDrawGizmosSelected。
Gizmos只在物体被选择的时候绘制。Gizmos不能点选。这可以设置更容易，例如
一个爆炸脚本可以绘制一个球显示爆炸半径。
var explosionRadius=5.0;
function OnDrawGizmosSelected(){
//选中的时候显示爆炸半径
 Gizmos.color=Color.white;
 Gizmos.DrawSphere(transfom.position,explosinRadius);
}
◆function OnEnable():void
描述：当物体启用或激活时这个函数被调用
function OnEnbale(){
 print(“script was enabled”);
}
◆function OnFailedToconnect(error:NetworkConnectionError);void
描述：当链接因为某些原因失败时在客户端上调用这个函数。
失败的原因作为NetworkConnectionError枚举传入。
function OnFailedToconnect (info:NetworkConnectionError){
 Debug.Log(“Could not connect to server”+error);
◆function OnFailedToConnectToMasterServer (error:NetworkConnectionError):void
描述：当链接到主服务器出现问题时在客户端或服务器调用这个函数。
错误的原因作为NetworkConnectionError枚举传入
function OnFailedToConnectToMasterServer(info:NetworkConnectionError){
 Debug.Log(“Could not connect to master server”+info);
}
◆function OnGUI():void
描述：OnGUI被调用来渲染并处理GUI事件。
如果Monobehaviour的启用属性被设置为假，OnGUI()将不会被调用。
Function OnGUI(){
 If(GUI>Button(Rect(10,10,150,100),”I am a button”)){
  Print(“You clicked the button”)
 }
}
参考GUI Scrtipting Guide 获取更多信息。
◆function ONJointBreak(breakForce:float):void
描述：当附加到相同游戏物体上的关节被断开时调用
当一个力大于这个关节的breakForce时，关节将被断开，当关节断开时，OnJointBreak将被调用，应用到关节的断开力将被传入，OnJointBreak之后这个关节将自动从游戏物体移除。参见：Joint.breakForce
◆function OnLevelWasLoaded(level:int):void
描述：这个函数在一个新的关卡被加载之后被调用
//level是被加载的关卡的索引。使用菜单项File>Build Settings来查看索引引用的是那个场景，参见：Application.LoadLevel
//当关卡13被加载的关卡的索引”Woohoo”
Function OnLevelWasLoaded(level:int){
If(level==13){
 Print(“Woohoo”);
}
}
OnLevelWasLoaded 可以是一个coroutine，简单地在这个函数中使用yield语句。
◆function OnMouseDown():void
描述：当用户在GUIElement或Collider上按下鼠标按钮时OnMouseDown被调用
这个事件被发送到所有附加在Collider或GUIElement的脚本上。
//加载名为“someLevel”的关卡
//来响应用户单击
Function OnMouseDown(){
 Application.LoadLevel(“SomeLevel”);
}
这个函数不会在属于Ignore Raycast的层上调用。
OnMouseDown可以是一个coroutine，简单地在这个函数中使用yield语句。这个事件被发送到的有附加在Collider或GUIElement的脚本上。
◆function OnMouseDrag():void
描述：当用户在GUIElement或Collider上点击并按住鼠标时OnMouseDrag被调用。
当鼠标被按下时OnMouseDrag将在每帧中被调用。
//按住鼠标时使用材质颜色变暗
function OnMouseDrag(){
 renderer.material.color==Color.white*Time.deltaTime;
}
这个函数不会在属于Ignore Ray的层被调用 。
OnMouseDrag可以是一个coroutine，简单地在这个函数中使用yield语句。这个事件被发送到所有附加在collider或GUIElement的脚本上。
◆Function OnMouseEnter():void
描述：当鼠标进入GUIElement或collider时，OnMouseEnter被调用。
//附加这个脚本到网格
//使用当鼠标经过这个网格时使它变红
Function OnMouseEnter(){
 Renderer.material.color=Color.red;
}
这个函数不会在属于Ignore Raycast的层上调用。
OnMouseEnter可以是一个coroutine，简单地在这个函数中使用yield语句。这个事件被发送所有附加在Collider或GUIElement的脚本上。
◆function OnMouseExit():void
描述：当鼠标不再位于GUIElement或Collider上时，OnMouseExit被调用。
OnMouseExit与OnMouseEnter相反
//当鼠标在网格时
//渐变材质的红色组件为零
Function OnMouseExit(){
 Rnderer.material.color=Color.white;
}
这个函数不会在属于Ignore Raycast的层上调用。
OnMouseExit可以是一个coroutine，简单地在这个函数中使用yield语句。这个事件被发送到所有附加在Collider或GUIElement上脚本上。
◆function OnMouseOver();void
描述：当鼠标在GUIElement或Collider上时，OnMouseOver被调用。
//当鼠标在网格上时
//渐变材质的红色组件为零
function OnMouseOver(){
 renderer.material.color==0.1*Time.deltaTime;
}
这个函数不会在属于Ignore Raycast的层上调用。
OnMouseOver可以是一个coroutine，简单地在这个函数中使用yield语句，这个事件被发送到所有附加在Collider或GUIElement的脚本上。
◆function OnMouseUP():void
描述：当用户已经松开鼠标按钮时OnMouseUp调用。
在GUIElement或Collider上松开鼠标时OnMouseUp被调用。
//加载名为”someLevel”的关卡
//来响应用户单击
function OnMouseUp(){
 Application.LoadLevel(“SomeLevel”);
}
这个函数不会在属于Ignore Raycast的层上调用。
OnMouseUp可以是一个coroution,简单地在这个函数yield语句。这个事件被发送到所有附加在Collider或GUIElement的脚本上。
◆function OnNetworkInstantiate(info:NetworkMessageInfo):void
描述：当一个物体使用Network.Instantiate进行网络初始化在该物体上调用这个函数。
这个对于禁用或启用一个已经初始化的物体组件来说是非常有用的，它们的行为取决与它们是在本地还是在远端。
 注意：在NetworkMessageInfo里的networkView属性不能在OnNetworkInstantiate里使用。
function OnNetworkInstantiate(info:NetworkMessageInfo){
 Debug.Log(“New object instantiated by”+info.sender);
}
◆function onParticleCollision(other:GameObject):void
描述：当一个粒子碰到一个碰撞器时OnParticleCollision被调用。
这个可以在游戏物体被粒子击中时应用伤害到它的上面，这个消息被发送到所有附加到
WorldParticleCollider 的脚本上和被击中的Collider上，这个消息只有当你在
WorldParticleCollider检视面板中启用了sendCollisionMessage时才会被发送。
//应用力到所有被粒子击中的刚体上
function OnParticleCollison(other:GameObject){
 var body=other.rigidbody;
 if(body){
  var direction=other.transform.position+transform.position;
  direction=direction.normalized;
  body.AddForce(direction*5);
 }
}
OnParticleCollision可以是一个coroutine，简单地在这个函数中使用yield语句。
◆function OnPlayConnected(player:NetworkPlayer):void
描述：当一个新玩家成功连接在服务器上调用这个函数。
private var playerCount:int=int=0;
function OnPlayerConnect(player.NetworkPlayer){
Debug.log(“Player”+playerCount+++”connected from”+player.ip.Address+”:”+player.port);
//用玩家的信息构建一个数据结构
}
◆function OnPlayerDisconnected(player:NetworkPlayer):void
描述：当玩家从服务器断开时在服务器上调用这个函数。
function OnPlayerDisconnected (player:NetworkPlayer){
 Debug.Log(“Clean up after player”+player);
 Network.RemoveRPcs(player);
 Network.DestroyPlayerObject(player);
}
◆function OnpostRender():void
描述：OnPostRender在相机渲染场景之后调用。
只有脚本被附加到相机上时才会调用这个函数。OnPostRender可以是一个coroutine，
简单地在这个函数中使用yield语句。
OnPostRender在相机渲染完所有它的物体之后被调用。如果你想在所有相机和GUI被渲染之后做一些事情，使用WaitForEndFrame coroutine
参见：OnPreRender,WaitForEndOfFrame
//当附加到机时，将消除
//相机纹理的alpha通道为纯白色
//如果你有一个渲染纹理并想将它显示在GUI上时可以使用这个函数
Parvate var mat:Material;
function OnPostRender(){
 //创建一个只渲染白色到alpha通道的着色器
 If(mat)
 {
 Mat=new Material(“Shader Hidden SetAlpha”+)
 “SubShader{“+”pass{”+”ZTest Always Cull off Zwrite Off”+”ColorMaskA”+”Color(1,1,1,1)”+”}”+”}”
+”}”);
}
}
// 用上述着色器绘制一个全屏四边形
GL.PushMatrix();
GL.LoadOrtho();
for(var i=0;i<mat.pssCount;++i){
 mat.SetPass(i);
 GL.Begin(GL.QUADS);
 GL.Vertex3(0,0,0.1);
 GL.Vertex3(1,0,0.1);
 GL.Vertex3(1,1,0.1);
 GL.Vertex3(0,1,0.1);
 GL.End();
 }
 GL.PopMatrix();
}
◆function OnpreCull():void
描述：OnPreCull在相机开始裁剪场景之前调用
裁剪决定那个物体对于相机来说是可见的。OnPreCull仅仅在这个过程之间被调用。
只有脚本被附加到相机上时才会调用这个函数
如果你想改变相机的视觉参数（例如fieldOfView或者仅是变换），就在这里做这个。
场景物体的可见性将基于相机参数在OnPerCull之后确定。
? function OnRender（）:void
描述：OnpreRender在相机开始渲染场景之前调用。
只用脚本被附加到相机上时才会调用这个函数。
注意如是果你在这里改变了相机的视野参数（例如fieldOfView），它们将影响下一帧。用OnPreCull代替。OnPreRender可以是一个coroutine，简单地在这个函数中使用yield语句。
参见：OnPostRender
? function OnRenderImage(source:RenderTexture,destination:RenderTexture):void
描述：OnRenderImage在所有渲染完成后被调用，来渲染图片的后期处理效果（限于Unity Pro）
这允许你使用基于shader的过滤器来处理最后的图片。进入图片是source渲染纹理结果是destination渲染纹理。当有多个图片过滤附加在相机上时，它们序列化地处理图片，将第一个过滤器的目标作为下一个过滤器的源。
这个消息被发送到所有附加在相机上脚本。
参见：Unity Pro 中的image effects
◆function OnRenderObject(queueindex:int):void
描述：OnRenderObject被用来渲染你自己的物体，使用Graphics.DarwMesh或者其他函数。
queueIndex指定用来渲染物体的render queue。可以使用RenderBeforeQueues属性来指定你想绘制这个物体到哪里渲染队列。
◆function OnserializeNetworkView(stream:Bitstream.info:NetworkMessageInfo):void
描述：用来在一个被网络视监控的脚本中自定义变量同步
它自动决定被序列化的变量是否应该发送或接收，查看下面的例子获取更好的描述：
//这个物体的生命信息
Int currentHealth;
function OnSerializeNetworkView(stream:BitStream,info:NetworkMessageInfo){
if(stream.isWriting){
  int health=currentHealth;
  stream.Serialize(health);
 }
 else{
  int health=0;
  stream.Serialize(health);
  currentHealth=health;
 }
}
◆function OnServerInitialized():void
描述：当Network.InitializeServer被调用并完成时，在服务器上调用这个函数。
function OnServerInitialized(){
 Debug.Log(“Server initialize and ready”);
}
◆function OnTriggerEnter(other:Collider):void
描述：当这个Collider other进入trigger时OnTriggerEnter被调用。
这个消息被发送到这个触发器碰撞器和接触到触发器的刚体（或者是碰撞器如果没有刚体）。注息如果碰撞器附加了一个刚体，也只发送触发器事件。
//销毁所有进入该触发器的物体
function OntriggerEnter(other:Collider){
 Destroy(other.gameObject);
}
OnTriggerEnter可以是一个coroutine简单地在这个函数中使用yield语句。
◆function OnTriggerExit(other:Collider):void
描述：当这个Collider other停止触碰trigger时OnTriggerExit被调用。
这个消息被发送到触发和接触到这个触发器的碰撞器。注意如果碰撞附加了一个刚体，也只发送触发器事件。
//觥毁所有离开该触发器的物体
function OntriggerExit (other:Collider){
Destroy(other.gameObject);
}
OnTriggerExit可以是一个coroutine，简单地在这个函数中使用yield语句。
◆function OnTriggerStay(other:Collider):void
描述：对于每个Collider other,当它触碰到trigger时，OnTriggerStay会在每一帧中都被调用。
这个消息被发送到触发器和接触到这个触发器的碰撞器。注意如果碰撞器附加了一个刚体，也只发送触发器事件。
//对所进入这个触发器的刚体使用一个向上的力
function OnTriggerStay(other:Collider){
 if(other.attachedRigidbody){
  other.attachedRigidbody.AddForce(Vector3.up*10);
 }
}
OnTriggerStay可以是一个coroutine，简单地在这个函数中使用yield语句。
◆function OnWillRenderObject():void
描述：如果物体可见，每个相机都会调用OnWiiRenderObject。
这个函数在裁剪过程中被调用，在渲染所有被裁剪的物体之前被调用。可以用这个来创建具有依赖性的渲染纹理，只有在被渲染的物体可见时才更新这个渲染纹理。作为一个例子，水组件就使用这个。
Camera.current将被设置为要渲染这个物体的相机
◆function Reset():void
描述：Reset在用户点击检视面版的上下文菜单或者第一次添加该组件被调用。Reset只在编辑模式下调用。Reset最常用于在检视面板中给定一个好的默认值
//设置target为一个默认的值
//这可以用于跟随相机
var target:GameObject;
function Reset(){
 //如果target没有赋值，设置它
 if(!target){
  target=GameObject.FindWithTag(“play”);
 }
}
◆function Start():void
描述：Start在所有Update方法被第一次调用前调用。
Start在行为的生命期内只调用一次。Awake和Start的不同在于Start只在脚本实例被启用时调用。这个允许你延迟所有初始化代码，知道真正需要它们的时候，Awake总是在任何Start函数之前调用。这允许你调整脚本的初始化顺序。Start不能作为一个coroutine
 Start函数在所有脚本实例的Awake函数调用之后调用。
 //初始化target变量
 //target是私有的并且不能在检视面板中编辑
parivate var target:GameObject;
function Start(){
 target=GameObject.FindWithTag(“Player”);
}
◆function Update():void
描述：如果MonoBehaviour被启用，Update将在每帧中调用。
Update是最常用的函数，来实现任何游戏行为。
//向前以1米的速度移动物体
function Update(){
 transform.Translate(0,0,Time.deltaTime*1);
}
为了得到从最后一次调用Update的消逝时间，使用Time.deltaTime。如果该Behaviour
被启用，该函数将在每帧中调用，重载这个函数，以便给你的组件提供功能。
继承的成员
继承的变量
endbled 启用Behaviours被更新，禁用Behaviour不被更新
transform附加到这个GameObject的Transform（如果没有null）
rigidbody 附加到这个GameObject的Rigidbody（如果没有null）
camera             附加到这个GameObject的Camera（如果没有null）
light  附加到这个GameObject的Light（如果没有null）
animation            附加到这个GameObject的Animation（如果没有null）
constantForce附加到这个GameObject的ConstantForce（如果没有null）
renderer             附加到这个GameObject的Renderer（如果没有null）
audio 附加到这个GameObject的Audio（如果没有null）
guiText 附加到这个GameObject的GUIText（如果没有null）
networkView附加到这个GameObject的NetworkView(只读)（如果没有null）
guiTexture附加到这个GameObject的GUITexture（只读）（如果没有null）
collider 附加到这个GameObject的Collider（如果没有null）
hingeJoint附加到这个GameObject的HingeJoint（如果没有null）
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有null）
gameObject这个组件附加的游戏物体。一个组件总是附加到一个游戏物体
tag  这个游戏物体的标签
name 对象的名称
hideFlags 该物体是否被隐藏，保存在场景或被用户修改
继承的函数
GetComponent           返回type类型组件，如果游戏物体上附加了一个如果没有返回
null。
GetComponentInChildren   返回type类型的组件，这个组件位于GameObject或任何它的子
物体上，使用深度优先搜索。 
GetComponentsInChildren  返回所有type类型的组件，这些组件位于GameObject或任何它
的子物体上。
GetComponents           返回GameObject上所有type类型的组件。
CompareTag              这个游戏物体被标签为tag？
SendmessageUpwards      在这个游戏物体的每个MonoBehaviour和该行为的祖先上
调用名为methodName方法
SendMessage 在这个游戏物体上的每个MonoBehaviour上调用methodName
方法。
BroadcastMessage在这个游戏物体或其任何子上的每个MonoBehaviour上调用
methodName方法。
GetInstanceID 返回该物体的实例ID。
继承的类函数
Operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy  移除一个游戏物体，组件或资源。
 
DestroyImmediate立即销毁物体obj。强烈建议使用Destroy代替。
FindObjectOfType返回所有类型为type的激活物体。
FindObjectOfType返回第一个类型为type的激活物体。
Operator== 比较两个物体是否相同。
Operator!=  比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
 Terrain
类，继承自MonoBehaviour
渲染地形的Terrain
变量
◆var basemapDistance:float
描述：超出basemapDistance的高度图，将使用预先计算的地解析度basemap。
这个可以改善远处块的性能。Unity混合任意数量的地形纹理，使用条图来渲染近处的高度图。
function Start(){
 Terrain.activeTerrain.basemapDistance=100;
}
◆var castShadows:bool
描述：地形应该投射阴影？
◆var detailObjectDistance:float
描述：在这个距离内细节将被显示。
function Start(){
 Terrain.activeTerrain.detailObjectDistance=40;
 }
◆var heightmapMaximumLOD:int
描述：让你实质降低用于渲染的高度图解析度
这个可用在低端的显卡上并不会显示最高的LOD地形。值为0表示总是显示最高细节。
值为1表示三角形数量将减小到1/4，高度图的解析度将是宽度和高度的一半。
function Start(){
 Terrain.activeTerrain.heightmapMaximumLOD=1;
}
◆var heightmapPixelError:float
描述：当切换LOD时大约有多少像素时地形将处于错误的情况。
较高的值减少多边形的绘制数量。
function Start(){
 Terrain.activeTerrain.heightmapPixelError=10;
}
◆var Lighting:Terrain.Lighting
描述：地形光照模式
参见：TerrainLighting枚举，Terrain Lightmap,terrain Settings
◆var terrainData:TerrainData
描述：存储在高度图中的地形数据，地形纹理，细节网格和树。
◆var treebillboardDistance:float
描述：到相机的距离超过这个值，树只被作为公告板渲染。
降低这个值将改善性能，但是使过度看起来更差因为公告板和树的不同将更加明显。
Function Start(){
 Terrain.activeTerrain.treeBillboardDistance=100;
}
◆var treeCrossFadeLength:float
描述：树从公告变换到网格到网格的总距离增量。
降低这个值将使变换发生的越快。设置为0时，在从网格切换分告表示时将立即发生。
function Start(){
 Terrain.activeTerrain.treeCrossFadeLength=20;
}
◆var treeDistance:float
描述：渲染树的最大距离。
这个值越高，越远的树将看到，运行的也更慢。
参见：Terrain.treeBillboardDistance
function Start(){
 Terrain.activeTerrain.treeDistance=2000;
}
◆var treeMaximumFull.ODCount:int
描述：全LOD时渲染树的最大数量。
这个是一个简单的设置用来阻止太多的楼以过高的解析度和密度被绘制。因为如果
treeMaximumFullLodCount过高，树将不会消失，你应该修改treeBillboardDistance为不
包含。
Function Start(){
 Terrain.activeTerrain.treeMaximumFullLODCount=200;
}
函数
◆function SampleHeight(worldPositon:Vector3):float
描述：在世界空间的给定位置处采样高度。
function LateUpdate(){
 transfom.positon.y=Terrain.activeTerrain.SampleHeght(transfom.position);
}
◆function SetNeighbors(left:Terrain,top:Terrain,right:Terrain,bottom:Terrain):void
描述：允许你在相邻地形间设置连接
这个确保LOD在相邻地形上相同。注意，在一个地形上调用这个函数是不够的，你需要在每个地形上设置邻居。
类变量
◆static var activeTerrain: Terrain
描述：激活的地形。这个是用来在场景中获取主地形的快捷方式。
类方法
◆Static functin CreateTerrainGameObject(assignTerrain: TerrainData): GameObject
描述：从TerrainData创建一个包含碰撞器的地形。
继承的成员
继承的变量 
Enabled 启用Behaviour被更新，禁用Behaviours不被更新。
transform 附加到该GameObject的Transform（没有返回null）
rigidbody 附加到该GameObject的Rigidbody（没有返回null）
camera 附加到该GameObject的Camera（没有返回null）
light 附加到该GameObject的Light（没有返回null）
animation 附加到该GameObject的Animation（没有返回null）
constantForce 附加到该GameObject的ConstantForce（没有返回null）
renderer 附加到该GameObject的Renderer（没有返回null）
audio 附加到该GameObject的Audio（没有返回null）
guiText 附加到该GameObject的GuiText（没有返回null）
networkView 附加到该GameObject的NetworkView（没有返回null）
guiTexture 附加到该GameObject的GuiTexture（没有返回null）
collider 附加到该GameObject的Collider（没有返回null）
hingeJoint 附加到该GameObject的HingeJoint（没有返回null）
particleEmitter 附加到该GameObject的ParticleEmitter（没有返回null）
gameObject 该组件所附加的游戏物体。组件总是会附加到游戏物体上
tag 该游戏物体的标签。
name 对象的名称
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改
继承的函数 
Invok e 在time秒调用methodName方法。
Invok Repeating 在time秒调用methodName方法。
CancelInvoke 取消所有在这个MonoBehaviour上的调用
IsInvoking 是否有任何对methodName的调用在等待？
StartCoroutine 开始一个coroutine
StopCoroutine 停止所有运行在这个行为上的名为methodName的coroutine
StopAllCoroutines 停止所有运行在这个行为上的coroutine
GetComponent  返回type类型的组件，如果游戏物体上附加了一个，如果没有
  返回null。
GetComponcetInChildren 返回type类型的组件，这个组件位于GameObject或任何它的子
  物体上。使用深度优先搜索
GetComponcetsInChildren 返回所有type类型组件，这些组件位于Gameobject或任何它的
  子物体上。
GetComponents  返回GameObject上所有type类型的组件。
CompareTag  这个游戏物体被标签为tag?
SendMessageUpwards  在这个游戏物体的每个MonoBehaviour和该行为的祖先上调用
  名为methodName方法。
SendMessage  在这个游戏物体上的每个MonoBehaviour上调用methodName
方法。
BroadcastMessage在这个游戏物体或其2任何子的每个MonoBehaviour上调用
methodName方法。
GetInstanceID 返回该物体的实例ID。
继承的消息传递
Update  如果MonoBehaviour被启用，Update将在每帧中
调用。
LateUpdate 如果该Behaviour被禁用，LateUpdate将在每帧中
调用。
FixedUpdate 如果MonoBehaviour被启用，这个函数将在每帧中调用。
Awake  当脚本实例被加载时，Awake被调用。
StartStart在所有Update方法被第一次调用前调用。
Reset  Reset在用户点击检视面板的上下文菜单或第一次添加该组件时
被调用。
OnMouseEnter当鼠标进入GUIElement或Collider时，OnMouseEnter被调用。
OnMouseOver 当鼠标在GUIElement或Collider时，OnMouseEnter被调用。
OnMouseExit 当鼠标不再位于GUIElement或Collider上时，OnMouseExit被调用。
OnMouseDown当用户在GUIElement或Collider上按下鼠标按钮时
，OnMouseDown被调用。
OnMouseUp 当户已经松开鼠标按钮时OnMouseUp被调用。
OnMouseDrag 当用户在EUIElement或Collider上点击并按住鼠标时
OnMouseDrag被调用。
OnTriggerEnter当这个Collider other进入trigger时OnTriggerEnter被调用。
OnTriggerExit 当这个Collider other停止触碰trigger进OnTriggerExit被调用。
OnTriggerStay 对于每个Collider other，当它触碰到trigger时，OnTriggerStay
会在每一帧中都会被调用。
OnCollisionEnter当这个碰撞器刚体开始触碰另一个刚体碰撞器
 
时OnCollisionEnter被调用。
OnCollisonExit 对于每个与碰撞器刚体停止触碰另一个刚体碰撞器时
OnCollisionExit被调用。
OnCollisonStay对于每个与刚体碰撞器相触的碰撞器刚体OnCollisonStay将在每
一帧中被调用。
OnControllerColliderHit  在移动的时候，控制器碰到一个碰撞器时OnControllerColliderHit
被调用。
OnJointBreak 当附加到相同游戏物体上的关节被断开时调用。
OnParticleCollision当一个粒子碰到一个碰撞器时OnParticleCollision被调用。
OnBecameVisibleOnBecamevisible函数在这个渲染器对任何相机变得可见时被
调用。
OnBecameInvisibleOnBecamevisible函数在这个渲染器对任何相机变得不可见时被
调用。
OnLevelWasLoaded这个函数在一个新的关卡被加载之后被调用。
OnEnable  当物体启用或激活时这个函数被调用。
OnDisable 当这个行为禁用或不活动时这个函数被调用。
OnPreCull OnPreCull在相机开始裁剪场景之前调用。
OnPreRender OnPreRender在相机开始渲染场景之后调用。
OnPostRender OnPostRender 在相渲染场景之后调用。
OnRenderObjectOnRenderObject被用来渲染你自己的物体，使用
Graphics.DrawMesh或者其他函数。
OnWillRenderObject  如果物体可见，每个相机都会调用OnWillRenderObject。
OnGUI  OnGUI被调用来渲染并处理GUI事件。
OnRenderImageOnRenderImage在所有渲染完成后被调用，来渲染图片。
OnDrawGizmosSelected  如果你想在物体被选择时绘制gizmos，实现这个
OnDrawGizmosSelected.
OnDrawGizmos如果你想绘制可被点选的gizmos时，实现OnDrawGizmos。
OnApplicationPause  当玩家暂停时发送到所有游戏物体。
OnApllicationQuit在应用退出之前发送到所有游戏物体。
OnPlayerConnected  当一个新玩家成功连接时在服务器上调用这个函数。
OnServerInitialized当Network.InitializeServer被调用并完成时，在服务上调用这
个函数。
OnConnectedToServer  当成功链接到服务器上时在客户端调用这个函数。
OnPlayerDisconnected  当玩家从服务器断开时在服务器上调用这个函数。
OndisconnectedFormServer 当链接丢失或服务器断开时在客户端调用这个函数。
OnFailedToConnect当链接因为某些原失败时在客户端上调用这个
 
函数
OnFailedToConnectToMasterServer   当链接到主服务器出现问题时在客户端或服务器端调用这个函数。
OnNetworkInstantiate   当一个物体使用Network.Instantiate进行网络初始化时在该物体上调用这个函数。
OnSerializeNetworkView   用来在一个被网络视监控的脚本中自定义变量同步。
继承的类函数
operator bool      这个物体存在吗？
Instantiate        克隆original物体并返回这个克隆。
Destroy            移除一个游戏物体，组件或资源。
DestroyImmediate   立即销毁物体obj。强烈建议使用Destroy代替。
FindObjectsOfType  返回所有类型为type的激活物体。
FindObjectOfType   返回第一个类型为type的激活物体。
operator ==        比较两个物体是否相同。
operator !=        比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
NetworkView
类，继承自Behaviour
网络视是多用户游戏的绑定物。
使用这个你可以准确定义什么应该通过网络同步，和如何同步，游戏物体可以有NetworkView组件，该组件可以被定义为观察物体的其他组件，可以在Network View manual page和component reference page获取更多信息。
变量
◆ var group : int
描述： 这个网络视所在的网格组。
所有的网格消息和RPC调用通过这个组。
Function Awake(){
//通过组1发送来自这个网格视的所有消息
Network View.group=1;
}
◆ var isMine : bool
描述：这个网格视是有这个物体控制吗？
Function OnNetworkInstantiate(info: NetworkMessageInfo){
If{networkView.isMine}
Debug.Log(“New object instanted by me”);
Else
Debug.Log(“New object instantiated by”+info.sender);
}
◆ var obseved : Component
描述：网络视监控的组件。
 
//打印含有由数组中给出的viewID的对象的名称（Print the names of the objects which have the view IDs given in the array）
Function PrintNames(viewIDs: Array){
   For (var ID: NetworkViewID in IDs){
       Debug.log(“Finding”+ID);
       Var view : NetworkView = networkView.Find(ID);
       Debug.log(view.observed.name);
}
}
◆ var owner : NetworkPlayer 
描述： 拥有这个网络视的NetworkPlayer
function OnNetworkInstantiate(info: NetworkMessageInfo){
   if(!networkView.isMine)
       Debug.log(“New object instantiated by” + networkView.owner);
}
◆ var stateSynchrohization: NetworkStateSynchronization
描述：为这个网络视设置的NetworkStateSynchronization类型。
确保NetworkView在所有机器上使用相同可靠的方法是你的责任。在状态同步已经发生后不要在运行时改变状态的可靠性。
◆ var viewID: NetworkViewID
描述：这个网络视的ViewID。
函数
◆ function RPC(name: string, mode: RPCMode, params args:object[]): void
描述：在所有连接端调用一个RPC函数。
调用的函数必须有@RPC标志（[RPC]用于C Sharp）。NetworkView必须附加到GameObject，在这个物体上RPC函数能够被调用。NetworkView用于其他什么地方或者是仅仅用于RPC函数是没有关系的。如果他仅仅用于RPC函数，state synchronization应该被关掉。Ovserved属性设置为none，在整个场景中RPC函数的名称应该是唯一的，如果不同脚本的两个RPC函数具有相同的名称，仅有一个会被调用。RPC调用总是确保执行的顺序与他们调用的顺序相同。用NetworkView.group为NetworkView设置的通信用，被用于RPC调用。为了获取RPC自身的信息，可以添加一个NetworkMessageInfo参数到函数申明中，它将自动包含这个信息。这样的做的时候你不需要改变调用RPC函数的方式，可以参考manual的RPC部分以便获取更多关于RPC的信息。可用的RPC参数为int，float，string，NetworkPlayer，NetworkViewID，Vector3和Quaternion。
var cubePrefab : Transform;
function OnGUI()
{
   if (GUILayout.Button(“SpawnBox”))
   {
       var viewID = Netwok.AllocateViewID();
 
       networkView.RPC(“SpawnBox”,
                   RPCMode.AllBuffered,
                   viewID,
                   transform.position);
    }
}
@RPC
function SpawnBox (viewID : NetworkViewID, location : Vector3) {
// Instantate the prefab locally
var clone : Transform;
clone = Instantiate(cubePrefab, location, Quaternion.identity);
var nView : NetworkView;
nView = clone.GetComponent(NetworkView);
nView.viewID = viewID;
}
◆ function RPC(name: string, target: NetworkPlayer, params args: object[]): void
描述：在特定的玩家端调用RPC
◆ function SetSeope(player: NetworkPlayer, relevancy: bool): bool
描述：相对于一个特定的网络玩家这是网络视的范围
这可以用来实现相关设置，设置它为真假取决于你是否想这个玩家从网络接收更新。
类方法
◆ static function Find(viewID: NetworkViewID): NetworkView
描述：基于NetworkViewID查找一个网络视。
// 打印物体的名称，这些物体具有数组中给定的视ID (Print the names of the objects which have the view IDs given in the array)
function PrintNames(viewIDs : Array) {
for (var ID: NetworkViewID in IDs) {
Debug.Log("Finding "+ID);
var view : NetworkView = networkView.Find(ID);
Debug.Log(view.observed.name);
}
} 
继承的成员
继承的变量
enabled 启用Behaviours被更新，禁用Behaviours不被更新。
transform 附加到这个GameObject的Transform（如果没有为null）。
rigidbody 附加到这个GameObject的Rigidbody（如果没有为null）。
camera 附加到这个GameObject的Camera（如果没有为null）。
light 附加到这个GameObject的Light（如果没有为null）。
animation 附加到这个GameObject的Animation（如果没有为null）。
constantForce    附加到这个GameObject的ConstantForce（如果没有为null）。
renderer 附加到这个GameObject的Renderer（如果没有为null）。
audio 附加到这个GameObject的AudioSource（如果没有为null）。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView 附加到这个GameObject的NetworkView（只读）。（如果没有为null）
guiTexture 附加到这个GameObject的GUITexture（只读）。（如果没有为null）
collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint 附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject       这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag              这个游戏物体的标签。
name             对象的名称。
hideFlags        该物体是否被隐藏，保存在场景中或被用户修改？
继承的函数
GetComponent             返回type类型的组件，如果游戏物体上附加了一个，如果没有返回null。
GetComponentInChildren   返回type类型的组件，这个组件位于GameObject或任何它的子物体上，使用深度优先搜索。
GetComponentsInChildren  返回所有type类型的组件，这些组件位于GameObject或任何它的子物体上。
GetComponents            返回GameObject上所有type类型的组件。
CompareTag               这个游戏物体标签为tag？
SendMessageUpwards       在这个游戏物体的每个MonoBehaviour和该行为的祖先上调用名为methodName方法。
SendMessage              在这个游戏物体的每个MonoBehaviour上调用methodName方法。
BroadcastMessage         在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
继承的类函数
operator bool      这个物体存在吗？
Instantiate        克隆original物体并返回这个克隆。
Destroy            移除一个游戏物体，组件或资源。
DestroyImmediate   立即销毁物体obj。强烈建议使用Destroy代替。
FindObjectsOfType  返回所有类型为type的激活物体。
FindObjectOfType   返回第一个类型为type的激活物体。
operator ==        比较两个物体是否相同。
operator !=        比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
Projector
类，继承自Behaviour。
脚本界面就是一个Projector组件。
这个Projector可用于场景工程中的任何材料——就像一个真实的世界。这类的属性值就是Projector的检查值。
它可以用来执行斑点或投射阴影。你也可以投射纹理动画或渲染纹理在电影场景的另一个部分。所有物体投影的视图在其观点和提供的材料中。
没有快捷方式在游戏对象或者组件来访问Projector，所以你必须使用GetComponent来做：
function Start() {
// 获取projector
Var proj.Projector=GetComponent(Projector);
//使用这个
Proj.nearClipPlane=0.5;
}
参见：projector.component;
变量
◆var aspectRatio:float
描述：投影的长宽比。
这个是投影的宽度除以高度。比为1.0使这个投影为正方形：比为2.0使得宽为高的2倍。
function Start() {
var proj : Projector = GetComponent (Projector);
proj.aspectRatio = 2.0;
}
 参见：projector component.
◆var farClipPlane:float
描述：远裁剪面的距离。
投影器将不会影响任何运离这个距离的物体。
function Start() {
var proj : Projector = GetComponent (Projector);
proj.farClipPlane = 20.0;
}
参见：projector component
◆var fieldofView:float
描述：投影的视野，以度为单位。
这是垂直视野：水平FOV取决于aspectRatio。当投射器是正交时fieldOfView被忽略
（参考orthographic）
function Start() {
var proj : Projector = GetComponent (Projector);
proj.fieldOfView = 80.0;
}
 参见：project component
◆var ignoreLayers:int
描述：那个物体层将这个投射器忽略。
参见layer mask
缺省为零，没有层被忽略，在ignoreLayers中设置的每个位将使这个层不会被投射器影
响。
function Start() {
var proj : Projector = GetComponent (Projector);
//使投射器忽略默认的（0）层
proj.ignoreLayers = (1<<0);
}
参见：projector component,Layers.
◆var material:material
描述：这个材质将被投射到每个物体上
 
 如果没有设置材质，投射器不会做任何事情，Standard Assets中的Blob.Shadow文件夹包含一个投射器材质的例子
 参见：projector component,Material类。
◆var nearClipPlane:float
描述：近裁剪面的距离。
投影器将不会影响任何比这个距离近的物体。
function Start() {
var proj : Projector = GetComponent (Projector);
proj.nearClipPlane = 0.5;
}
 参见：projector component;
◆var orthographic:bool
描述：投射是正交的（true）还是透视的（false）?
当正交为true时，投影被orghographicSize定义。
当正交为false时，投射被fieldOfView定义
function Start() {
var proj : Projector = GetComponent (Projector);
proj.orthographic = true;
}
参见：projector component
◆var orthographicSize:float
描述：在正交模式下投射的一半尺寸。
这个为投影体垂直大小的一半。水平投射的大小取决于aspectRatio,投射器不是正交时，
orthographicSize被忽略（参考orthographic）
function Start() {
var proj : Projector = GetComponent (Projector);
proj.orthographic = true;
proj.orthographicSize = 2.0;
}
参见：projector component
继承的成员
继承的变量
enabled              启用Behaviours被更新，禁用Behaviours不被更新。
transform             附加到这个GameObject的Transform（如果没有为null）。
rigidbody             附加到这个GameObject的Rigidbody（如果没有为null）。
camera               附加到这个GameObject的Camera（如果没有为null）。
light                 附加到这个GameObject的Light（如果没有为null）。
animation            附加到这个GameObject的Animation（如果没有为null）。
constantForce         附加到这个GameObject的ConstantForce（如果没有为null）。
renderer             附加到这个GameObject的Renderer（如果没有为null）。
guiText              附加到这个GameObject的GUIText（如果没有为null）。
networkView附加到这个GameObject的NetworkView（如果没有为null）。
Collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag  这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改？
继承的函数
GetComponet  返回type类型的组件，如果游戏物体上附加一个，如果没有返回null。
GetComponentInchildren 返回type类型的组件，这个组件位于GameObject或者任何它的子物体上，使用深度优先搜索。
GetComponentsInchildren 返回所有type类型的组件，这些组件位于GameObject或者任何它的子物体上。
GetComponets返回Gameobject所有type类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards  在这游戏物体的每个MonoBehaviour和该行为的组先上调用名为methodName方法。
SendMessage 在这游戏物体的每个MonoBehaviour上调用名为
methodName方法。
BoradcastMessage  在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
继承的类函数
Operator bool 这个物体存在吗？
Instatiate  克隆original物体并返回这个克隆。
Destroy  移除一个游戏物体，组件或资源。
DestroyImmediate立即销毁物体obj。强烈建议使用Destroy代替
FindObjectsOfType返回所有类型为type的激活物体。
FindObjectOfType返回第一个类型为type的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
Skybox
类，继承自Behaviour
Skybox component的脚本接口
天空盒只有material属性
参见：skybox component
变量
◆var material:Material
描述：该天空盒使用的材质。
参见：skybox component
继承的成员
继承的变量
Enabled 启用Behaviours被更新，禁用Behaviours不被更新。
Transform附加到这个GameObject的Transform（如果没有为null）。
Rigidbody附加到这个GameObject的Rigidbody（如果没有为null）。
Camera 附加到这个GameObject的Camera（如果没有为null）。
Light  附加到这个GameObject的Light（如果没有为null）。
Animation附加到这个GameObject的Animation（如果没有为null）。
constantForce附加到这个GameObject的ConstantForce（如果没有为null）。
Renderer 附加到这个GameObject的Renderer（如果没有为null）。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView附加到这个GameObject的NetworkView（如果没有为null）。
Collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag  这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改？
继承的函数
GetComponet返回type类型的组件，如果游戏物体上附加一个，如果没有返
                      回null。
GetComponentInchildren 返回type类型的组件，这个组件位于GameObject或者任何它的子物体上，使用深度优先搜索。
GetComponentsInchildren 返回所有type类型的组件，这些组件位于GameObject或者任何它的子物体上。
GetComponets返回Gameobject所有type类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards  在这游戏物体的每个MonoBehaviour和该行为的组先上调用名为methodName方法。
SendMessage 在这游戏物体的每个MonoBehaviour上调用名为
methodName方法。
BoradcastMessage  在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
继承的类函数
Operator bool 这个物体存在吗？
Instatiate  克隆original物体并返回这个克隆。
Destroy  移除一个游戏物体，组件或资源。
DestroyImmediate立即销毁物体obj。强烈建议使用Destroy代替
FindObjectsOfType返回所有类型为type的激活物体。
FindObjectOfType返回第一个类型为type的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
collider
类，继承自Component
所有碰撞器的基类
参见：BoxCollider,SphereCollider,CapsuleCollider,MeshCollider,PhysicCollider,Rigidbody.
如果你打算经常移动一个碰撞器，建议再附加一个运动学刚体。
变量
◆var attachedRigidbody:Rigidbody
描述：该碰撞器所附加的刚体。
如果碰撞器附加到非刚体上返回null。
碰撞器被自动链接到刚体，这个刚体附加在与碰撞器相同的游戏物体或者父游戏物体上。
//升起附加在碰撞器上的刚体
Collider.attachedRigidbody.AddForce(1,0,1);
◆var bounds:Bounds
描述：碰撞器在世界空间中的包围盒
◆var isTrigger:bool
描述：该碰撞器是一个触发器？
触发器不会与刚体碰撞，当刚体进入或离开这个触发器时，触发器将发送OnTriggerEnter
OnTriggerExit和OnTriggerStay.
 //将附加的碰撞器转化为一个触发器
 Collider.isTrigger=true;
◆var material:PhysicMaterial
描述：该碰撞器使用的材质。
如果材质被碰撞器共享，它将复制材质并将它赋给碰撞器。
//让碰撞器你冰一样
Collider.material.dynamicFriction=0;
collider.material.staticFricton=0;
◆var sharedMaterial:PhysicMaterial
描述：该碰撞器的共享物理材质。
修改这个材质将改变所有使用这个材质的碰撞器的表面属性。大多数情况下，你只要修改Collider.material。
Var material:PhysicMaterial;
Collider.shareMaterial=material;
函数
◆function ClosestPointOnBounds(position:Vector3):Vector3
描述：到碰撞器包围上最近的点。
这可以用来计算受到爆炸伤害时伤害点数。
var hitPoints=100.0;
function ApplyHitPoint(explosionPos:Vector3,radius:float){
 //从爆炸位置到刚体表面的距离
 var closetPoint=collider.ClosePointOnBounds(explosionPos);
 var distance=Vector3f.Distance(closestPoint,explosionPos);
 //伤害点数随着到伤害点的距离而降低
 Var hitPoints=1.0-Math.Clamp0|(distance/radius);
 //这是我们要用的最终伤害点数。最大为10
 hitPoints=10;
}
◆function Raycast(ray:Ray,outhitInfo:RaycastHIt,distance:float):bool
参数
ray   射线的开始点和方向。
hitInfo  如果没有近回真，hitInfo将包含更多关于碰撞器被碰到什么地方的信息（参考：
RaycastHit）.
Distance 射线的长度
返回：布尔值-当射线碰到任何碰撞器时为真，否则为假。
描述：投射一个Ray,它忽略所有碰撞器除了这个。
同上使用ray.origin和ray.direction而不是origin和disrection.
var ray=Camera.main.ScreenPointToRay(Input.mousePostion);
var hit:RaycastHit;
if(collider.Raycast(ray,hit,100){
 Debug.drawLine(ray.origin,hit.point);
}
消息传递
◆function OnCollisionEnter(collisionInfo:Collision):void
描述：当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时OnCollisionEnter被调用。
相对于OnTriggerEnter,OnCollisionEnter传递Collision类而不是Collider.Collision类包含接触点，碰撞器速度等细节。如果在函数中不使用CollisionInfo,省略collisionInfo参数以避免不必要的计算。注意如果碰撞器附加了一个非动力学刚体，也只发送碰撞事件。
◆Function OnCollisionEnter(collision:Collision){
//调试绘制所有的接触点和法线
for(var contact:ContacePoint in collision.contacts){
  Debug.DrawRay(contact.point,contact.normal,color.white);
 }
 //如果碰撞物体有较大的冲击就播放声音
 If(collision.relativeVelocity.magnitude.2)
  Audio.Play();
 }
 //一枚手榴弹
 //在击中一个表面时初始化一个爆炸预设
 //然后销毁它
 var exploionPrefab:Transform;
 function OnCollisionEnter(collision:Collision){
  //旋转这个物体使y轴面向沿着表面法线的方向
  var contact=collision.contact[0];
  var rot=Quaternion.FromToRotation(Vector3.up,contact.normal);
  var pos=contact.point;
  Instantiate(exploionPrefab,pos,rot);
  Destroy(gameObject);
 }
◆function OnCollisionExit(collisionInfo:Collision):void
描述：当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit被调用。
相当于OnTriggerExit,OnCollisionExit传递Collision类而不是Collider.Collision类包含接触
点，碰撞速度等细节。如果在函数中不使用collisionInfo，省略collisionInfo参数以避免不必要的计算，注意如果碰撞器附加了一个非动力学刚体，也只发关碰撞事件。
function OnCollisionExit(collisionInfo:Collision){
 print(“No longer in contact with”+collisionInfo.transform.name);
}
◆function OnCollisionStay(collisionInfo:Collision):void
描述：对于每个与刚体/碰撞器相触碰的碰撞器/刚体，OnCollisionStay将在每一帧中被调用。
相当于OnTriggerStay,OnCollisionStay传递Collision类而不是Collider.Collision类包含接
触点，碰撞速度等细节。如果在函数中不使用collisionInfo，省略collisionInfo参数以避免
不必要的计算。注意如果碰撞器附加了一个非动力学刚体，也只发送碰撞事件。
 function OnCollisionStay(collisionInfo:Collision){
  //调试绘制所有的接触点和法线
  for(var contact:ContactPoint in collision.contacts){
Debug.DrawRay(contact.point,contact.normal,color.white);
  }
}
◆function OnTriggerEnter(other:Collider):void
描述：当这个Collider other进入trigger时OnTriggerEnter被调用。
这个消息被发送到这个触发器碰撞器和接触到触发器的刚体（或者是碰撞器如果没有刚体）。注意如果碰撞器附加了一个

刚体，也只发送触发器事件。
//销毁所有进入该触发器的物体
 function OnTriggerEnter(other:Collider){
  Destroy(other.gameObject);
 }
◆function OnTriggerExit(other:Collider):void
描述：当这个Collider other停止触碰trigger时OnTriggerExit被调用。
 这个消息被发送到触发器和拉触到这个触发器的碰撞器。注意如果碰撞器附加了一个
刚体，也只发送触发器事件。
 销毁所有离开该触发器的物体
 function OnTriggerExit(other:Collider){
  Destroy(other.gameObject);
 }
◆function OnTriggerStay(other:collider):void
描述：对于每个Collider other,当它触碰到trigger 时，OnTriggerStay会在每一帧中都被调用。
这个消息被发送到触发器和接触到这个触发器的碰撞器。注意如果碰撞器附加了一个刚体，也只发送触发器事件。
//对所进入这个触发器的刚体使用一个向上的力
function OnTriggerStay(other:Collider){
 if(other.atachedRigidbody){
  other.attachedRigidbody.AddForce(Vector3.up*10);
 }
}
继承的成员
继承的变量
transform附加到这个GameObject的Transform（如果没有为null）。
rigidbody附加到这个GameObject的Rigidbody（如果没有为null）。
camera 附加到这个GameObject的Camera（如果没有为null）。
light  附加到这个GameObject的Light（如果没有为null）。
animation附加到这个GameObject的Animation（如果没有为null）。
constantForce附加到这个GameObject的ConstantForce（如果没有为null）。
Renderer 附加到这个GameObject的Renderer（如果没有为null）。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView附加到这个GameObject的NetworkView（如果没有为null）。
Collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag  这个游戏的标签。
name 对象的名称。
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改？
继承的函数
GetComponet返回type类型的组件，如果游戏物体上附加一个，如果没有返
                      回null。
GetComponentInchildren 返回type类型的组件，这个组件位于GameObject或者任何它的子物体上，使用深度优先搜索。
GetComponentsInchildren 返回所有type类型的组件，这些组件位于GameObject或者任何它的子物体上。
 
GetComponets返回Gameobject所有type类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards  在这游戏物体的每个MonoBehaviour和该行为的组先上调用名为methodName方法。
SendMessage 在这游戏物体的每个MonoBehaviour上调用名为
methodName方法。
BoradcastMessage  在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
继承的类函数
Operator bool 这个物体存在吗？
Instatiate  克隆original物体并返回这个克隆。
Destroy  移除一个游戏物体，组件或资源。
DestroyImmediate立即销毁物体obj。强烈建议使用Destroy代替
FindObjectsOfType返回所有类型为type的激活物体。
FindObjectOfType返回第一个类型为type的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。

BosCollider

类，继承自Collider
 一个盒状的简单碰撞器
 参见：SphereCollider,copsuleCollider,PhysicMaterial,Rigidbody
变量
◆var center:vector3
描述：box的中心，基于物体局部空间。
//重置中心到变换的位置
collider.center=Vector3.zero;
◆var size:Vector3
描述：box的尺寸，基于物体局部空间
 该box的尺寸将随着变换的缩放面缩放。
 //使这个box碰撞器变长
 collider.size=Vector3(10,1,1);
继承的成员
继承的变量
attachedRigidbody 该碰撞器所附加的刚体。
isTrigger该碰撞器是一个触发器？
material 该碰撞器使用的材质。
sharedMaterial  该碰撞器的共享物体材质。
bounds 碰撞器在世界空间中包围盘。
Transform附加到这个GameObject的Transform（如果没有为null）。
Rigidbody附加到这个GameObject的Rigidbody（如果没有为null）。
Camera 附加到这个GameObject的Camera（如果没有为null）。
Light  附加到这个GameObject的Light（如果没有为null）。
Animation附加到这个GameObject的Animation（如果没有为null）。
constantForce附加到这个GameObject的ConstantForce（如果没有为null）。
Renderer 附加到这个GameObject的Renderer（如果没有为null）。
audio 附加到这个GameObject的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView附加到这个GameObject的NetworkView（如果没有为null）。
Collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag  这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改？
 继承的函数
 ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
 Raycast 投射一个Ray，它忽略所有的碰撞器除了这个。
GetComponet  返回type类型的组件，如果游戏物体上附加一个，如果没有返回null。
GetComponentInchildren 返回type类型的组件，这个组件位于GameObject或者任何它的子物体上，使用深度优先搜索。
GetComponentsInchildren 返回所有type类型的组件，这些组件位于GameObject或者任何它的子物体上。
GetComponets返回Gameobject所有type类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards  在这游戏物体的每个MonoBehaviour和该行为的组先上调用名为methodName方法。
SendMessage 在这游戏物体的每个MonoBehaviour上调用名为
methodName方法。
BoradcastMessage  在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
 继承的消息传递
 OnTriggerEnter当这个Collider other进入trigger进OnTriggerEnter被调用。
 
OnTriggerExit  当这个Collider other停止触碰trigger时OnTriggerExit被调用。
 OnTriggerStay  对于每个Collider other，当它触碰到trigger时，OnTriggerStay会
  在每一帧中都被调用。
 OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
  OnCollisionEnter被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用
 OnCollisionStay 对于每个与刚体/碰撞器相触碰的碰撞器/刚体OnCollisionStay将在每
  一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗？
Instatiate  克隆original物体并返回这个克隆。
Destroy  移除一个游戏物体，组件或资源。
DestroyImmediate立即销毁物体obj。强烈建议使用Destroy代替
FindObjectsOfType返回所有类型为type的激活物体。
FindObjectOfType返回第一个类型为type的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
CapsuleCollider
 类，继承自Collider
 一个胶囊状的简单碰撞器
 Capsules是术状的并在每端有一个半球。
 参见：BoxCollider,SphereCollder，PhysicMaterial,Rigidbody
变量
◆var center:vector3
描述：胶囊的中心，基于物体的局部空间。
//重置中心到变换的位置
collider.center=Vector3.zero;
◆var direction:int
描述：胶囊的方向
0->胶囊的高度沿着x轴。1->胶囊的高度沿着y轴。2->胶囊的高度沿着z轴。
//使胶囊的高度沿着x轴
collider.direction=0;
◆var height:float
描述：胶囊的高度，基于物体的局部空间
该胶囊的高度将随着变换的缩放而缩放。注意height为包含两端两个半球的实际高度。
collider.height=5;
◆var radius:float
描述：球的半径，基于物体的局部空间。
该胶囊的半径随着变换的缩放而缩放。
collider.radius=1;
继承的成员
继承的变量
attachedRigidbody  该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器？
material 该碰撞器使用的材质。
sharedMaterial  该碰撞器的共享物体材质。
bounds 碰撞器在世界空间中包围盘。
Transform附加到这个GameObject的Transform（如果没有为null）。
Rigidbody附加到这个GameObject的Rigidbody（如果没有为null）。
Camera 附加到这个GameObject的Camera（如果没有为null）。
Light  附加到这个GameObject的Light（如果没有为null）。
Animation附加到这个GameObject的Animation（如果没有为null）。
constantForce附加到这个GameObject的ConstantForce（如果没有为null）。
Renderer 附加到这个GameObject的Renderer（如果没有为null）。
audio 附加到这个GameObject的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView附加到这个GameObject的NetworkView（如果没有为null）。
Collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag  这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改？

继承的函数

ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
 Raycast 投射一个Ray，它忽略所有的碰撞器除了这个。
GetComponet  返回type类型的组件，如果游戏物体上附加一个，如果没有返回null。
GetComponentInchildren 返回type类型的组件，这个组件位于GameObject或者任何它的子物体上，使用深度优先搜索。
GetComponentsInchildren 返回所有type类型的组件，这些组件位于GameObject或者任何它的子物体上。
GetComponets返回Gameobject所有type类型的组件。
 
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards  在这游戏物体的每个MonoBehaviour和该行为的组先上调用名为methodName方法。
SendMessage 在这游戏物体的每个MonoBehaviour上调用名为
methodName方法。
BoradcastMessage  在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
 继承的消息传递
 OnTriggerEnter当这个Collider other进入trigger进OnTriggerEnter被调用。
 OnTriggerExit  当这个Collider other停止触碰trigger时OnTriggerExit被调用。
 OnTriggerStay  对于每个Collider other，当它触碰到trigger时，OnTriggerStay会
  在每一帧中都被调用。
 OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
  OnCollisionEnter被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用
 OnCollisionStay 对于每个与刚体/碰撞器相触碰的碰撞器/刚体OnCollisionStay将在每
  一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗？
Instatiate  克隆original物体并返回这个克隆。
Destroy  移除一个游戏物体，组件或资源。
DestroyImmediate立即销毁物体obj。强烈建议使用Destroy代替
FindObjectsOfType返回所有类型为type的激活物体。
FindObjectOfType返回第一个类型为type的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。

CharactController
 类，继承自Collider
 CharacterController允许你很容易地做受到碰撞制约的移动，而无需处理刚体。
 CharacterController不会受力, 的影响，并且只有在调用 Move函数时才会移动，然后这个控制器将实现移动，但是会受到碰撞的制约。
 参见：Character Controller component和Character animation examples
变量
◆var center:Vector3
描述：角色胶囊相对于变换的位置的中心。
 //向上移动胶囊的中心
 var Controller. CharacterController=GetComponent(CharacterController);
controller.center=Vector3(0,1,0);
◆var collisionFlags:CollisionFlags
描述：在最后一次调用CharacterController.Move时，胶囊的哪个部分与环境发生了碰撞。
function Update(){
 var controller:CharacterController=GetComponent(CharacterController);
 if((controller collisionFlags&collisionFlags.Above)!=0)
  print(“touched the celling”);
}
◆var detectCollisions:bool
描述：其他刚体或角色控制器应该与这个角色控制器碰撞吗（默认总是启用的）？
 这个方法不会影响角色移动时的碰撞检测。它控制角色和其他物体之间的碰撞。例如，
一个箱子可以阻止控制器的运动，但是作为模拟的一部分这个箱子可以进入控制器。这可以用于临时禁用角色控制器。例如，你也许想装载角色到汽车上并禁用碰撞直到再次退出汽车。注意这只影响其他没有与碰撞的物体。detectCollisions不是可序列化的。也就说，它不会显示要检视面板中并且当在场景中实例化或保存这个控制器时，它将不被保存。
 GetComponent(CharacterController).detectCollisions=false;
◆var height:float
描述：这个胶囊的高度
//设置控制器的高度为2.0
var controller:CharacterController=GetComponent(CharacterController);
controller.height=2.0;
◆var isGrounded:bool
描述：CharacterController上一次移动的时候是否接触地面？
function Update(){
 var controller.CharacterController=GetComponent(CharacterController);
 if(controller.isGronded){
  print(“We are grounded”)
 }
}
◆var radius:float
描述：角色胶囊的半径
//这只控制器的半径为0.3
var controller:CharacterController=GetComponent(CharacterController);
controller.radius=0.3;
◆var slopLimit:float
描述：角色控制器的斜度限制
//设置控制器的斜度限制为45
var controller:CharacterController=GetComponent(CharacterController);
controller.slopLimit=45.0;
◆var stepOffset:float
描述：角色控制器的步高，以米为单位。
//这只控制器的步高为2.0
var controller:CharacterController=GetComponent(CharacterController);
controller.stepOffset=2.0;
◆var velocity:Vector3
描述：角色的当前速度
这允许你知道角色实际的行走有多快，例如当它碰到墙时这个值为零向量
function Update(){
  var controller:CharacterController=GetComponent(CharacterController);
  var horizontalVelocity=controller.velocity;
  horizontalVelocity=0;
  //x-z平面上的速率，忽略其他任何速率
  var horizontalSpeed= horizontalVelocity.y;
  //整体速率
  var overallSpeed=controller.velocity.magnitude;
}
函数
◆function Move(motion:Vector3):CollisionFlags
描述：一个更复杂的移动函数，可以使用绝对移动增量。
试图由motion来移动控制器，这个运动只受制于碰撞，它将沿着碰撞器滑动，
collisionFlags为移动期间所发生的碰撞总和。这个函数不使用任何重力。
//这个脚本基于方向键向前
//和两边移动角色控制器
//按下空格后它也会跳跃
//确保这个与角色控制器附加在同一个游戏物体上
var speed = 6.0;
var jumpSpeed = 8.0;
var gravity = 20.0;
private var moveDirection = Vector3.zero;
function FixedUpdate() {
var controller : CharacterController = GetComponent(CharacterController);
if (controller.isGrounded) {
//我们在地面上，因此重计算
//直接沿轴方向移动
moveDirection = Vector3(Input.GetAxis("Horizontal"), 0,
Input.GetAxis("Vertical"));
moveDirection = transform.TransformDirection(moveDirection);
moveDirection *= speed;
if (Input.GetButton ("Jump")) {
moveDirection.y = jumpSpeed;
}
}
// 使用重力
moveDirection.y -= gravity * Time.deltaTime;
// 移动控制器
controller.Move(moveDirection * Time.deltaTime);
}
◆function SimpleMove(speed:Vector3);bool
描述：以speed移动角色
沿着y轴的速度将忽略。速度单位m/s，重力被自动应用。返回角色是否在地面
上。
var speed = 3.0;
var rotateSpeed = 3.0;
function Update (){
 var controller : CharacterController = GetComponent(CharacterController);
 // Rotate around y - axis
 transform.Rotate(0, Input.GetAxis ("Horizontal") * rotateSpeed, 0);
 // Move forward / backward
 var forward = transform.TransformDirection(Vector3.forward);
 var curSpeed = speed * Input.GetAxis ("Vertical");
 controller.SimpleMove(forward * curSpeed);
}
 @script RequireComponent(CharacterController)
消息传递
◆function OnControllerColliderHit(hit:ControllerColliderHit):void
描述：在移动的时候，控制器碰到一个碰撞器时，OnControllerColliderHit被调用。
这可以用来在角色碰到物体时推开物体。
//这个脚本推开所有碰到的刚体
var pushPower = 2.0;
function OnControllerColliderHit (hit : ControllerColliderHit){
 var body : Rigidbody = hit.collider.attachedRigidbody;
 // 无刚体
 if (body == null || body.isKinematic)
  return;
 // 不推开我们身后的物体
 if (hit.moveDirection.y < -0.3) 
  return;
 //从移动方向计算推的方向
 // 只推开物体到旁边而不是上下
 var pushDir = Vector3 (hit.moveDirection.x, 0, hit.moveDirection.z);
 //如果知道角色移动有多快
 //然后你就可以用它乘以推动速度
 //使用推力
 body.velocity = pushDir * pushPower;
}
继承的成员
继承的变量
attachedRigidbody  该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器？
material 该碰撞器使用的材质。
sharedMaterial  该碰撞器的共享物体材质。
bounds 碰撞器在世界空间中包围盘。
Transform附加到这个GameObject的Transform（如果没有为null）。
Rigidbody附加到这个GameObject的Rigidbody（如果没有为null）。
Camera 附加到这个GameObject的Camera（如果没有为null）。
 
Light  附加到这个GameObject的Light（如果没有为null）。
Animation附加到这个GameObject的Animation（如果没有为null）。
constantForce附加到这个GameObject的ConstantForce（如果没有为null）。
Renderer 附加到这个GameObject的Renderer（如果没有为null）。
audio 附加到这个GameObject的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView附加到这个GameObject的NetworkView（如果没有为null）。
Collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag  这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改？
 继承的函数
 ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
 Raycast 投射一个Ray，它忽略所有的碰撞器除了这个。
GetComponet  返回type类型的组件，如果游戏物体上附加一个，如果没有返回null。
GetComponentInchildren 返回type类型的组件，这个组件位于GameObject或者任何它的子物体上，使用深度优先搜索。
GetComponentsInchildren 返回所有type类型的组件，这些组件位于GameObject或者任何它的子物体上。
GetComponets返回Gameobject所有type类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards  在这游戏物体的每个MonoBehaviour和该行为的组先上调用名为methodName方法。
SendMessage 在这游戏物体的每个MonoBehaviour上调用名为
methodName方法。
BoradcastMessage  在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
 继承的消息传递
 OnTriggerEnter 当这个Collider other进入trigger进OnTriggerEnter被调用。
 OnTriggerExit  当这个Collider other停止触碰trigger时OnTriggerExit被调用。
 OnTriggerStay  对于每个Collider other，当它触碰到trigger时，OnTriggerStay会
  在每一帧中都被调用。
 OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
  OnCollisionEnter被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用.
OnCollisionStay对于每个与刚体/碰撞器相触碰的碰撞器/刚体
OnCollisionStay将在每一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗？
Instatiate  克隆original物体并返回这个克隆。
Destroy  移除一个游戏物体，组件或资源。
DestroyImmediate立即销毁物体obj。强烈建议使用Destroy代替
FindObjectsOfType返回所有类型为type的激活物体。
FindObjectOfType返回第一个类型为type的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
MeshCollider
 类，继承自Collider
 网格碰撞器允许人在网格和几何体之间进行碰撞检测。
 参见：BosCollider,CapsuleCollider,PhysicMaterial,Rigidbody

变量
◆var convex:bool
描述：为这个网格将使用一个凸碰撞器。
凸网格可以与其他凸碰撞器和非凸网格碰撞。因此凸网格碰撞器适用于刚体，如果你真的需要比几何碰撞器更多的详细的碰撞信息，可以使用这个。
◆var shareMesh:mesh
描述：用于碰撞检测的网格物体。
◆var smoothSphereCollision:bool
描述：为球形碰撞使用插值法线而不是平面多边形法线。
这可以让球体在平面上的滚动更加更滑。缺点是在从陡峭的角度滚落时，它的行为非常奇怪，显得有拉动某个方向的的球体。
继承的成员
继承的变量
attachedRigidbody  该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器？
material 该碰撞器使用的材质。
sharedMaterial  该碰撞器的共享物体材质。
bounds 碰撞器在世界空间中包围盘。
Transform附加到这个GameObject的Transform（如果没有为null）。
Rigidbody附加到这个GameObject的Rigidbody（如果没有为null）。
Camera 附加到这个GameObject的Camera（如果没有为null）。
Light  附加到这个GameObject的Light（如果没有为null）。
Animation附加到这个GameObject的Animation（如果没有为null）。
constantForce附加到这个GameObject的ConstantForce（如果没有为null）。
Renderer 附加到这个GameObject的Renderer（如果没有为null）。
audio 附加到这个GameObject的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView附加到这个GameObject的NetworkView（如果没有为null）。
Collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag  这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改？
 继承的函数
 ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
 Raycast 投射一个Ray，它忽略所有的碰撞器除了这个。
GetComponet  返回type类型的组件，如果游戏物体上附加一个，如果没有返回null。
GetComponentInchildren 返回type类型的组件，这个组件位于GameObject或者任何它的子物体上，使用深度优先搜索。
GetComponentsInchildren 返回所有type类型的组件，这些组件位于GameObject或者任何它的子物体上。
GetComponets返回Gameobject所有type类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards  在这游戏物体的每个MonoBehaviour和该行为的组先上调用名为methodName方法。
SendMessage 在这游戏物体的每个MonoBehaviour上调用名为
methodName方法。
BoradcastMessage  在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
 继承的消息传递
 OnTriggerEnter  当这个Collider other进入trigger进OnTriggerEnter被调用。
 OnTriggerExit当这个Collider other停止触碰trigger时OnTriggerExit被调用。
OnTriggerStay对于每个Collider other，当它触碰到trigger时，
 会在每一帧中都被调用。
OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
  OnCollisionEnter被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用.
OnCollisionStay 对于每个与刚体/碰撞器相触碰的碰撞器/刚体
 OnCollisionStay将在每一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗？
Instatiate  克隆original物体并返回这个克隆。
Destroy  移除一个游戏物体，组件或资源。
DestroyImmediate立即销毁物体obj。强烈建议使用Destroy代替
FindObjectsOfType返回所有类型为type的激活物体。
FindObjectOfType返回第一个类型为type的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
RaycastCollider
 类，继承自Collider
 基于碰撞的一个线。
 Raycast碰撞器主要用于模型汽车，气垫船和船因为它们提供更精确的碰撞检测。然而，对于轮式交通工具，建议使用WheelCollider。
 一个Raycast碰撞器总是沿着本地y轴向下投射一个射线。Raycast碰撞器在与设置为具有弹性的物理材质组全时是最有用的。
变量
◆var center:Vector3
描述：胶囊的中心，基于物体的局部空间。
//重置中心到变换的位置
collider.center=Vector3.zero;
◆var length:float
 描述：本地空间的射线的长度，射线将发射
从center沿着变换的负y轴，length将随着变换的缩放而缩放
collider.length=2;
继承的成员
继承的变量
attachedRigidbody  该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器？
material 该碰撞器使用的材质。
sharedMaterial  该碰撞器的共享物体材质。
bounds 碰撞器在世界空间中包围盘。
Transform附加到这个GameObject的Transform（如果没有为null）。
Light  附加到这个GameObject的Light（如果没有为null）。
Animation附加到这个GameObject的Animation（如果没有为null）。
constantForce附加到这个GameObject的ConstantForce（如果没有为null）。
Renderer 附加到这个GameObject的Renderer（如果没有为null）。
audio 附加到这个GameObject的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView附加到这个GameObject的NetworkView（如果没有为null）。
Collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag  这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改？
 继承的函数
 ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
 Raycast 投射一个Ray，它忽略所有的碰撞器除了这个。
GetComponet  返回type类型的组件，如果游戏物体上附加一个，如果没有返回null。
GetComponentInchildren 返回type类型的组件，这个组件位于GameObject或者任何它的子物体上，使用深度优先搜索。
GetComponentsInchildren 返回所有type类型的组件，这些组件位于GameObject或者任何它的子物体上。
GetComponets返回Gameobject所有type类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards  在这游戏物体的每个MonoBehaviour和该行为的组先上调用名为methodName方法。
SendMessage 在这游戏物体的每个MonoBehaviour上调用名为
methodName方法。
BoradcastMessage  在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
 继承的消息传递
 OnTriggerEnter 当这个Collider other进入trigger进OnTriggerEnter被调用。
 OnTriggerExit  当这个Collider other停止触碰trigger时OnTriggerExit被调用。
OnTriggerStay  对于每个Collider other，当它触碰到trigger时，OnTriggerStay会
  在每一帧中都被调用。
 OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
  OnCollisionEnter被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用.
OnCollisionStay对于每个与刚体/碰撞器相触碰的碰撞器/刚体
OnCollisionStay将在每一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗？
Instatiate  克隆original物体并返回这个克隆。
Destroy  移除一个游戏物体，组件或资源。
DestroyImmediate立即销毁物体obj。强烈建议使用Destroy代替
FindObjectsOfType返回所有类型为type的激活物体。
FindObjectOfType返回第一个类型为type的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
SphereCollider
 类继承自Collider
 一个球形的几何碰撞器
 参见：BoxCollider，CapsuleCollider，Physic Material，Rigidbody
变量
◆var center:Vector3
描述：球的中心，基于物体的局部空间。
//重置中心到变换的位置
Collider.center=Vector3.zero;
◆var radius:float
描述：球的半径，基于物体的局部空间。
球体随着变换的缩放而缩放
collider.radius=10;
继承的成员
继承的变量
attachedRigidbody  该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器？
material 该碰撞器使用的材质。
sharedMaterial  该碰撞器的共享物体材质。
Transform附加到这个GameObject的Transform（如果没有为null）。
Light  附加到这个GameObject的Light（如果没有为null）。
Animation附加到这个GameObject的Animation（如果没有为null）。
constantForce附加到这个GameObject的ConstantForce（如果没有为null）。
Renderer 附加到这个GameObject的Renderer（如果没有为null）。
audio 附加到这个GameObject的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView附加到这个GameObject的NetworkView（如果没有为null）。
Collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag  这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改？
 继承的函数
 ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
 Raycast 投射一个Ray，它忽略所有的碰撞器除了这个。
GetComponet  返回type类型的组件，如果游戏物体上附加一个，如果没有返回null。
GetComponentInchildren 返回type类型的组件，这个组件位于GameObject或者任何它的子物体上，使用深度优先搜索。
GetComponentsInchildren 返回所有type类型的组件，这些组件位于GameObject或者任何它的子物体上。
GetComponets返回Gameobject所有type类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards  在这游戏物体的每个MonoBehaviour和该行为的组先上调用名为methodName方法。
SendMessage 在这游戏物体的每个MonoBehaviour上调用名为
methodName方法。
BoradcastMessage  在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
 继承的消息传递
 OnTriggerEnter 当这个Collider other进入trigger进OnTriggerEnter被调用。
 OnTriggerExit  当这个Collider other停止触碰trigger时OnTriggerExit被调用。
 OnTriggerStay  对于每个Collider other，当它触碰到trigger时，OnTriggerStay会
在每一帧中都被调用。
 OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
  OnCollisionEnter被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用.
OnCollisionStay对于每个与刚体/碰撞器相触碰的碰撞器/刚体
OnCollisionStay将在每一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗？
Instatiate  克隆original物体并返回这个克隆。
Destroy  移除一个游戏物体，组件或资源。
DestroyImmediate立即销毁物体obj。强烈建议使用Destroy代替
FindObjectsOfType返回所有类型为type的激活物体。
FindObjectOfType返回第一个类型为type的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
TerrainCollider
类，继承自Collider
基于高度图的碰撞器。
变量
◆var terrainData:TerrainData
描述：存储高度图的地形
继承的成员
继承的变量
attachedRigidbody  该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器？
material 该碰撞器使用的材质。
sharedMaterial  该碰撞器的共享物体材质。
bounds 碰撞器在世界空间中包围盘。
Transform附加到这个GameObject的Transform（如果没有为null）。
Light  附加到这个GameObject的Light（如果没有为null）。
Animation附加到这个GameObject的Animation（如果没有为null）。
constantForce附加到这个GameObject的ConstantForce（如果没有为null）。
Renderer 附加到这个GameObject的Renderer（如果没有为null）。
audio 附加到这个GameObject的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView附加到这个GameObject的NetworkView（如果没有为null）。
Collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag  这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改？
 继承的函数
 ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
 Raycast 投射一个Ray，它忽略所有的碰撞器除了这个。
GetComponet  返回type类型的组件，如果游戏物体上附加一个，如果没有返回null。
GetComponentInchildren 返回type类型的组件，这个组件位于GameObject或者任何它的子物体上，使用深度优先搜索。
GetComponentsInchildren 返回所有type类型的组件，这些组件位于GameObject或者任何它的子物体上。
GetComponets返回Gameobject所有type类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards  在这游戏物体的每个MonoBehaviour和该行为的组先上调用名为methodName方法。
SendMessage 在这游戏物体的每个MonoBehaviour上调用名为
methodName方法。
BoradcastMessage  在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
 继承的消息传递
 OnTriggerEnter 当这个Collider other进入trigger进OnTriggerEnter被调用。
 OnTriggerExit  当这个Collider other停止触碰trigger时OnTriggerExit被调用。
 OnTriggerStay  对于每个Collider other，当它触碰到trigger时，OnTriggerStay会
  在每一帧中都被调用。
 OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
  OnCollisionEnter被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用.
OnCollisionStay对于每个与刚体/碰撞器相触碰的碰撞器/刚体
OnCollisionStay将在每一帧中被调用。

继承的类函数
Operator bool 这个物体存在吗？
Instatiate  克隆original物体并返回这个克隆。
Destroy  移除一个游戏物体，组件或资源。
DestroyImmediate立即销毁物体obj。强烈建议使用Destroy代替
FindObjectsOfType返回所有类型为type的激活物体。
FindObjectOfType返回第一个类型为type的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
WheelCollider
 类，继承自Collider
 用于车轮的特殊碰撞器。
 车轮的碰撞器用来模拟车轮。它的功能类似与RaycastCollider，但是还有车轮物理和基于轮胎摩擦力模拟的滑动。在大多数情况下WheelCollider是更精确的也更容易使用的。
 车轮的碰撞检测是通过从center沿着局部Y轴向下投射一个射线进行的。车轮有一个radius并可以通过suspensionDistance向下扩展。
 车轮使用motoTorque,brakeTorque和steerAngle属性控制。
 车轮碰撞器使用不同于物理引擎的一个基于滑动的摩擦力模型来计算摩擦力。这允许更加真实的行为。而且使车轮忽略标准的PhysiMaterial设置。通过改变车轮所碰到的
rorwardFriction和 sidewaysFriction来模拟不同的路面材质。参见：GetGroundHit和
WheelFrictionCurve。
变量
◆var brakeTorque:float
描述：制动的力矩。必须为正
//制动车轮
collider.brakeTorque=1000；
◆var center:vector3
描述：车轮的中心，基于物体的局部空间。
//重置中心到变换的位置
collider.center=Vector.zero;
◆var forwardFriction:WheelFrictionCurve
描述；在轮胎所指向上的摩擦力属性
◆var isGrounded:bool
描述：表示当前车轮是否与什么东西发生碰撞（只读）
◆var mass:float
描述：车轮的质量必须比0大
collider.mass=1;
◆var motorTorque:float
描述：车轮上的动力力矩。正负根据方向而定。
为了模拟制动，不要使用负的动力力矩，而使用brakeTorque
//向前旋转的车轮
collider.motorTorque=10;
◆var radius:float
描述：本地空间的车轮的半径。
半径将随着变换的缩放而缩放。
collider.radius=5;
◆var rpm:float
描述：当前车轮轴的旋转速度，以旋转/秒（只读）
◆var sidewaysFriction:WheelfrictionCurve
描述：侧向的轮胎摩擦力属性。
◆var steerAngle:float
描述：转向的角度，总是绕着本地y轴。
//转向前
collider.steerAngle=0;
较高的速率使用小的转向角：一点角度就足够了。
◆var suspensionDistance:float
描述：在局部空间下，车轮悬挂的最大扩展距离。
悬挂总是沿着本地y轴向下扩展。悬挂过程将随着变换的缩放而缩放。
collider.susensionDistance:=0.1;
◆var suspensionSpring:JointSring
描述：车轮悬挂的参数。悬挂视图到达一个目标的位置
通过添加弹簧和阴尼力。
suspensionSpring.spring力视图到达这个目标的位置。较大的值使得悬挂更快到达目标
位置。
suspensionSpring.damer力阻尼悬挂速度。较大的值使得悬挂更慢到达目标。
 悬挂试图到达suspensionSpring.targetPositon.它是悬挂沿着suspensionDistance的剩余长度。零值表示完全扩展。1表示完全压缩，缺省的值为0，它匹配于常规汽车的悬挂行为。
函数
◆function GetGroundHit(out hit:WheelHit):bool
描述：获取轮胎的地面碰撞数据。
如果车轮碰撞器与某些物体发生了碰撞，返回true并填充hit结构。如果车轮没有碰撞。
返回false并保持hit结构不变。
报告的hit总是最接近的一个，因为轮胎摩擦力模型不会自动响应其他的physicMaterial。
任何对不同地面材质的模拟必须基于这里所返回的碰撞器材质来手动调整forwordFriction和sidewayFriction完成。
继承的成员
继承的变量
attachedRigidbody  该碰撞器所附加的刚体。
isTrigger 该碰撞器是一个触发器？
material 该碰撞器使用的材质。
sharedMaterial  该碰撞器的共享物体材质。
bounds 碰撞器在世界空间中包围盘。
Transform附加到这个GameObject的Transform（如果没有为null）。
Light  附加到这个GameObject的Light（如果没有为null）。
Animation附加到这个GameObject的Animation（如果没有为null）。
constantForce附加到这个GameObject的ConstantForce（如果没有为null）。
Renderer 附加到这个GameObject的Renderer（如果没有为null）。
audio 附加到这个GameObject的AudioSourec(如果没有为null)。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView附加到这个GameObject的NetworkView（如果没有为null）。
Collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag  这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改？
 继承的函数
 ClosestPointOnBounds 附加碰撞器到包围盒最近的点。
 Raycast 投射一个Ray，它忽略所有的碰撞器除了这个。
GetComponet  返回type类型的组件，如果游戏物体上附加一个，如果没有返回null。
GetComponentInchildren 返回type类型的组件，这个组件位于GameObject或者任何它的子物体上，使用深度优先搜索。
GetComponentsInchildren 返回所有type类型的组件，这些组件位于GameObject或者任何它的子物体上。
GetComponets返回Gameobject所有type类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards  在这游戏物体的每个MonoBehaviour和该行为的组先
上调
用名为methodName方法。
SendMessage 在这游戏物体的每个MonoBehaviour上调用名为
methodName方法。
BoradcastMessage  在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
 继承的消息传递
 OnTriggerEnter 当这个Collider other进入trigger进OnTriggerEnter被调用。
 OnTriggerExit  当这个Collider other停止触碰trigger时OnTriggerExit被调用。
 OnTriggerStay  对于每个Collider other，当它触碰到trigger时，OnTriggerStay会
  在每一帧中都被调用。
 OnCollisionEnter 当这个碰撞器/刚体开始触碰另一个刚体/碰撞器时
  OnCollisionEnter被调用。
OnCollisionExit 当这个碰撞器/刚体停止触碰另一个刚体/碰撞器时OnCollisionExit
被调用.
OnCollisionStay对于每个与刚体/碰撞器相触碰的碰撞器/刚体
OnCollisionStay将在每一帧中被调用。
继承的类函数
Operator bool 这个物体存在吗？
Instatiate  克隆original物体并返回这个克隆。
Destroy  移除一个游戏物体，组件或资源。
DestroyImmediate立即销毁物体obj。强烈建议使用Destroy代替
FindObjectsOfType返回所有类型为type的激活物体。
FindObjectOfType返回第一个类型为type的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
Joint
类，继承自Comonent
 Joint是所有关节的基类。
 参见：CharacterJoint，HingJoint,SpringJoint.
变量
◆var anchor:Vector3
描述：关节的移动被限制于绕着这个锚点的位置。
定义在本地空间中的位置。
hingeJoint.anchor=Vector3(2,0,0);
◆var axis:Vector3
描述：物体被限制于绕着这个轴的方向旋转。
 定义在本地空间中的轴。
 hingeJoint.axis=Vector3.up;
◆var breakForce:float
描述：需要断开关节的力
力可能来自与其他物体的碰撞，应用到刚体的力。addTorque或来自其他关节。
//当一个大于10的力矩被应用时使用关节断开
hingeJoint.breakForce=10;
//使关节不会被断开
hingeJoint.breakForce=mathf.Infinity;
参见:OnJointBreak
◆var breakTorque:float
描述：需要断开关节的力矩
力矩可能来自与其他物体的碰撞，使用rigidbody.AddTorque或来自其他关节。
//当一个大于10的力矩被应用时使关节断开
hingeJoint.breakTorque=10;
//使关节不会被断开
hingeJoint.breakTorque=mathf.Infinity;
参见：OnJointBreak
◆var connectedBody:Rigidbody
描述：这个关节链接到的另一个刚体的引用。
如果不设置，这个关节将连接物体到世界。
//连接关节到世界而不是其他刚体
hingeJoint.connectedBody=Null;
连接关节到其他物体
var otherBody=Rigidbody;
hingeJoint.connectedBody=otherBody;
消息传递
◆function OnJointBreak(breakForce:float):void
描述：当附加到相同游戏物体上的关节被断开。当关节断开时，OnJointBreak将被调用
，应用到关节的断开力将被传入，OnJointBreak之后这个关节自动从游戏物体移除。参见：
Joint.breakForce
继承的成员
继承的变量
Transform附加到这个GameObject的Transform（如果没有为null）。
Rigidbody附加到这个GameObject的Rigidbody（如果没有为null）。
Camera 附加到这个GameObject的Camera（如果没有为null）。
Light  附加到这个GameObject的Light（如果没有为null）。
Animation附加到这个GameObject的Animation（如果没有为null）。
constantForce附加到这个GameObject的ConstantForce（如果没有为null）。
Renderer 附加到这个GameObject的Renderer（如果没有为null）。
audio            附加到这个GameObject的AudioSouree（如果没有为null）。
guiText          附加到这个GameObject的GUIText（如果没有为null）。
networkView      附加到这个GameObject的NetworkView（只读）（如果没有为null）。
guiTexture       附加到这个GameObject的GUITexture（只读）（如果没有为null）。
collider         附加到这个GameObject的Collider（如果没有为null）。
hingeJoint       附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject       这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag              这个游戏物体的标签。
name             对象的名称。
hideFlags        该物体是否被隐藏。保存在场景中或被用户修改？
继承的函数
GetComponent             返回type类型的组件，如果游戏物体上附加了一个，如果没有返回null。
GetComponentInChildren   返回type类型的组件，这个组件位于GameObject或任何它的子物体上，使用深度优先搜索。
GetComponentsInChildren  返回所有type类型的组件，这些组件位于GameObject或任何它的子物体上。
GetComponents            返回GameObject上所有type类型的组件。
CompareTag               这个游戏物体标签为tag？
SendMessageUpwards       在这个游戏物体的每个MonoBehaviour和该行为的祖先上调用名为methodName方法。
SendMessage              在这个游戏物体的每个MonoBehaviour上调用methodName方法。
BroadcastMessage         在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
继承的类函数
operator bool      这个物体存在吗？
Instantiate        克隆original物体并返回这个克隆。
Destroy            移除一个游戏物体，组件或资源。
DestroyImmediate   立即销毁物体obj。强烈建议使用Destroy代替。
FindObjectsOfType  返回所有类型为type的激活物体。
FindObjectOfType   返回第一个类型为type的激活物体。
operator ==        比较两个物体是否相同。
operator !=        比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
CharacterJoint
类，继承自Joint
Joints的属性主要用于碰撞效果。它们是一个扩展的球窝状joint，允许你限制joint在每个轴上。
变量
◆var highTwistLimit:SoftJointLimit
描述：角色关节原始轴的上限。
这个限制是相对于两个刚体开始模拟时的角度。
◆var lowTwistLimit:SoftJointLimit
描述：角色关节原始轴上的下限。
这个限制是相对于两个刚体开始模拟时的角度。
◆var swing1Limit:SoftJointLimit
描述：在角色关节的原始轴上限制。
限制是对称的。因此，例如30将在此-30到30之间限制是相对于两个刚体开始模拟时的角度。
◆var swing2Limit:SoftJointLimit
描述：在角色关节的原始轴上的限制。
限制是对称的。因此，例如30将在此-30到30之间限制是相对于两个刚体开始模拟时的角度。
◆var swingAxis:vector3
描述：关节可以绕着旋转的第二轴
CharacterJoint.swing1Limit是被允许的绕着这个轴旋转的限制。
继承的成员
继承的变量
Transform附加到这个GameObject的Transform（如果没有为null）。
Rigidbody附加到这个GameObject的Rigidbody（如果没有为null）。
Camera 附加到这个GameObject的Camera（如果没有为null）。
Light  附加到这个GameObject的Light（如果没有为null）。
Animation附加到这个GameObject的Animation（如果没有为null）。
constantForce附加到这个GameObject的ConstantForce（如果没有为null）。
Renderer 附加到这个GameObject的Renderer（如果没有为null）。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView附加到这个GameObject的NetworkView（如果没有为null）。
Collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter  附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
Tag  这个游戏的标签。
Name 对象的名称。
hideFlags 该物体是否被隐藏，保存在场景中或被用户修改？
继承的函数
GetComponet返回type类型的组件，如果游戏物体上附加一个，如果没有返
                      回null。
GetComponentInchildren 返回type类型的组件，这个组件位于GameObject或者任何它的子物体上，使用深度优先搜索。
GetComponentsInchildren 返回所有type类型的组件，这些组件位于GameObject或者任何它的子物体上。
GetComponets返回Gameobject所有type类型的组件。
CompareTag 这游戏物体被标签为tag?
SendMessageUpwards  在这游戏物体的每个MonoBehaviour和该行为的组先上调用名为methodName方法。
SendMessage 在这游戏物体的每个MonoBehaviour上调用名为
methodName方法。
BoradcastMessage  在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。
GetInstanceID            返回该物体的实例id。
继承的类函数
Operator bool 这个物体存在吗？
Instatiate  克隆original物体并返回这个克隆。
Destroy  移除一个游戏物体，组件或资源。
DestroyImmediate立即销毁物体obj。强烈建议使用Destroy代替
FindObjectsOfType返回所有类型为type的激活物体。
FindObjectOfType返回第一个类型为type的激活物体。
Operator== 比较两个物体是否相同。
Operator!= 比较两个物体是否不相同。
DontDestroyOnLoad  加载新场景时确保物体target不被自动销毁。
ConfigurableJoint
 类，继承自Joint
 可配置关节是一种非常灵活的关节，它让你完全控制旋转和线性移动。
 你也可以用它的构建所有其他类型的关节，但是它的设置也是非常复杂的。它让你在每个旋转轴线自由度上完全控制motor.drive和关节限制。
变量
◆var angularXDrive:jointDrive
描述：定义关节的旋转如何绕着局部x轴作用。仅在Rotation Drive Mode 为Swing&
twist时使用。
◆var angularXMotion：configurableJointMotion
描述：根据Low和High Angular Xlimit允许沿着X轴的旋转为free,完全locked或者
limited.
◆var angularYLimit:SoftJointLimit
描述：基于原始旋转的增量定义的旋转约束边界。
◆var angularYMotion:ConfigurableJointMotion
描述：根据Low和High AngularZLimit允许沿着Z轴的旋转为Free，完全Locked或者
Limited。
◆var angularYZDrive:JointDrive
描述：定义的旋转如何绕着局部Y和 Z轴作用。仅在Rotation Drive Mode为Swing&Twist
时使用。
◆var angularZLimit:SoftJointLimit
描述：基于到原始旋转的增量定义的旋转约束边界。
◆var angularZmotion:ConfigurableJointMotion
描述：根据Low和High Angular Zlimit允许沿着Z轴的族转为Free，完全Locked或者
Limited.
◆var configuredInWorldSpace:bool
描述：如果启用，所有目标值将在世界空间中计算而不是物体的局空间。
◆var highAngularXLimit:SoftJointLimit
描述：基于到原始旋转的增量定义的最大旋转约束边界。
◆var linearLimit:SoftJointLimit
基于到关节原点的距离确定的移动约束边界定义。
◆var lowAngularXlimit:SoftJointLimit
基于到原始旋转的增量定义的最小旋转约束边界。
◆var projectionAngle:float
描述：到Connected Body的距离，在物体折回到一个可接受的位置之前必须超过这个距离。
◆var projectionDistance:float
描述：到Connected Body的距离，在物体折回到一个可接受的位置之前必须超过这个距离。
◆var projectionMode:JointProjectionMode
描述：该属性用来在物体偏离太多时候将它回到约束位置。
◆var rotationDriveMode:RotationDriveMode
描述：控制物体使用X&YZ或自身的slerp Dirve旋转
◆var slerpDrive:JointDrive
描述：定义关节的旋转如何绕着所有的局部轴作用。仅在Rotation Drive Mode为slerp only 时使用。
◆var targetAngularVelocity:Vector3
描述：这是一个Vector3。它定义了关节应该旋转的角速度。
◆var targetPosition:Vector3
描述：需要关节移动到的位置。
◆var targetVelocity:Vector3
描述：需要关节移动的速度。
◆var xDrive:JointDrive
描述：定义关节的移动如何沿着局部X轴作用。
◆var xMotion:JointDrive
描述：按照Linear Limit允许沿着X轴的移动为Free，完全Locked或者Limited。
◆var yDrive:JointDrive
描述：定义关节的移动如何沿着局部Y轴作用。
◆var yMotion:JointDrive
描述：按照Linear Limit允许沿着Y轴的移动为Free，完全Locked或者Limited。
◆var zDrive:JointDrive
描述：定义关节的移动如何沿着局部Z轴作用。
◆var zMotion:JointDrive
描述：按照Linear Limit允许沿着Z轴的移动为Free，完全Locked或者Limited。
继承的成员
继承的变量
 connectedBody 这个关机链接到的另一个刚体的引用。
 axis 物体被限制于绕着这个轴的方向旋转。
 anchor关节的移动被限制于绕着这个锚点的位置。
 breakForce  需要断开关节的力。
 breakTorque  需要断开关节的力矩。
transform 附加到这个GameObject的Transform（如果没有为null）。
rigidbody 附加到这个GameObject的Rigidbody（如果没有为null）。
camrea 附加到这个GameObject的Camera（如果没有为null）。
light 附加到这个GameObject的Light（如果没有为null）。
animation 附加到这个GameObject的Animation（如果没有为null）。
constantForce 附加到这个GameObject的ConstantForce如果没有为null）。
renderer 附加到这个GameObject的Renderer（如果没有为null）。
audio 附加到这个GameObject的AudioSource（如果没有为null）。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView 附加到这个GameObject的NetworkView（只读）。（如果没有为null）。
guiTexture 附加到这个GameObject的GUITexture（只读）。（如果没有为null）。
collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint 附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter 附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏，保存在场景中或被用户修改？
继承的函数
GetComponent 返回type类型的组件，如果游戏物体上附加了一个，如
果没有返回null。
GetComponentInChildren 返回type类型的组件，这个组件位于GameObject或任何
它的子物体上，使用深度优先搜索。
GetComponentsInChildren 返回所以type类型的组件，这些组件位于GameObject或
任何它的子物体上。
GetComponents 返回GameObject上所以type类型的组件。
CompareTag 这个游戏物体被标签为tag？
SendMessageUpwards 在这个游戏物体的每个MonoBehaviour和该行为的祖先
上调用名为methodName方法。
SendMessage 在这个游戏物体上的每个MonoBehaviour上调用
methodName方法。
BroadcastMessage 在这个游戏物体或其任何子上的每个MonoBehaviour上
调用methodName方法。
GetInstanceID 返回该物体的实例id。
继承的消息传递
OnJointBreak 当附加到相同游戏物体上的关节被断开时调用。
继承的类函数
operator bool 这个物体存在吗？
Instantiate 克隆original物体并返回这个克隆。
Destroy 移除一个游戏物体，组件或资源。
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代替。
FindObjectsOfType 返回所有类型为type的激活物体。
FindObjectsOfType 返回第一个类型为type的激活物体。
operator== 比较两个物体是否相同。
operator != 比较两个物体是否不相同。
DontDestroyOnLoad 加载新场景时确保物体target不被自动销毁。
FixedJoint
类，继承自Joint
FixedJoint将两个刚体组合在一起，使他们在边界位置粘合。
参见： CharacterJoint, HingeJoint, SpringJoint.
继承的成员
继承的变量
ConnectedBody 这个关机链接到的另一个刚体的引用。
axis 物体被限制于绕着这个轴的方向旋转。
anchor 关节的移动被限制于绕着这个锚点的位置。
breakForce 需要断开关节的力。
breakTorque需要断开关节的力矩。
transform 附加到这个GameObject的Transform（如果没有为null）。
rigidbody 附加到这个GameObject的Rigidbody（如果没有为null）。
camrea 附加到这个GameObject的Camera（如果没有为null）。
light 附加到这个GameObject的Light（如果没有为null）。
animation 附加到这个GameObject的Animation（如果没有为null）。
constantForce 附加到这个GameObject的ConstantForce如果没有为null）。
renderer 附加到这个GameObject的Renderer（如果没有为null）。
audio 附加到这个GameObject的AudioSource（如果没有为null）。
guiText 附加到这个GameObject的GUIText（如果没有为null）。
networkView 附加到这个GameObject的NetworkView（只读）。（如果没有为null）。
guiTexture 附加到这个GameObject的GUITexture（只读）。（如果没有为null）。
collider 附加到这个GameObject的Collider（如果没有为null）。
hingeJoint 附加到这个GameObject的HingeJoint（如果没有为null）。
particleEmitter 附加到这个GameObject的ParticleEmitter（如果没有为null）。
gameObject 这个组件所附加的游戏物体。一个组件总是附加到一个游戏物体。
tag 这个游戏物体的标签。
name 对象的名称。
hideFlags 该物体是够被隐藏，保存在场景中或被用户修改？
继承的函数
GetComponent 返回type类型的组件，如果游戏物体上附加了一个，如
果没有返回null。
GetComponentInChildren 返回type类型的组件，这个组件位于GameObject或任何
它的子物体上，使用深度优先搜索。
GetComponentsInChildren 返回所以type类型的组件，这些组件位于GameObject或
任何它的子物体上。
GetComponents 返回GameObject上所以type类型的组件。