Unity3D脚本中文系列教程(十二)

我会带着你远行 2022-05-14 06:18 278阅读 0赞

**GameObject类，继承自Object**

Unity场景中所有实体的基类。  
参见：Component

**变量**

**◆ var active: bool**

描述：游戏物体是激活的？激活/不激活该游戏物体，  
//不激活该游戏物体.  
gameObject.active=false;

**◆ var animation: Animation**

描述：附加到这个游戏物体的动画组件（只读）（如果没有为null）  
var other: GameObject;  
other.animation.Play();

**◆ var audio: AudioSource**

描述：附加到这个游戏物体的声音组件（只读）（如果没有为null）  
var other: GameObject;  
other.audio.Play();

**◆ var camera: Camera**

描述：附加到这个游戏物体的相机（只读）（如果没有为null）  
var other: GameObject;  
other.camera.fieldOfView=45;

**◆ var collider: Collider**

描述：附加到这个游戏物体的碰撞器（只读）（如果没有为null）  
var other: GameObject;  
other.collider.material.dynamicFriction=1;

**◆ var constantForce: ConstantForce**  
描述：附加到这个游戏物体的恒定力（只读）（如果没有为null）  
var other: GameObject;  
other.constantForce.relativeForce=Vector3(0,0,1);

**◆ var guiText: GUIText**

描述：附加到这个游戏物体的GUIText（只读）（如果没有为null）  
var other: GameObject;  
other.guiText.text="HelloWorld";

**◆ var guiTexture: GUITexture**

描述：附加到这个游戏物体的GUIText（只读）（如果没有为null）

**◆ var hingeJoint: HingeJoint**

描述：附加到这个游戏物体的HingeJoint（只读）（如果没有为null）  
var other: GameObject;  
other.hingeJoint Spring.targetPosition=70;

**◆ var layer: int**

描述：游戏物体所在的层，一个层在\[0...32\]之间.  
Layer可以用来选择性的渲染或忽略投射.  
//设置游戏物体到忽略投射物体的层上  
gameObject.layer=2;

**◆ var light: Light**

描述：附加到这个游戏物体的光影（只读）（如果没有为null）  
var other: GameObject;  
other.light.range=10;

**◆ var networkView: NetworkView**

描述：附加到这个游戏物体的网络视（只读）（如果没有为null）  
var other: GameObject;  
other.networkView.RPC("MyFunction",RPCMode.All,"someValue");

**◆ var particleEmitter: ParticleEmitter**

描述：附加到这个游戏物体的粒子发射器（只读）（如果没有为null）  
var other: GameObject;  
other.particleEmitter.emite=true;

**◆ var renderer: Renderer**

描述：附加到这个游戏物体的渲染器（只读）（如果没有为null）  
var other: GameObject;  
other.renderer.material.color=Color.green;

**◆ var rigidbody: Rigidbody**

描述：附加到这个游戏物体的刚体（只读）（如果没有为null）  
var other: GameObject;  
other.rigidbody.AddForce(1,1,1);

**◆ var tag: string**

描述：这个游戏物体的标签。  
标签可以用来标识一个游戏物体。标签在使用前必须在标签管理器中定义。  
gameObject.tag="Player";

**◆ var transform: Transform**

描述：附加到这物体的变换. （如果没有为null）  
var other: GameObject;  
other.transform.Translate(1,1,1);

**构造函数**

◆ static function GameObject(name:string): GameObject  
描述：创建一个新的游戏物体，命名为name.  
Transform总是被添加到该游戏物体.  
//创建一个名为"Player"的游戏物体  
//并给他添加刚体和立方体碰撞器.  
player=new GameObject("Player");  
player.AddComponent("Rigidbody");  
player.AddComponent("BoxCollider");

**◆ static function GameObject(): GameObject**

描述：创建一个新的游戏物体.  
Transform总是被添加到该游戏物体.  
//创建一个没有名称的游戏物体  
//并给他添加刚体和立方体碰撞器.  
player=new GameObject();  
player.AddComponent("Rigidbody");  
player.AddComponent("BoxCollider");

**◆ static function GameObject(name: string, params components: Type\[\]): GameObject**  
描述：创建一个游戏物体并附加特定的组件.

**函数**

**◆ function AddComponent(className: string): Component**

描述：添加一个名为className的组件类型到该游戏物体.  
使用这个函数来改变物体的行为。你也可以传递脚本的类名来添加脚本到游戏物体。  
有些组件也需要另一些组件存在于同一个游戏物体上。这个函数会自动添加需要的组  
件，例如如果你添加一个HingeJoint也会自动添加一个Rigidbody.  
//添加名为FoobarScript的脚本到游戏物体  
gameObject.AddComponent("FoobarScript");  
//添加球形碰撞器到游戏物体  
gameObject.AddComponent("FoobarCollider");

**◆ function AddComponent(componentType: Type): Component**

描述：添加一个名为componentType类型的类到该游戏物体.  
gameObject.AddComponent("FoobarScript");  
注意，没有RemoveComponent()，来移除组件，使用Object.Destroy.

**◆ function BroadcastMessage(methodName: string, parameter: object=mull, option:  
SendMessageOption=SendMessageOptions.RequireReceiver): void**

描述：在这个游戏物体或其任何子上的每个MonoBehaviour上调用methodName方法。  
通过使用零参数，接收方法可以选择忽略parameter。如果options被设置为  
SendMessageOptions.RequireReceiver，那么如果这个消息没有被任何组件接收时将打印一个  
错误消息。  
///使用值5调用函数ApplyDamage  
gameObject.BroadcastMessage("ApplyDamage",5);  
//所有附加到该游戏物体和其子物体上脚本中的  
//ApplyDamage函数都将调用  
function ApplyDamage(damage)

\{  
     print(damage)  
\}

**◆ function CompareTag(tag: string): bool**

描述：这个游戏物体被标签为tag？  
//立即死亡触发器  
//销毁任何进入到触发器的碰撞器，这些碰撞器被标记为Player.  
function OnTriggerEnter(other: Collider)

\{  
    if(other.gameObject.CompareTag("Player"))  
    \{  
         Destroy(other.gameObject);  
     \}  
\}

**◆ function GetComponent(type: Type): bool**

描述：如果游戏物体有type类型的组件就返回它，否则返回null. 你可以使用这个函数  
访问内置的组件或脚本.  
GetComponent是防卫其他组件的主要方法。对于Javascript脚本的类型总是脚本显示  
在工程视图中的名称。例如：  
function Start()  
\{  
     var curTransform: Transform;  
     curTransform=gameObject.GetComponent(Transform);  
     //这等同于  
     curTransform=gameObject.transform;  
\}  
function Update()

\{  
     //为访问附加在同一游戏物体上  
     //其他脚本内的公用变量和函数  
     //(ScriptName为Javascript文件名)  
     var other: ScriptName=gameObject.GetComponent(ScriptName);  
     //调用该脚本中的DoSomething函数  
     other DoSomething();  
     //设置其他脚本实例中的另一个变量  
     other.someVariable=5;  
\}

**◆ function GetComponent(type: string): Component**

描述：返回名为type的组件，如果游戏物体上附加了一个就返回它，如果没有返回null.  
出于性能的原因最好用Type电影GetComponent而不是一个字符串。然而有时你可能  
无法得到类型，例如当试图从Javascript中访问c\#时。在那种情况下你可以简单的通过名  
称而不是类型访问这个组件。例如：  
function Update()  
\{  
      //为访问附加在同一游戏物体上  
      //其他脚本内的公用变量和函数.  
      //(ScriptName为Javascript文件名）  
      var other=gameObject.GetComponent("ScriptName");  
      //调用该脚本中的DoSomething函数  
      other.DoSomething().  
      //设置其他脚本实例中的另一个变量  
      other.someVariable=5;  
\}

**◆ function GetComponentInChildren(type: Type): Component**

描述：返回type类型的组件，这个组件位于这个游戏物体或任何它的子物体上，使用  
深度优先搜索。  
只有激活的组件被返回。  
var script: ScriptName=gameObject.GetComponentInChildren(ScriptName);  
script.DoSomething();

**◆ function GetComponents(type: Type): Component\[\]**

描述：返回该游戏物体上所有type类型的组件。  
//在这个游戏物体和所有它的子物体上  
//的HingeJoints上禁用弹簧  
var hingeJoints=gameObject.GetComponents(HingeJoint);  
for(var joint: HingeJoint in hingeJoints)

\{  
     joint.useSpring=false;  
\}

**◆ function GetComponentsInChildren(type: Type, includeInactive: bool=false):  
Component\[\]**

描述：返回所有type类型的组件，这些组件位于该游戏物体或任何它的子物体上。  
只有激活的组件被返回。  
//在这个游戏物体和所有它的子物体上  
//的所有HingeJoints上禁用弹簧  
var hingeJoints=gameObject.GetComponentsInChildren(HingeJoint);  
for(var joint: HingeJoint in hingeJoints)

\{  
     joint.useSpring=false;  
\}

**◆ function SampleAnimation(animation: AnimationClip, time: float): void**

描述：在一个特定的时间采样动画，用于任何动画目的。  
出于性能考虑建议使用Animation接口，这将在给定的time采用animation，任何被动  
化的组件属性都将被这个采样值替换，多数时候你会使用Animation.Play. SampleAnimation  
用于当你需要以无序方式或给予一些特殊的输入在帧之间跳跃时使用。参见：Aniamtion  
//通过采样每一帧或动画剪辑  
var clip.AniamtionClip  
function Update()  
\{  
    gameObject.sampleAnimation(clip, clip.length-Time.time);  
\}

**◆ function SendMessage(methodName: string, value: object=null, options:  
SendMessageOption=SendMessageOption.RequireReceiver): void**  
描述：在这个游戏物体上的每个MonoBehaviour上调用methodName方法。  
通过使用零参数，接收方法可以选择忽略参数。如果options被设置为  
SendMessageOptions.RequireReceiver，那么如果这个消息没有被任何组件接收时将打印一个  
错误消息。  
//使用值5调用函数ApplyDamage  
gameObject.SendMessage("ApplyDamage",5);  
//所以附加到该游戏物体上的脚本中的  
//ApllyDamage函数都将调用  
function.ApplyDamage(damage)

\{  
    pring(damage);  
\}

**◆ function SendMessageUpwards(methodName: string, value: object=null, options:  
SendMessageOption=SendMessageOption.RequireReceiver): void**

描述：在这个游戏物体上的每个MonoBehaviour和该行为的祖先上调用名为methodName  
方法。  
通过使用零参数，接收方法可以选择忽略参数。如果options被设置为  
SendMessageOptions.RequireReceiver，那么如果这个消息没有被任何组件接收时将打印一个  
错误消息。  
//使用值5调用函数ApplyDamage  
gameObject.SendMessageUpwards("ApplyDamage",5);  
//所以附加到该游戏物体上的脚本中的  
//ApllyDamage函数都将调用  
function.ApplyDamage(damage)

\{  
     pring(damage);  
\}

**◆ function SetActiveRecursion(rotate: bool): void**

描述：设置这个物体和所以子游戏物体的机会状态。  
gameObject.SetActiveRecursion(true);

**类方法**

**◆ static function CreatePrimitive(type: PrimitiveType): GameObject**  
   
描述：用几何的网格渲染器和适当的碰撞器创建一个游戏物体。  
///在场景中创建一个平面，球体和立方体  
function Start()  
\{  
     var plane:GameObject= GameObject.CreatePrimitive(PrimitiveType.Plane);

var cube=GameObject.CreatePrimitive(PrimitiveType.Cube);  
     cube.transform.position=Vector3(0,0.5,0);

var sphere=GameObject.CreatePrimitive(PrimitiveType.Sphere);  
     sphere.transform.position=Vector3(0,1.5,0);

var capsule=GameObject.CreatePrimitive(PrimitiveType.Capsule);  
     capsule.transform.position=Vector3(2,1,0);

var cylinder=GameObject.CreatePrimitive(PrimitiveType.Cylinder);  
     cylinder.transform.position=Vector3(-2,1,0);

**◆ static function Find(name: string): GameObject**

描述：依据name查找物体并返回它.  
如果没有物体具有名称name返回null. 如果name包含'/'字符它将像一个路径名一样穿  
越层次，这个函数只返回激活的游戏物体。  
出于性能考虑建议不要在每帧中都是有该函数，而是在开始时调用并在成员变量中缓存结果  
或者用GameObject.FindWithTag.  
//这返回场景中名为Hand的游戏物体.  
hand=GameObject.Find("Hand");  
//这将返回名为Hand的游戏物体.  
//在层次试图中Hand也许没有父！  
hand=GameObject.Find("/Hand");  
//这将返回名为Hand的游戏物体.  
//它是Arm>Monster的子.  
//在层次试图中Monster也许没有父！  
hand=GameObject.Find("/Monster/Arm/Hand");  
//这将返回名为Hand的游戏物体.  
//它是Arm>Monster的子.  
//Monster有父.  
hand=GameObject.Find("/Monster/Arm/Hand");  
这个函数最常用与在加载时自动链接引用到其他物体，例如，在MonoBehaviour.Awake  
或MonoBehaviour.Start内部. 处于性能考虑你不应该在每帧中调用这个函数，例如  
MonoBehaviour.Update内. 一个通用的模式是在MonoBehaviour.Start内将一个游戏物体赋给  
一个变量. 并在MonoBehaviour.Update中使用这个变量.  
//在Start中找到Hand并在每帧中选择它  
private var hand: GameObject;  
function Start()

\{  
     hand=GameObject.Find("/Monster/Arm/Hand");  
\}  
function Update()

\{  
     hand.transform.Rotate(0,100\*Time.deltaTime,0);  
\}

**◆ static function FindGameObjectsWithTag(tag: string): GameObject\[\]**

描述：返回标记为tag的激活物体列表，如果没有发现返回null.  
标签在使用前必须在标签管理中定义。  
//在所有标记为"Respawn"的物体位置处  
//实例化respawnPrefab  
   
var respawnPrefab: GameObject;  
var respawns=GameObject.FindGameObjectsWithTag("Respawn");  
for(var respawn in respawns)  
Instantiate(respawnPrefab, respawn.position, respawn.rotation);  
//打印最接近的敌人的名称  
print(FindClosestEnemy().name);  
//找到最近的敌人的名称  
function FindClosestEnemy(): GameObject

\{  
     //找到所以标记为Enemy的游戏物体  
     var gos: GameObject\[\]  
     gos=GameObject.FindGameObjectsWithTag("Enemy");  
     var closest: GameObject;  
     var distance=Mathf.Infinity;  
     var position=transform.position;  
     //遍历它们找到最近的一个  
     for(var go: GameObject in gos)

\{  
           var diff=(go.transform.position-position);  
           var curDistance=diff.sqrMagnitude;  
           if(curDistance<distance)

\{  
               closest=go;  
               distance=curDistance;  
            \}  
       \}  
      return closest;  
\}

**◆ static function FindGWithTag(tag: string): GameObject**

描述：返回标记为tag的一个激活游戏物体，如果没有发现返回null.  
标签在使用前必须在标签管理中定义。  
//在标记为"Respawn"的物体位置处  
//实例化一个respawnPrefab  
var respawnPrefab: GameObject;  
var respawns=GameObject.FindWithTag("Respawn");  
Instantiate(respawnPrefab, respawn.position, respawn.rotation);

**继承的成员  
继承的变量**

name 对象的名称。  
hideFlags 该物体是够被隐藏，保存在场景中或被用户修改？

**继承的函数**

GetInstanceID 返回该物体的实例id。

**继承的类函数**

operator bool 这个物体存在吗？  
Instantiate 克隆original物体并返回这个克隆。  
Destroy 移除一个游戏物体，组件或资源。  
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代替。  
FindObjectsOfType 返回所有类型为type的激活物体。  
FindObjectsOfType 返回第一个类型为type的激活物体。  
operator== 比较两个物体是否相同。  
operator != 比较两个物体是否不相同。  
DontDestroyOnLoad 加载新场景时确保物体target不被自动销毁。  
这与使用带有"\_MainTex"名称的GetTextureOffset或SetTextureOffset相同。  
//基于时间滚动主纹理  
var scrollSpeed=0.5;  
function Update()

\{  
     var offset=Time.time\*scrollspeed;  
     renderer.material.mainTextureOffset=Vector2(offset,0);  
\}

参见：SetTextureOffset.GetTextureOffset.

**◆ var mainTextureScale: Vector2**

描述：主材质的纹理缩放。  
这与使用带有"\_MainTex"名称的GetTextureScale或SetTextureScale相同。  
function Update()

\{  
     var scalex=Mathf.Cus(Timetime)\*0.5+1;  
     var scaleY=Mathf.Sin(Timetime)\*0.5+1;  
     renderer.material.mainTextureScale=Vector2(scaleX,scaleY);  
\}

参见：SetTextureScale.GetTextureScale.

**◆ var passCount: int**

描述：在这个材质中有多少个pass（只读）.  
这个最常用在使用GL类之间绘制的代码中（只限于Unity Pro）. 例如，Image Effects使用  
材质来实现屏幕后期处理. 对材质中的每一个pass（参考SetPass）它们激活并绘制一个全屏  
四边形。  
这里是一个全屏图形效果的例子，它反转颜色。添加这个脚本到相机并在播放模式中  
查看。  
private var mat: Material;  
function Start()  
\{  
mat=new Material(  
"Shader"Hidden/Invert"\{"+  
"SubShader\{"+  
"Pass\{"+  
"ZTestAlways Cull Off ZWrite Off"+  
"SetTexture\[\_RenderTex\]\{combine one-texture\}"+  
"\}"+  
"\{"+  
"\}"+  
);  
\}  
function OnRenderImage(source: RenderTexture, dest: RenderTexture)\{  
RenderTexture.active=dest;  
source.SetGlobalShaderProperty("\_RenderTex");  
GL.PushMatrix();  
GL.LoadOrtho();  
//对于材质中的每个pass（这里只有一个）  
for(var i=0; i<mat.passCount; ++i)\{  
//激活pass  
mat.SetPass(i);  
//绘制一个四边形  
GL.Begin(GLQUADS);  
GL.TEXCoord2(0,0); GL.Vertex3(0,0,0.1);  
GL.TEXCoord2(1,0); GL.Vertex3(1,0,0.1);  
GL.TEXCoord2(1,1); GL.Vertex3(1,1,0.1);  
GL.TEXCoord2(0,1); GL.Vertex3(0,1,0.1);  
GL.End();  
\}  
GL.PopMatrix();  
\}

参见：SetPass函数，GL类，ShaderLab documentation.

**◆ var renderQueue: int**

描述：这个材质的渲染队列（只读）  
默认地材质使用shader的render queue，你可以使用这个变量重载该渲染队列。注意一  
旦渲染队列在该材质上被设置，它将保持这个值，集市以后shader被改变为不同的一个值。  
渲染队列值需要时正的才能正常工作。  
参见：Shader.renderQueue, RenderQueue tag.

**◆ var shader: Shader**

描述：该材质使用的着色器。  
//按下空格键时，  
//在Diffuse和Transparent/Diffuse着色器之间切换  
private var shader1=Shader.Find("Diffuse");  
private var shader2=Shader.Find("Transparent/Diffuse");  
function Update()

\{  
      if(Input.GetButtonDown("Jump"))

\{  
           if(renderer.material.shader--shader1)  
               rendere.material.shader=shader2;  
           else  
               renderer.material.shader=shader1;  
       \}  
\}

参见：Shader.Find方法，Material, ShaderLab documentation.

**构造函数**

**◆ static function Material(contents: string): Material**

描述：从一个源shader字符串创建一个材质。  
如果你有一个实现自定义特效的脚本，你需要使用着色器和材质实现所有的图像设置。  
在你的脚本内使用这个函数创建一个自定义的着色器和材质。在创建材质后，使用SetColor，  
SetTexture, SetFloat, SetVector, SetMatrix来设置着色器属性值。  
//创建一个附加混合材质并用它来渲染  
var color=Color.white;  
function Start()  
\{  
var shader Text=  
"shader"Alpha Additive"\{"+  
Properties\{\_Color("Main Color", Color)=(1,1,1,0)\}"+  
"SubShader \{"+  
"Tags \{"Queue"="Transparent"\}"+  
"Pass \{"+  
"Blend One One ZWrite Off ColorMask RGB"+  
"Material \{Diffuse\[\_Color\]Ambient\[\_Color\]\}"+  
"Lighting On"+  
"SetTexture\[\_Dummy\]\{combine primary double, primary\}"+  
"\}"+  
"\}"+  
"\}";  
renderer.material=new Material(shaderText);  
renderer.material.color=color;  
\}  
参见：ShaderLab documentation.

**函数**

**◆ function CopyPropertiesFormMaterial(mat: Material): void**

描述：从其他材质拷贝属性到这个材质。

**◆ function GetColor(propertyName: string): Color**

描述：获取一个命名的颜色值。  
数多shader使用超过一个颜色，使用GetColor来获取propertyName颜色。  
Unity内置着色器使用的普通颜色名称；  
"\_Color"为材质的主颜色。这也能够通过color属性访问。  
"\_SpecColor"为材质的反射颜色（在specular/glossy/vertexlit着色器中使用）。  
"\_Emission"为材质的散射颜色（用在reflective着色器中使用）。  
print(renderder.material.GetColor("\_SpecColor));  
参见：color属性，SetColor.

**◆ function GetFloat(propertyName: string): float**

描述：获取一个命名的浮点值。  
参见：SetFloat, Materials, ShaderLab documentation.

**◆ function GetMatrix(propertyName: string): Matrix4x4**

描述：从该shader中获取命名矩阵的值。  
这个最常用于自定义的shader，其中需要额外的矩阵参数，矩阵参数不需要在材质检  
视面板中公开，但是能够在脚本中通过SetMatrix和GetMatrix来设置和查询。  
参见：SetMatrix, Materials, ShaderLab documentation.

**◆ function GetTag(taf: string, searchFallbacks: bool, defaultValue: string=""): string**

描述：获取材质的shader标签值。  
如果材质的shader没有定义标签，defaultValue被返回。  
如果searchFallbacks为true那么这个函数将在所有的子shader和所有后备中查找标签。  
如果searchFallbacks为false只在当前查询的子shader中查找这个标签。  
使用不搜索后备的GetTag可以检视现在使用的是哪个子shader：添加一个自定义具有  
不同值的标签到每个子shader，然后再运行时查询这个值。例如，Unity Pro的水使用这个  
函数来检测shader何时退化为没有反射，然后关闭反射相机。  
◆ function GetTexture(propertyNmae: string): Texture  
描述：获取一个命名纹理。  
数多shader使用超过一个纹理。使用GetTexture来获取propertyName纹理。  
Unity内置着色器使用的普通纹理名称；  
"\_MainTex"为主散射纹理. 这也能够通过mainTexture属性访问。  
"\_BumpMap"为法线贴图。  
"\_LightMap"为光照贴图。  
   
"\_Cube"为发射立方体贴图。  
function Start()

\{  
   var tex=renderer.material.GetTexture("\_BumpMap");  
   if(tex)  
        print("My bumpmap is "+ tex.name);  
   else  
        print("I have no bumpmap!");  
\}  
参见：mainTexture属性，SetTexture.

**◆ function GetTextureOffset(propertyName: string): Vector2**

描述：获取纹理propertyName的位置偏移。  
Unity内置着色器使用的普通纹理名称；  
"\_MainTex"为主散射纹理. 这也能够通过mainTextureOffset属性访问。  
"\_BumpMap"为法线贴图。  
"\_LightMap"为光照贴图。  
"\_Cube"为发射立方体贴图。  
参见：mainTextureOffset属性，SetTextureOffset.

**◆ function GetTextureScale(propertyName: string): Vector2**

描述：获取纹理propertyName的位置缩放。  
Unity内置着色器使用的普通纹理名称；  
"\_MainTex"为主散射纹纹理. 这也能够通过mainTextureOffset属性访问。  
"\_BumpMap"为法线贴图。  
"\_LightMap"为光照贴图。  
"\_Cube"为发射立方体贴图。  
参见：mainTextureScale属性，SetTextureScale.

**◆ function GetVector(propertyName: string): Vector4**

描述：获取一个命名向量的值。  
在Unity shader中四组件向量和颜色是相同的。GetVector does exactly the same as  
GetColor just the input data type is different(xyzw in the vector becomes rgba in the color).  
See Also: GetColor, SetVector.

**◆ function HasProperty(propertyName: string): bool**

描述：检查材质的shader是否有给定名称的属性。  
参见：mainTextureScale属性，SetTextureScale.

**◆ function Lerp(Start: Material, end: Material, t: float): void**

描述：在两个材质间插值属性。  
使一个材质的所有颜色和浮点值从start到end基于t来插值。  
当t为0，所有的值为start。  
当t为1，所有的值为end。  
通常你想要插值的两个材质是相同的（使用相同的着色器和纹理）除了颜色和浮点值。  
然后你使用Lerp来混合它们。  
//混合两个材质  
var material1: Material;  
var material2: Material;  
var duration=2.0;  
function Start()  
\{  
    //首先使用第一个材质  
    renderer.material=material\[\];  
\}  
function Update()  
\{  
    //随着时间来回变化材质  
    var lerp=Mathf.PingPong(Time.time, duration)/duration;  
    renderer.material.Lerp(material1, materail2, lerp);  
\}  
参见：Material.

**◆ function SetColor(propertyName: string, color: Color): void**

描述：设置一个命名的颜色值。  
数多shader使用超过一个颜色。使用SetColor来获取propertyName颜色.  
Unity内置着色器使用的普通颜色名称；  
"\_Color"为材质的主颜色. 这也能够通过color属性访问.  
"\_SpecColor"为材质的反射颜色（在specular/glossy/vertexlit着色器中使用）.  
"\_Emission"为材质的散射颜色（用在vertexlit着色器中）.  
"\_ReflectColor"为材质的反射颜色（用在reflective着色器中）.  
function Start()

\{  
    //设置Glossy着色器这样可以使用反射颜色  
    renderer.material.shader=Shader.Find("Glossy");  
    //设置红色的高光  
    renderer.material.SetColor("\_SpecColor", Color.red);  
\}  
参见：color属性，GetColor.

**◆ function SetFloat(propertyName: string, value: float): void**

描述：设置一个命名的浮点值。  
function Start()

\{  
     //在这个材质上使用Glossy着色器  
     renderer.material.shader=Shader.Find("Glossy");  
\}  
function Update()

\{  
     //动画Shininess值  
     var shininess=Mathf.PingPong(Time.time, 1.0);  
     renderer.material.SetFloat("\_Shininess, shininess);  
\}  
参见：GetFloat, Materials, ShderLab documentation.

**◆ function SetMatrix(propertyName: string, matrix: Matrix4x4): void**

描述：为一个shader设置一个命名矩阵。  
这个最常用于自定义的shader，其中需要额外的矩阵参数，矩阵参数不需要在材质检  
视面板中公开，但是能够在脚本中通过SetMatrix和GetMatrix来设置和查询。  
var rotateSpeed=30;  
var texture: Texture;  
function Start()\{  
//用于一个着色器创建一个新的材质  
//这个着色器旋转纹理  
var m=new Material  
 (  
"Shader"Rotation Texture"\{"+  
"Properties\{\_Main Tex("Base",2D)="white"\{\}\}"+  
"SubShader\{"+  
"Pass\{"+  
"Material\{Diffuse(1,1,0)Ambient(1,1,1,0)\}"+  
"Lighting On"+  
"SetTexture\[\_MainTex\]\{"+  
"matrix\[\_Rotation\]"+  
"combing texture\*primary double.texture"+  
"\{"+  
"\}"+  
"\{"+  
"\}"  
);  
m.mainTexture=texture;  
renderer.material=m;  
\}  
function Update()  
\}  
//为这个着色器构建一个旋转矩阵并设置它  
var rot=Quaternion, Euler(0,0,Time.time\*rotateSpeed);  
var m=Matrix4x4.TRS(Vector3.zero,rot.Vector3(1,1,1));  
renderer.material.SetMatrix(\*\_Rotation", m);  
\}

///

var rotateSpeed = 30;  
var texture : Texture;  
  
function Start() \{  
// Create a new material with a shader  
// that rotates the texture. Texture rotation  
// is performed with a \_Rotation matrix.  
var m : Material = new Material (  
"Shader "Rotating Texture\\" \{" +  
"Properties \{ \_MainTex ("Base\\", 2D) = "white\\" \{\} \}" +  
"SubShader \{" +  
" Pass \{" +  
" Material \{ Diffuse (1,1,1,0) Ambient (1,1,1,0) \}" +  
" Lighting On" +  
" SetTexture \[\_MainTex\] \{" +  
" matrix \[\_Rotation\]" +  
" combine texture \* primary double, texture" +  
" \}" +  
" \}" +  
"\}" +  
"\}"  
);  
m.mainTexture = texture;  
renderer.material = m;  
\}  
  
function Update() \{  
// Construct a rotation matrix and set it for the shader  
var rot = Quaternion.Euler (0, 0, Time.time \* rotateSpeed);  
var m = Matrix4x4.TRS (Vector3.zero, rot, Vector3(1,1,1) );  
renderer.material.SetMatrix ("\_Rotation", m);  
\}

参见：GetMatrix，Materials，ShaderLab documentation.

**◆ function SetPass(pass: int): bool**

描述：为渲染激活给定的pass.  
传递从零开始最大到passCount（但不包含）的索引。  
这个最常用在使用GL类直接绘制的代码中（只能Unity Pro）。例如，Image Effects使用  
材质来实现屏幕后期处理，对材质中的每一个pass它们激活并绘制一个全屏四边形。  
如果SetPass返回假，你不应该渲染任何东西。  
这里是一个全屏图像效果的例子，它反转颜色，添加这个脚本到相机并在播放模式中  
查看。  
private var mat: Material;  
function Start()  
\{  
mat=new Material(  
"Shader"Hidden/Invert"\{"+  
"SubShader\{"+  
"Pass\{"+  
"ZTest Always Cull Off ZWrite Off"+  
"SetTexture\[\_RenderTex\]\{combine one-texture\}"+  
"\}"+  
"\}"+  
"\}"  
);  
\}  
function OnRenderImage(source: RenderTexrure, dest: RenderTexture)\{  
RenderTexture.active=dest;  
source.SetGlobalShaderProperty("\_RenderTex");  
GL.PushMatrix();  
GL.LoadOrtho();  
//激活第一个pass（这里我们知道它只有仅有的pass）  
mat.SetPass(0);  
//绘制一个四边形  
GL..Begin(GL.QUADS);  
GL..TexCoord2(0,0);GL..Vertex3(0,0,0.1);  
   
GL..TexCoord2(1,0);GL..Vertex3(1,0,0.1);  
GL..TexCoord2(1,1);GL..Vertex3(1,1,0.1);  
GL..TexCoord2(0,1);GL..Vertex3(0,1,0.1);  
GL..End();

GL.PopMatrix();  
\}  
参见：passCount属性，GL类，ShaderLab documentation.

**◆ function SetTexture(propertyName: string, texture: Texture): void**

描述：设置一个命名纹理.  
数多shader使用超过一个纹理。使用SetTexture来改变propertyName纹理。  
Unity内置着色器使用的普通纹理名称：  
"\_MainTex"为主射散纹理，这也能够通过mainTexture属性访问.  
"\_BumapMap"为法线贴图.  
"\_LightMap"为光照贴图.  
"\_Cub"为放射立方体贴图.  
//基于实际滚动主纹理  
var scrollSpeed=0.5;  
function Update()\{  
var offset=Time.time\*scrollSpeed;  
rendereer.material.SetTextureOffset("\_MatrixTex", Vector2(offset,0));  
\}  
参见：mainTextureOffset属性，GetTextureOffset.  
◆ function SetTextureScale(propertyName: string, scale: Vector2): void  
描述：设置纹理propertyName的位置缩放.  
Unity内置着色器使用的普通纹理名称：  
"\_MainTex"为主射散纹理，这也能够通过mainTexture属性访问.  
"\_BumapMap"为法线贴图.  
"\_LightMap"为光照贴图.  
"\_Cub"为放射立方体贴图.  
参见：mainTextureScale属性，GetTextureScale.  
function Update()  
\{  
//以一个流行的放式动画主纹理缩放！  
var scaleX=Mathf.Cos(Time.time)\*0.5+1;  
var scaleY=Mathf.Sin(Time.time)\*0.5+1;  
rendereer.material.SetTextureScale("\_MainTex", Vector2(ScaleX,ScaleY));  
\}  
◆ function SetVector(propertyName: string, Vector: Vector4): void  
描述：设置一个命名的向量值.  
在Unity shader中四组件向量和颜色是相同的。SetVector与SetColor完全相同，仅仅  
是输入数据类型不同（向量的xyzw变为颜色的rgba）.  
参见：SetColor, GetVector.  
继承的成员  
继承的变量  
name 对象的名称。  
hideFlags 该物体是够被隐藏，保存在场景中或被用户修改？  
继承的函数  
GetInstanceID 返回该物体的实例id。  
继承的类函数  
operator bool 这个物体存在吗？  
Instantiate 克隆original物体并返回这个克隆。  
Destroy 移除一个游戏物体，组件或资源。  
DestroyImmediate 立即销毁物体obj。强烈建议使用Destroy代替。  
FindObjectsOfType 返回所有类型为type的激活物体。  
FindObjectsOfType 返回第一个类型为type的激活物体。  
operator== 比较两个物体是否相同。  
operator != 比较两个物体是否不相同。  
DontDestroyOnLoad 加载新场景时确保物体target不被自动销毁。  
Mesh  
类，继承自Object  
一个类允许你从脚本中创建或修改网格。  
网格包含顶点和多个三角形数组。参考Procedural example project获取石油网格接口的  
例子。  
三角数组只是顶点索引数组；三个索引为一个三角形。  
对于每个顶点可以有一个法线，两个纹理坐标，颜色和切线。这些都是可选的并可以  
去掉。所有的顶点信息被存储相同尺寸的不同数组中，因此如果的网格有10个顶点，你  
应该有大小为10的数组用于法线和其他属性。  
可能有三件事，你可能想要使用可调整的网格。  
1. 从头开始构建网格：应该总是按照如下的顺序：1）赋值vertices2）赋值triangles  
function start()\{  
var mesh=new Mesh();  
GetComponent(MeshFilter).mesh=mesh;  
mesh.vertices=newVertices;  
nesh.uv=newUV;  
mesh.triangles=newTriangles;  
\}  
2. 没帧修改顶点属性：1）获取顶点，2）修改它们，3）将它们赋值回网格.  
function Update()\{  
var mesh: mesh=GetComponent(MeshFilter).mesh;  
var vertices=newVertices;  
var normals=mesh.normals;  
for(var i=0,i<vertices.length,i++)  
\{  
vertices\[i\]+=mormals\{i\}\*Mathf.Sin(Time.time);  
\}  
mesh.vertices=vertices;  
\}  
3. 连续地改变网格三角形和顶点：1）调用Clear开始刷心，2）赋值顶点和其他属性，3）赋  
值三角形索引.  
在赋值新的顶点或三角形时调用Clear是重要的。Unity总是检查提供的三角形索引，  
它们是否没有超出顶点边界。电影Clear然后赋值顶点然后三角形，确保没你没有超出数据边  
界。  
function Update()\{  
var mesh: mesh=GetComponent(MeshFilter).mesh;  
mesh.Clear();  
mesh.vertices=newVertices;  
nesh.uv=newUV;  
mesh.triangles=newTriangles;  
\}  
变量  
◆ var bindposes: Matrix4x4\[\]  
描述：绑定的姿势。每个索引的绑定姿势使用具有相同的索引的骨骼。  
当骨骼在绑定姿势中时，绑定姿势是骨骼变换矩阵的逆。  
function Start()\{  
gameObject.AddComponent(Animation);  
gameObject.AddComponent(SkinnedMeshRenderer);  
var renderer: SkinnedMeshRenderer=GetComponent(SkinnedMeshRenderer);  
//构建基本网格  
var mesh: Mesh-new Mesh();  
mesh.vertices=\[Vector3(-1,0,0), Vector3(1,0,0), Vector3(-1,5,0), Vector3(1,5,0)\];  
mesh.uv=\[Vector2(0,0), Vector2(1,0), Vector2(0,1), Vector2(1,1)\];  
mesh.triangles=\[0,1,2,1,3,2\];  
mesh.RecalculateNormals();  
//赋网格到网格过滤器和渲染器  
renderer.material=new Material(Shader.Find("Diffuse"));  
//赋骨骼权值到网格  
//使用两个骨骼. 一个用于上部的顶点，一个用于下部的顶点  
var weights=new BoneWeight\[4\];  
weights\[0\].boneIndex0=0;  
weights\[0\].weight0=1;  
weights\[1\].boneIndex0=0;  
weights\[1\].weight0=1;  
weights\[2\].boneIndex0=1;  
weights\[2\].weight0=1;  
weights\[3\].boneIndex0=1;  
weights\[3\].weight0=1;  
mesh.boneWeights=weights;  
//创建骨骼变换并绑定姿势  
//一个骨骼在顶部一个在底部  
var bones=new Transform\[2\];  
var bindPoses=new Matrx4x4\[2\];  
bones\[0\]=new GameObject("Lower").transform;  
bones\[0\]parent=transform;  
//设置相对于父的位置  
bones\[0\].localRotation=Quaternion.identity;  
bones\[0\].localPosition=Vector3.zero;  
//绑定姿势是骨骼的逆变换矩阵  
//在这种情况下我们也要使这个矩阵市相对与根的  
//这样我们就能够随意移动根物体了  
bindPose\[0\]=bones\[0\].worldToLocalMatrix\*transform.localToWorldMatrix;  
bones\[1\]=new GameObject("Upper").transform;  
bones\[1\]parent=transform;  
//设置相对于父的位置  
bones\[1\].localRotation=Quaternion.identity;  
bones\[1\].localPosition=Vector3.(0,5,0);  
//绑定姿势是骨骼的逆变换矩阵  
//在这种情况下我们也要使这个矩阵市相对与根的  
//这样我们就能够随意移动根物体了  
bindPose\[1\]=bones\[1\].worldToLocalMatrix\*transform.localToWorldMatrix;  
.mesh.bindposes=bindPoses;  
.//赋值骨骼并绑定姿势  
.renderer.bones=bones;  
.renderer.sharedMesh=mesh;  
//赋值一个简单的挥动动画到底部的骨骼  
var curve=new AnimationCurve();  
curve.keys=\[new Keyframe(0,0,0,0:,new Keyframe(1,3,0,0),new Keyframe(2,0.0,0,0,)\];  
//使用曲线创建剪辑  
var clip=new AnimationClip();  
clip.SetCurve("Lower", Transform,"m\_LocalPosition.z", curve);  
//添加并播放剪辑  
animation.AddClip(clip, "test");  
animation.Play("test"); \}  
◆ var boneWeights: BondWeight\[\]  
描述：每个顶点的骨骼权重  
数组的大小与vertexCount相同或为空。  
每个顶点可以被至多4个不同骨骼影响。4个骨骼的权值加和应该为1，  
function Start()\{  
gameObject.AddComponent(Animation);  
gameObject.AddComponent(SkinnedMeshRenderer);  
var renderer: SkinnedMeshRenderer=GetComponent(SkinnedMeshRenderer);  
//构建基本网格  
var mesh: Mesh-new Mesh();  
mesh.vertices=\[Vector3(-1,0,0), Vector3(1,0,0), Vector3(-1,5,0), Vector3(1,5,0)\];  
mesh.uv=\[Vector2(0,0), Vector2(1,0), Vector2(0,1), Vector2(1,1)\];  
mesh.triangles=\[0,1,2,1,3,2\];  
mesh.RecalculateNormals();  
//赋网格到网格过滤器和渲染器  
renderer.material=new Material(Shader.Find("Diffuse"));  
//赋骨骼权值到网格  
//使用两个骨骼. 一个用于上部的顶点，一个用于下部的顶点  
var weights=new BoneWeight\[4\];  
weights\[0\].boneIndex0=0;  
weights\[0\].weight0=1;  
weights\[1\].boneIndex0=0;  
weights\[1\].weight0=1;  
weights\[2\].boneIndex0=1;  
weights\[2\].weight0=1;  
weights\[3\].boneIndex0=1;  
weights\[3\].weight0=1;  
mesh.boneWeights=weights;  
//创建骨骼变换并绑定姿势  
//一个骨骼在顶部一个在底部  
var bones=new Transform\[2\];  
var bindPoses=new Matrx4x4\[2\];  
bones\[0\]=new GameObject("Lower").transform;  
bones\[0\]parent=transform;  
//设置相对于父的位置  
bones\[0\].localRotation=Quaternion.identity;  
bones\[0\].localPosition=Vector3.zero;  
//绑定姿势是骨骼的逆变换矩阵  
//在这种情况下我们也要使这个矩阵市相对与根的  
//这样我们就能够随意移动根物体了  
bindPose\[0\]=bones\[0\].worldToLocalMatrix\*transform.localToWorldMatrix;  
bones\[1\]=new GameObject("Upper").transform;  
bones\[1\]parent=transform;  
//设置相对于父的位置  
bones\[1\].localRotation=Quaternion.identity;  
bones\[1\].localPosition=Vector3.(0,5,0);  
//绑定姿势是骨骼的逆变换矩阵  
//在这种情况下我们也要使这个矩阵市相对与根的  
//这样我们就能够随意移动根物体了  
bindPose\[1\]=bones\[1\].worldToLocalMatrix\*transform.localToWorldMatrix;  
mesh.bindposes=bindPoses;  
//赋值骨骼并绑定姿势  
renderer.bones=bones;  
renderer.sharedMesh=mesh;  
//赋值一个简单的挥动动画到底部的骨骼  
var curve=new AnimationCurve();  
curve.keys=\[new Keyframe(0,0,0,0:,new Keyframe(1,3,0,0),new Keyframe(2,0.0,0,0,)\];  
//使用曲线创建剪辑  
var clip=new AnimationClip();  
clip.SetCurve("Lower", Transform,"m\_LocalPosition.z", curve);  
//添加并播放剪辑  
animation.AddClip(clip, "test");  
animation.Play("test");  
\}  
◆ var bounds: Bounds  
描述：网格的包围体。  
这个是在网格的局部坐标空间中轴对齐的包围盒（不会受到变换的影响）参考世界空  
间中的Renderer.Bounds属性。  
//产生一个屏幕UV坐标，这个与网格尺寸无关  
//通过缩放包围盒尺寸的顶点  
function Start()\{  
var mesh: Mesh=GetComponent(MeshFilter).mesh;  
var.vertices=mesh vertices;  
var.uv=new Vector2\[vertices.length\];  
var.bounds=mesh.bounds;  
   
for (var i=0,i<uvs.length;i++)\{  
uvs\[i\]=Vector2(vertices\[i\].x/bounds.size.x,vertices\[i\].z/bounds.size.x);  
\}  
mesh.uv=uvs;  
\}  
参见：Bounds类，Renderer.Bounds属性.  
◆ var Colors: Color\[\]  
描述：返回网格的顶点颜色。  
如果没有顶点颜色可用，一个空的数组将被返回。  
//设置y=0的顶点位红色，y=1的订单为绿色.  
//（注意大多数设置着色器不显示顶点颜色，你可以  
//使用例如，一个粒子渲染器来查看顶点颜色）  
function Start()\{  
var mesh: Mesh=GetComponent(MeshFilter).mesh;  
var.vertices=mesh vertices;  
var.color=new Color\[Vertices.Length\];  
for (var i=0,i<vertices.length;i++)\{  
colors\[i\]=Color.Lerp(Colored, Color.green, vertices\[i\].y);  
\}  
mesh.colors=colors;  
\}  
◆ var normals: Vectors\[\]  
描述：网格的法线。  
如果网格布包含发行，一个空的数组将被返回。  
//以speed每帧旋转法线  
var speed=100.0;  
function Update()\{  
var mesh: Mesh=GetComponent(MeshFilter).mesh;  
var.normals=mesh.normals;  
var rotation=Quaternion.AngleAxis(Time.deltaTime\*speeed, Vector3.up);  
for (var i=0,i<normals.length;i++)\{  
normals\[i\]=rotation\*normals\[i\];  
\}  
mesh.normals=normals;  
\}  
◆ var subMeshCount: int  
描述：子网格数。每个材质有一个不同的三角形列表。  
◆ var tangents: Vector4\[\]  
描述：网格的切线。  
切线主要用于bumpmap shader中。切线是一个单位长度向量，a沿着网格表面指向水平  
(U)纹理方向。Unity中的切线是由Vector4表示的，x.y.z组件定义向量，如果需要w用来翻  
转副法线。  
Unity通过计算向量和切线之间的叉乘来计算表面的向量（副法线），并乘以  
tangnent.w.因此w应该是1或-1。  
如果你想在网格上使用凹凸贴图着色器，你需要自己计算切线。赋值normals或使用  
RecalculateNormals之后计算切线。  
◆ var tirangles: int\[\]  
描述：一个数组包含网格中所有的三角形。  
   
这个数组时包含顶点数组索引的三角形列表。三角形数组的大小总是3的倍数。顶点  
可以通过简单地索引同一顶点来共享。如果网格包含多个子网格（材质），三角形列表将包  
含所有子网格的所有三角形。建议赋值顶点数组之后赋值一个三角形数组，以避免越界错  
误。  
//构建一个网格，这个网格包含一个带有uv的三角形.  
function start()\{  
gameObject.AddComponent("MeshFilter);  
gameObject.AddComponent("MeshRenderer);  
var.mesh: Mesh=GetComponent(MeshFilter).mesh;  
mesh.Clear();  
mesh.vertices=\[Vector3(0,0,0), Vector3(0,1,0), Vector3(1,1,0)\];  
mesh.uv=\[Vector2(0,0), Vector2(0,1), Vector2(1,1)\];  
mesh.triangles=\[0,1,2\];  
\}  
◆ var uv: Vector2\[\]  
描述：网格的基本纹理坐标。  
//产生一个平面uv坐标  
function start()\{  
var mesh: Mesh=GetComponent(MeshFilter).mesh;  
var vertices=mesh.vertices;  
var uvs=new Vector2\[vertices.lenghth\];  
fpr(var i=0;i<uvs.Length,i++)\{  
uvs\[i\]=Vector2(vertices\[i\].x, vertices\[i\].z);  
\}  
mesh.uv=uvs;  
\}  
◆ var uv2: Vector2\[\]  
描述：网格的第二个纹理坐标集，如果提供。  
//为第二个uv集产生一个平面uv坐标  
function start()\{  
var mesh: Mesh=GetComponent(MeshFilter).mesh;  
var vertices=mesh.vertices;  
var uvs=new Vector2\[vertices.lenghth\];  
fpr(var i=0;i<uvs.Length,i++)\{  
uvs\[i\]=Vector2(vertices\[i\].x, vertices\[i\].z);  
\}  
mesh.uv2=uvs;  
\}  
◆ var vertexCount: int  
描述：网格顶点数（只读）  
function start()\{  
var mesh=GetComponent(MeshFilter).sharedMesh;  
print(mesh.vertexCount);  
\}  
◆ var vertices: Vector3\[\]int  
描述：返回一个顶点位置的拷贝或赋值一个新的顶点位置数组。  
网格的顶点数可，以通过赋值一个不同数量的顶点数组来改变。注意，如果你调整了  
顶点数组，那么所有其他顶点属性（法线，颜色，切线，UV）将被自动地调整大小。设置  
顶点时，如果没有顶点被赋值到这个网格那么RecalculateBounds将自动被调用。  
function start()\{  
var mesh=GetComponent(MeshFilter).sharedMesh;  
var vertics=mesh vertices;  
   
fpr(var i=0;i<vertices.Length,i++)  
\{  
vertices\[i\]+=Vector3.up\*Time.deltaTime;  
\}  
mesh.vertices=vertices;  
mesh.RecalculateBounds();  
\}  
构造函数  
◆ static function Mesh(): Mesh  
描述：创建一个空的网格  
//创建一个新的网格并将它赋给网格过滤器  
function Start()\{  
var mesh=new Mesh();  
GetComponent(MeshFilter).mesh=mesh;  
\}  
函数  
◆ function Clear(): void  
描述：清除所有的顶点数据和所有的三角形索引。  
你应该在重建triangles数组之间调用这个函数。  
◆ function GetTriangles(submesh: int): int\[\]  
描述：返回子网格的三角形列表。  
一个子网格仅仅是一个独立的三角形列表。当网格渲染器使用多个材质时，你应该确保  
有尽可能多的子网格作为材质。  
◆ function Optimize(): void  
描述：优化网格以便显示。  
这个操作将花费一点时间但是会使几何体显示的更快。例如，它从三角形中产生三角形  
带。如果你从头创建一个网格并且想在运行的时候取得更好的运行时性能而不是较高的加  
载时间，你应该使用它。它三角带化你的模型为每个顶点缓存位置优化三角形，对于导  
载时间，你应该使用它。它三角带化你的模型并为每个顶点缓存位置优化三角形。对于导  
入的模型你不应该调用这个，因为导入流水线已经为你做了。  
function Start()\{  
var mesh: Mesh=GetComponent(MeshFilter).mesh;  
mesh.Optimize();  
\}  
◆ function RecalculateBounds(): void  
描述：从顶点重新计算网格的包围提。  
修改顶点之后你应该调用这个函数以确保包围体式正确的。赋值三角形将自动计算  
这个包围体。  
function Start()\{  
var mesh: Mesh=GetComponent(MeshFilter).mesh=mesh;  
mesh.RecalculateBounds();  
\}  
◆ function RecalculateNormals(): void  
描述：从三角形和顶点重新计算网格的法线。  
在调整顶点之后通常需要更新法线以便反映这个改变。法线是从所有共享的顶点来计  
算的。导入的网格有时并不共享所有顶点。例如在UV法线接缝处的点将被分割成两个点。因  
而RecalculateNormals函数在uv接缝处将创建不平滑的法线，RecalculateNormals不会自动  
产生切线，因此bumpmap着色器在调用RecalculateNormals之后不会工作。然而你可以提  
取你自己的切线。  
function Start()\{  
var mesh: Mesh=GetComponent(MeshFilter).mesh;  
mesh.RecalculateNormals();  
\}  
◆ function SetTriangles(triangles: int\[\], submesh: int): void  
描述：为子网格设置多边形列表  
一个子网格仅仅是一个独立的三角形列表。当网格渲染器使用多个材质时，你应该确保  
有尽可能多的子网格作为材质。建议赋值顶点数组之后赋值一个三角形数组，以避免越界  
错误。  
继承的成员  
继承的变量  
name 对象的名称  
hideFlages 该物体是够被隐藏，保存在场景中或被用户修改？  
继承的函数  
GetInstanceID 返回该物体的实例id。  
继承的类函数  
operator bool 这个物体存在吗？  
Instantiate 克隆original物体并返回这个克隆。  
Destroy 移除一个游戏物体，缓存或资源。  
DestroyImmediate 立即销毁物体obj，强烈建议使用Destroy代替。  
FindObjectsOfType 返回所有类型为type的激活物体。  
FindObjectsOfType 返回第一个类型为type的激活物体。  
operator== 比较两个物体是否相同。  
operator != 比较连个物体是否不相同。  
DomDestroyOnLoad 卸载场景时确保物体target不被自动销毁。  
PhysicsMaterial  
类，继承自Object  
载体材质描述：如何处理物体碰撞（摩擦，弹性）  
参见：Collider  
变量  
◆ var bounceCombine: PhysicsMaterialCombine  
描述：决定弹力是如何组合的。  
传统上弹性属性依赖于两种相互接触的材质的组合。然而在游戏中这是不切实的。可以  
使用组合模式来调整两个材质的弹性如何被组合。  
collider.material.bounceCombine=FrictionCombineMode.Average;  
◆ var bouncyness: float  
描述：表面的弹力如何？0值没有弹力。1值没有能力损失的反弹。  
collider.bouncyness=1;  
◆ var dynamicFriction: float  
描述：移动时候使用的摩擦力。这个值在0到1之间。  
0值就像冰，1像橡胶。  
collider.dynamicFriction=1;  
◆ var dynamicFriction2: float  
描述：如果有向摩擦力被启用，dynamicFriction2将沿着FrictionDirection2使用。  
collider.physicMaterial.dynamicFriction2=0;  
◆ var frictionCombine: PhysicMaterialCombine  
描述：决定摩擦力是如何组合的。  
传统上摩擦力属性依赖于两种相互接触的材质的组合。然而在游戏中这是不切实的。  
你可以使用组合模式来调整两个材质的摩擦力如何被组合。  
collider.material.frictionCombine=physicMaterialCombine.Average;  
◆ var frictionDirection2: Vector3  
描述：有向性方向。如果这个矢量是非零，有向摩擦力被启用。  
dynamicFriction2和staticFriction2将沿着frictionDirection2被应用。有向性方向相对于  
碰撞器的局部坐标系统。  
//使碰撞向前滑动而不是侧滑  
collider.physicMaterial.frictionDirection2=Vector3.forward;  
collider.physicMaterial.dynamicFriction2=0;  
collider.physicMaterial.dynamicFriction=1;  
◆ var staticFriction: float  
描述：当一个物体静止在一个表面上时使用的摩擦力。通常是0到1之间的值。  
0值就像冰，1像橡胶。  
collider.staticFriction=1;  
◆ var staticFriction2: float  
描述：如果有向摩擦力被启用，staticFriction2将沿着frictionDirection2使用。  
collider.physicMaterial.staticFriction2=0;  
构造函数  
◆ static function PhysicMaterial(): PhysicMaterial  
描述：创建一个新的材质  
通常只使用collider.material和直接修改附加的材质更加简单。  
//创建一个新的材质并附加它  
function Start()\{  
var material=new PhysicMaterial();  
material.dynamicfriction=1;  
collider.material=material;  
\}  
◆ static function PhysicMaterial(name: string): PhysicMaterial  
描述：创建一个新的材质，命名为name.  
//创建一个新的材质并附加它  
function Start()\{  
var material=new PhysicMaterial("New Material");  
material.dynamicfriction=1  
collider.material=material;  
\}  
继承的成员  
继承的变量  
name 对象的名称  
hideFlages 该物体是够被隐藏，保存在场景中或被用户修改？  
继承的函数  
GetInstanceID 返回该物体的实例id。  
继承的类函数  
operator bool 这个物体存在吗？  
Instantiate 克隆original物体并返回这个克隆。  
Destroy 移除一个游戏物体，缓存或资源。  
DestroyImmediate 立即销毁物体obj，强烈建议使用Destroy代替。  
FindObjectsOfType 返回所有类型为type的激活物体。  
FindObjectsOfType 返回第一个类型为type的激活物体。  
operator== 比较两个物体是否相同。  
operator != 比较连个物体是否不相同。  
DomDestroyOnLoad 卸载场景时确保物体target不被自动销毁  
ScriptableObject  
类，继承自Object  
如果你想创建一个不需要附加到游戏物体的对象，可以从这个类继承、  
这对于那些只存储数据资源是组有用的。  
消息传递  
◆ function OnDisable(): void  
描述：当可编辑物体超出范围时调用这个函数  
当物体被销毁的时候这个函数也会被调用并可以用于任何清理的代码。当脚本在编译  
结束后被加载时，OnDisable将被调用，然后脚本加载完成后OnDisable将被调用。  
function OnDisable()  
\{  
print(:script was removed");  
\}  
OnDisable不能作为一个coroutine.  
◆ function OnEnable(): void  
描述：物体被加载时调用该函数  
function OnEnable()  
\{  
print(:script was enabled");  
\}  
OnEnable不能作为一个coroutine.  
类方法  
◆ static function CreateInstance(className: string): ScriptableObject  
描述：使用className创建一个可编程物体的实例.  
继承的成员  
继承的变量  
name 对象的名称  
hideFlages 该物体是够被隐藏，保存在场景中或被用户修改？  
继承的函数  
GetInstanceID 返回该物体的实例id。  
继承的类函数  
operator bool 这个物体存在吗？  
Instantiate 克隆original物体并返回这个克隆。  
Destroy 移除一个游戏物体，缓存或资源。  
DestroyImmediate 立即销毁物体obj，强烈建议使用Destroy代替。  
FindObjectsOfType 返回所有类型为type的激活物体。  
FindObjectsOfType 返回第一个类型为type的激活物体。  
operator== 比较两个物体是否相同。  
operator != 比较连个物体是否不相同。  
DomDestroyOnLoad 卸载场景时确保物体target不被自动销毁  
GUISkin  
类，继承自ScriptableObject  
变量  
◆ var box: GUIStyle  
描述：用于GUI.Box控件的缺省风格  
◆ var button: GUIStyle  
描述：用于GUI.Button控件的缺省风格  
◆ var GUIStyle\[i\]:  
描述：  
◆ var font: Font  
描述：用于所有风格的缺省字体。  
◆ var horizontalScrollbar: GUIStyle  
描述：  
◆ var horizontalScrollbarLeftButton: GUIStyle  
描述：  
◆ var horizontalScrollbarRightButton: GUIStyle  
描述：  
◆ var horizontalScrollbarThumb: GUIStyle  
描述：  
◆ var horizontalSlider: GUIStyle  
描述：用于GUI.HorizontalSlider控件背景部分的缺省风格.  
用于决定滑块可拖动区域尺寸的填充属性。  
◆ var horizontalSliderThumb: GUIStyle  
描述：用于GUI.HorizontalSlider控件中可拖动滑块的缺省风格.  
用于决定滑块尺寸的填充属性。  
◆ var label: GUIStyle  
描述：用于GUI.Label控件的缺省风格.  
◆ var scrollView: GUIStyle  
描述：  
◆ var settings: GUISettings  
描述：使用这个皮肤的空间如何表现得通用设置。  
◆ var textArea: GUIStyle  
描述：用于GUI.TextArea控件的缺省风格。  
◆ var textField: GUIStyle  
描述：用于GUI.textField控件的缺省风格。  
◆ var toggle: GUIStyle  
描述：用于GUI.toggle控件的缺省风格。  
◆ var verticalScrollbar: GUIStyle  
描述：  
◆ var verticalScrollbarDownButton: GUIStyle  
描述：  
◆ var verticalScrollbarThumb: GUIStyle  
描述：  
◆ var verticalScrollbarUpbutton: GUIStyle  
描述：  
◆ var verticalSlider: GUIStyle  
描述：用于GUI.VerticalSlider控件背景部分的缺省风格.  
用于决定滑块可拖动区域尺寸的填充属性。  
◆ var verticalSliderThumb: GUIStyle  
描述：用于GUI.VerticalSlider控件中可拖动滑块的缺省风格.  
用于决定滑块尺寸的填充属性。  
◆ var window: GUIStyle  
描述：用于GUI.Windows控件的缺省风格。  
函数  
◆ function FindStyle(styleName: string): GUIStyle  
描述：获取一个命名GUIStyle.  
继承的成员  
继承的变量  
name 对象的名称  
hideFlages 该物体是够被隐藏，保存在场景中或被用户修改？  
继承的函数  
GetInstanceID 返回该物体的实例id。  
继承的消息传递  
OnEnable 物体被加载时调用该函数  
OnDisable 可用编程物体超出范围时调用这个函数  
继承的类函数  
CreateInstance 使用className创建一个可编程物体的实例。  
operator bool 这个物体存在吗？  
Instantiate 克隆original物体并返回这个克隆。  
Destroy 移除一个游戏物体，缓存或资源。  
DestroyImmediate 立即销毁物体obj，强烈建议使用Destroy代替。  
FindObjectsOfType 返回所有类型为type的激活物体。  
FindObjectsOfType 返回第一个类型为type的激活物体。  
operator== 比较两个物体是否相同。  
operator != 比较连个物体是否不相同。  
DomDestroyOnLoad 卸载场景时确保物体target不被自动销毁。  
Shader  
类，继承自Object  
用于所以渲染的着色器脚本  
大多数高级的渲染都是通过Material类控制的. Shader类类最常用于检查一个着色器时  
否能够运行在用户的硬件上（isSupported属性）并根据名称找到着色器（Find方法）.  
参见：Material类，Materials，ShaderLab documentation.  
变量  
◆ var isSupported: bool  
描述：这个着色器能够运行在端用户的显卡上？（只读）  
如果这个着色器重的设置和任何fallback函数被支持，返回真。在实现特定的效果时，  
最常使用这个。例如，Unity Pro中的image effects，如果这个着色器不被支持那么Unity将  
自动禁用它们。  
//如果材质的着色器不被支持，禁用渲染器  
if(!renderer material.shader.isSupported)  
renderer.enabled=false;  
参见：Material类，ShaderLab documentation.  
◆ var maximumLOD: int  
描述：该shader的LOD等级  
参见：Shader Level of Detail, Shder globalMaximumLOD.  
◆ var renderQueue: int  
描述：这个shader的渲染队列（只读）  
参见：Material.renderQueue, RenderQueue tag.  
类变量  
◆ static var globalMaximumLOD: int  
描述：所有shader的LOD等级.  
参见：Shader Level of Detail, Shader.MaximumLOD.  
类方法  
◆ static function Find(name: string): Shader  
描述：找到名为name的着色器。  
Shader.Find能够用来切换到另一个着色器，而不需要保持一个到该着色的引用。name  
为材质着色器下拉框中的名称。通常的名称是："Diffuse", "Bumped Diffuse", "VertexLit",  
"Transparent/Diffuse"等等。  
在构建时，只包含那些使用中的shader或位置在"Resources"文件夹中shader。  
//从脚本中改变shader  
function Start()  
\{  
//切换到透明散射着色器  
renderer.material.shader=Shader.Find("Transparent/Diffuse");  
\}  
//从代码创建一个材质  
function Start()  
//使用透明散射着色器创建一个材质  
var material=new Material(Shader.Find("Transparent//Diffuse");  
material.color=Color.green;  
//赋值这个材质到渲染器  
renderer.material=material;  
\}  
参见：Material类。  
◆ static function PropertyToID(name: string): int  
描述：为一个着色器属性名获取唯一标识。  
着色器属性表示被MaterialPropertyBlock函数使用。  
在Unity中着色器属性的每个名称都（例如，\_MainTex或\_Color）被赋予一个唯一的整型  
数，在整个游戏中都不变。  
参见：MaterialPropertyBlock.  
◆ static function SetGlobalColor(propertyName: string, color: Color): void  
描述：为所以着色器设置全局颜色属性。  
如果一个着色器需要而材质没有定义它们将使用全局属性（例如，如果着色器不在  
Properties模块中公开它们）.  
通常在你有一组定义的着色器并使用相同的"全局"颜色（例如，太阳的颜色）。然后  
你可以从脚本中设置全局属性，并不需要在所有的材质中设置相同的颜色。  
参见：SetGlobalFloat，SetGlobalVector，SetGlobalTexture；Material类，ShaderLab  
documentation.  
◆ static function SetGlobalFloat(propertyName: string, value: float): void  
描述：为所有着色器设置全局浮点数属性。  
如果一个着色器需要而材质没有定义它们将使用全局属性（例如，如果着色器不在  
Properties模块中公开它们）.  
通常在你有一组定义的着色器并使用相同的"全局"浮点z数（例如，自定义雾类型的  
密度）。然后你可以从脚本中设置全局属性，并不需要在所有的材质中设置相同的浮点数。  
参见：SetGlobalColor，SetGlobalTexture；Material类，ShaderLab documentation.  
◆ static function SetGlobalMatrix(propertyName: string, mat: Matrix4x4): void  
描述：为所有着色器设置全局矩阵属性。  
如果一个着色器需要而材质没有定义它们将使用全局属性（例如，如果着色器不在  
Properties模块中公开它们）.  
参见：SetGlobalColor，SetGlobalFloat；Material类，ShaderLab documentation.  
◆ static function SetGlobalTexture(propertyName: string, tex: Texture): void  
描述：为所有的着色器设置全局纹理属性。  
如果一个着色器需要而材质没有定义它们将使用全局属性（例如，如果着色器不在  
Properties模块中公开它们）.  
通常在你有一组定义的着色器并使用相同的"全局"纹理（例如，自定义散射光照立方  
贴图）。然后你可以从脚本中设置全局属性，并不需要在所有的材质中设置相同的纹理。  
参见：SetGlobalColor，SetGlobalFloat；Material类，ShaderLab documentation.  
◆ static function SetGlobalVector(propertyName: string, vec: Vector4): void  
描述：为所有着色器设置全局向量属性。  
如果一个着色器需要而材质没有定义它们将使用全局属性（例如，如果着色器不在  
Properties模块中公开它们）.  
通常在你有一组定义的着色器并使用相同的"全局"向量（例如，风的方向）。然后你  
可以从脚本中设置全局属性，并不需要在所有的材质中设置相同的向量。  
参见：SetGlobalFloat，SetGlobalColor，SetGlobalTexture；Material类，ShaderLab  
documentation.  
继承的成员  
继承的变量  
name 对象的名称  
hideFlages 该物体是够被隐藏，保存在场景中或被用户修改？  
继承的函数  
GetInstanceID 返回该物体的实例id。  
继承的类函数  
operator bool 这个物体存在吗？  
Instantiate 克隆original物体并返回这个克隆。  
Destroy 移除一个游戏物体，缓存或资源。  
DestroyImmediate 立即销毁物体obj，强烈建议使用Destroy代替。  
FindObjectsOfType 返回所有类型为type的激活物体。  
FindObjectsOfType 返回第一个类型为type的激活物体。  
operator== 比较两个物体是否相同。  
operator != 比较连个物体是否不相同。  
DomDestroyOnLoad 卸载场景时确保物体target不被自动销毁。  
TerrainData  
类，继承自Object  
TerrainData类存储高度图，细节网格位置，树实例，和地形纹理alph图，  
Terrain组件链接地形数据并渲染它。  
变量  
◆ var heightmapHeight: int  
描述：采样的地形高度（只读）  
◆ var heightmapWidth: int  
描述：采样的地形宽度（只读）  
◆ var size: Vector3  
描述：地形在世界单位下的总大小  
函数  
◆ function GetHeights(xBase: int, yBase: int, width: int, height: int): float\[,\]  
描述：获取高度图采样的一个数组。  
◆ function GetInterpolatedNormal(x: float, y: float): Vector3  
描述：在一个给定的位置获取插值法线。  
/x/和y坐标被作为0...1之间正规化的坐标被指定。  
◆ function SetHeights(xBase: int, yBase: int, height: float): float\[,\]): void  
描述：设置高度图采样的一个数组。  
继承的成员  
继承的变量  
name 对象的名称  
hideFlages 该物体是够被隐藏，保存在场景中或被用户修改？  
继承的函数  
GetInstanceID 返回该物体的实例id。  
继承的类函数  
operator bool 这个物体存在吗？  
Instantiate 克隆original物体并返回这个克隆。  
Destroy 移除一个游戏物体，缓存或资源。  
DestroyImmediate 立即销毁物体obj，强烈建议使用Destroy代替。  
FindObjectsOfType 返回所有类型为type的激活物体。  
FindObjectsOfType 返回第一个类型为type的激活物体。  
operator== 比较两个物体是否相同。  
operator != 比较连个物体是否不相同。  
DomDestroyOnLoad 卸载场景时确保物体target不被自动销毁。  
TextAsset  
类，继承自Object  
文本文件资源。  
你可以在你的工程中使用原始的.txt文件作为资源，并通过这个类获取它们的内容。  
变量  
描述：文本资源的原始字节  
//通过添加.txt扩展名到文件来加载一个.jpg或.png文件  
//并拖动它到imageTextAsset  
var image TextAsset: TextAsset  
function Start()\{  
var tex=new Texture2D(4,4);  
tex.LoadImage(imageTextAsset.bytes);  
renderer.material.mainTexture=tex;  
\}  
◆ var text: string  
描述：.txt文件的文本内容作为一个字符串。  
var asset: TextAsset;  
function Start()  
\{  
print(asset.text);  
\}  
继承的成员  
继承的变量  
name 对象的名称  
hideFlages 该物体是够被隐藏，保存在场景中或被用户修改？  
继承的函数  
GetInstanceID 返回该物体的实例id。  
继承的类函数  
operator bool 这个物体存在吗？  
Instantiate 克隆original物体并返回这个克隆。  
Destroy 移除一个游戏物体，缓存或资源。  
DestroyImmediate 立即销毁物体obj，强烈建议使用Destroy代替。  
FindObjectsOfType 返回所有类型为type的激活物体。  
FindObjectsOfType 返回第一个类型为type的激活物体。  
operator== 比较两个物体是否相同。  
operator != 比较连个物体是否不相同。  
DomDestroyOnLoad 卸载场景时确保物体target不被自动销毁。  
Texture  
类，继承自Object  
用于处理纹理的基类，包含的功能被Texture2D和RenderTexture类共用。  
变量  
◆ var anisoLevel: int  
描述：纹理的各向异性过滤等级  
反走样过滤使纹理从一个较小的视角看时具有较好的效果，但是会带来显卡性能上的开  
值。通常你可以将它用与地面，地板或路面纹理以使它看起来更好。参见：texture assets.  
renderer.material.mainTexture.anisoLevel=2;  
◆ var filterMode: FilterMode  
描述：纹理的过滤模式  
renderer.material.mainTexture.filterMode=FilterMode.trilinear;  
参见：FilterMode, texture assets.  
◆ var height: int  
描述：纹理的像素高度（只读）  
//打印纹理尺寸到控制台  
var texture: Texture;  
function Start()\{  
print("Size is"+texture.width+"by"+texture.height);  
\}  
◆ var mipMapBias: float  
描述：纹理的mipMap偏移。  
一个正的偏移使纹理显得非常模糊，而一个负的偏移使纹理变得更加清晰。注意使用  
大的负值会降低性能，因此不建议使用小于0.5的偏移。在大多数情况先，纹理的锐化可  
以通过使用反走样过滤来实现。  
参见：texture.anisoLevel, texture assets.  
renderer.material.mainTexture.mipMaoBias=0.5;  
◆ var width: int  
描述：纹理的像素宽度（只读）  
//打印纹理尺寸到控制台  
var texture: Texture;  
function Start()\{  
print("Size is"+texture.width+"by"+texture.height);  
\}  
◆ var wrapMode: TextureWrapMode  
描述：纹理的包裹模式（Repeat或Clamp）  
使用TextureWrapMode.Clamp在边界上设置纹理剪裁以避免包裹的不真实，或者用  
TextureWrapMode.Repeat平铺纹理。参见：TextureWrapMode, texture assets.  
renderer.material.mainTexture.WrapMode=TextureWrapMode.Clamp;  
继承的成员  
继承的变量  
name 对象的名称  
hideFlages 该物体是够被隐藏，保存在场景中或被用户修改？  
继承的函数  
GetInstanceID 返回该物体的实例id。  
继承的类函数  
operator bool 这个物体存在吗？  
Instantiate 克隆original物体并返回这个克隆。  
Destroy 移除一个游戏物体，缓存或资源。  
DestroyImmediate 立即销毁物体obj，强烈建议使用Destroy代替。  
FindObjectsOfType 返回所有类型为type的激活物体。  
FindObjectsOfType 返回第一个类型为type的激活物体。  
operator== 比较两个物体是否相同。  
operator != 比较连个物体是否不相同。  
DomDestroyOnLoad 卸载场景时确保物体target不被自动销毁。  
Cubemap  
类，继承自Texture  
处理立方贴图的类，用这个来创建或修改已有的cube map assets.  
变量  
◆ var format: TextureFormat  
描述：纹理中像素数据的格式（只读）  
使用这个确定纹理的格式。  
构造函数  
◆ static function Cubemap(size: int. format: TextureFormat, mipmap: bool): Cubemap  
描述：创建新的空立方贴图纹理；  
在每个面，纹理将是size大小的并且有或没有mipmap.  
通常你会想在创建它之后设置纹理的颜色，使用SetPixel和Apply函数.  
function Start()\{  
//创建一个新的纹理并将它复制给渲染器材质  
var texture=new Cubemap(128, TextureFormat.ARGB32, false)  
renderer.material.mainTexture=Texture;  
\}  
参见：SetPixel，Apply函数.  
函数  
◆ function Apply(updateMipmaps: bool=true): void  
描述：应用所有面前的SetPixel改变.  
如果updateMipMaps为true.mip等级也被重新计算.这是非常耗时的操作，因此你要在  
Apply调用之间改变尽可能多的像素。参见：SetPixel函数.  
◆ function GetPixel(face: CubemapFace, x: int, y: int): Color  
描述：返回坐标（face, X, Y）处的像素颜色.  
如果像素坐标超出边界（大于宽/高或小于0），它将基于纹理的包裹模式来限制或重复。  
该函数只工作再ARGB32,RGB24和Alpha8纹理格式上。对于其他格式，他总是返  
回不透的白色。  
◆ function GetPixels(face: CubemapFace, miplevel: int): Color\[\]  
描述：返回立方贴图一个面的像素颜色.  
这个函数返回立方贴图面上整个mip等级的像素颜色数组。  
返回的数组被设置在2D数组中，这里，像素被从左到右，从上到下放置（行序）数  
组的大小是所使用的mip等级的宽乘高。默认的mip等级是零（基本纹理）在这种情况下  
大小仅为纹理的大小。一般地，mip等级尺寸是mipSize=max(1,width>>miplevel)高度类似。  
该函数只工作在ARGB32,RGB24和Alpha8纹理格式上。对于其他格式，GetPixels被  
忽略.  
使用GetPixels比重复调用GetPixel更快，尤其是对于大纹理，此外GetPixels可以访  
问单独的mipmap等级.  
参见：SetPixels，mipmapCount.  
◆ function SetPixel(face: CubemapFace, x: int, y: int, color: Color): void  
描述：在坐标（face,x,y）处设置像素颜色。  
调用Apply来实际上载改变后的像素到显卡, 上载是非常耗时的操作，因此你要在  
Apply调用之间改变尽可能多的像素。  
该函数只工作再ARGB32,RGB24和Alpha8纹理格式上。对于其他格式SetPixels被  
忽略. 参见：Apply函数.  
◆ function SetPixels(color: Color\[\], face: CubemapFace, mipmapFace, miplevel: int): void  
描述：设置立方贴图一个面的像素颜色。  
这个函数取回并改变整个立方贴图面的像素颜色数组。调用Apply来实际上载改变后  
的像素到显卡.  
colors数组被放置在2D数组中，这里，像素被从左到右，从上到下放置（行序）数组  
的大小必须至少是所使用的mip等级的宽乘高。默认的mip等级是零（基本纹理）在这种  
情况下大小仅为纹理的大小。一般地，mip等级尺寸是mipSize=max(1,width>>miplevel)高  
度类似。  
该函数只工作在ARGB32,RGB24和Alpha8纹理格式上。对于其他格式，GetPixels被  
忽略.  
参见：GetPixel, Apply, mipmapCount.  
继承的成员  
继承的变量  
name 对象的名称  
hideFlages 该物体是够被隐藏，保存在场景中或被用户修改？  
继承的函数  
GetInstanceID 返回该物体的实例id。  
继承的类函数  
operator bool 这个物体存在吗？  
Instantiate 克隆original物体并返回这个克隆。  
Destroy 移除一个游戏物体，缓存或资源。  
DestroyImmediate 立即销毁物体obj，强烈建议使用Destroy代替。  
FindObjectsOfType 返回所有类型为type的激活物体。  
FindObjectsOfType 返回第一个类型为type的激活物体。  
operator== 比较两个物体是否相同。  
operator != 比较连个物体是否不相同。  
DomDestroyOnLoad 卸载场景时确保物体target不被自动销毁。  
MovieTexture  
类，继承自Texture  
Movie Textures是可以播放电影的纹理  
它们可以用于过场动画电影序列，或者渲染电影到场景中。  
变量  
◆ var audioClip: AudioClip  
描述：返回属于MovieTexture的AudioClip.  
注意这是一个特定的AudioClip它总是与电影同步播放音频。在编辑器重如果你将电影  
的audioClip附加到一个源上，它将在电影播放的时候自动开始播放，否则你必须收动开  
始它，剪辑只能被附加到一个AudioSource。  
◆ var isPlaying: bool  
描述：返回电影是否在播放  
◆ var isReadyToPlay: bool  
描述：如果电影是从网站上下载的，这个返回是够已经下载了足够的数据以便能够不同  
版的播放它。  
对于不是来自web的流的电影，这个值是返回真。  
function Start()\{  
www=new WWW(url);  
guiTexture.texture=www.movie;  
\}  
function Update()\{  
if(!guiTexture.texture.isPlaying&&guiTexture.texture.isReadyToPlay)  
guiTexture.texture.Play();  
\}  
◆ var loop: bool  
描述：这个为真时电影循环。  
函数  
◆ function Pause(): void  
描述：暂停播放电影。  
function Start()\{  
renderer.material.mainTexture.Pause();  
\}  
◆ function Play(): void  
描述：开始播放电影。  
注意运行的MovieTexture将使用大量的CPU资源，并且它将持续运行直到它被手、  
动停止或加载一个新的关卡。参见：stop  
function Start()\{  
renderer.material.mainTexture.Play();  
\}  
继承的成员  
继承的变量  
width 纹理的像素宽度（只读）  
height 纹理像素高度（只读）  
filterMode 纹理的过滤模式  
anisoLevel 纹理的各向异性过滤等级  
wrapMode 纹理的包裹模式（Repeat或Clamp）  
mipMapBias 纹理的mipMap便宜。  
name 对象的名称  
hideFlages 该物体是够被隐藏，保存在场景中或被用户修改？  
继承的函数  
描述：渲染纹理的尺寸限制为2的幂次？  
当创建图像后刷处理效果时，你应该总是设置这个为false因为这允许四面  
ReaderTexture大小问任意屏幕大小。  
当为普通的材质和shader使用RenderTexture时，你应该总是设置这个为true因为这允  
许像普通纹理一样使用一个RenderTexture.  
◆ var useMipMap: bool  
描述：生成mipmap等级？  
当设置为true，渲染到这个纹理将创建并生成mipmap等级面膜人的渲染纹理没有  
mipmap.  
这个这毙用于2的幂次方尺寸的渲染纹理（参考isPowerOfTwo).  
◆ var width: int  
描述：渲染纹理的像素宽度。  
注意不像Texture.height属性，这个是可读写的，设置一个值来改变大小  
构造函数  
◆ static function ReaderTexture(width: int, height: int, depth: int): ReaderTexture  
描述：创建一个新的RenderTexture对象。  
渲染纹理使用width x height尺寸创建，深度缓存为depth位（深度可以是0,16或24）  
渲染纹理或设置为非2的幂次纹理并使用默认的color format  
注意创建一个RenderTexture不会立即创建硬件表示。实际的渲染纹理是第一次使用  
是创建或当Create被手动调用时创建。因此在创建渲染纹理之后，你可以设置额外的变量，如  
isPowerOfTwo, format, isCubemap等等。  
参见：isPowerOfTwo变量, format变量.  
函数  
◆ function Create(): bool  
描述：实际创建RenderTexture。  
RenderTexture构造函数实际上并没有创建硬件纹理：默认的纹理第一次创建时被设置  
为active，调用Create来创建它。如果纹理已经被创建Create不做任何事。  
参见：Release，isCreated函数.  
◆ function IsCreate(): bool  
描述：渲染纹理产生了？  
RenderTexture构造函数实际上并没有创建硬件纹理：默认的纹理第一次创建时被设置  
为active，如果用于渲染的的硬件资源被创建了，IsCreate返回ture.  
参见：Create，Release函数.  
◆ function Release(): void  
描述：释放RenderTexture。  
这个函数释放由这个渲染纹理使用的硬件资源，纹理本身并不被销毁，并在使用的时候  
被自动再次创建。  
参见：Create，IsCreate函数.  
◆ function SetBorderColor(color: Color): void  
描述：为这个渲染纹理设置为边框颜色。  
如果显卡支持"剪裁到边界"，那么任何超出0...1UV范围的纹理采样将返回边界颜色。  
◆ function SetGlobalShaderProperty(propertyName: string): void  
描述：赋值这个RenderTexture为一个名为propertyName的全局shader属性。  
类变量  
◆ static var active: RenderTexture  
描述：激活的渲染纹理。  
所有的渲染将进入激活的RenderTexture如果活动的RenderTexture未null所有的东西都  
被渲染到主窗口.  
当你一个RenderTexture变为激活，如果它还没有被创建，硬件渲染内容将被自动创建。  
类方法  
◆ static function GetTemporary(width: int, height: int, depthBuffer: int, format:  
RenderTextureFormat=RenderTextureFormat.ARGB32): RenderTexture  
描述：分配一个临时的渲染纹理。  
这个函数被优化，用于当你需呀一个快速RenderTexture来做一些临时计算时，一旦完  
成使用ReleaseTemporary释放它，这样，如果需要，另一个调用能够开始重用它。  
◆ static function ReleaseTemporary(temp: RenderTexture): void  
描述：释放一个由GetTemporary分配的临时纹理。  
如果可能，之后调用GetTemporary将重用前面创建的RenderTexture，如果没有请来临  
时RenderTexture，几帧后它将被销毁。  
继承的成员  
继承的变量  
width 纹理的像素宽度（只读）  
height 纹理像素高度（只读）  
filterMode 纹理的过滤模式  
anisoLevel 纹理的各向异性过滤等级  
wrapMode 纹理的包裹模式（Repeat或Clamp）  
mipMapBias 纹理的mipMap便宜。  
name 对象的名称  
hideFlages 该物体是够被隐藏，保存在场景中或被用户修改？  
继承的函数  
GetInstanceID 返回该物体的实例id。  
继承的类函数  
operator bool 这个物体存在吗？  
Instantiate 克隆original物体并返回这个克隆。  
Destroy 移除一个游戏物体，缓存或资源。  
DestroyImmediate 立即销毁物体obj，强烈建议使用Destroy代替。  
FindObjectsOfType 返回所有类型为type的激活物体。  
FindObjectsOfType 返回第一个类型为type的激活物体。  
operator== 比较两个物体是否相同。  
operator != 比较连个物体是否不相同。  
DomDestroyOnLoad 卸载场景时确保物体target不被自动销毁。  
Texture2D  
类，继承自Texture  
用于处理纹理的类。使用这个来创建临时的纹理或修改已经存在的texture assets  
变量  
◆ var format: TextureFormat  
描述：纹理中像素数据的格式（只读）  
使用这个确定纹理的格式。  
◆ var mipmapCount: int  
描述：在这个纹理中有多少Mipmap等级（只读）  
返回值也包含基本等级，因此他总是1或更大。  
如果你使用GetPixels或SetPixels来取回或修改不同的mip等级时，需要使用  
mipmapCount. 例如，你可以改变一个纹理以便每个mip等级以不同的颜色修改. 然后再游  
戏中你可以看到那个mip等级被实际使用了。  
参见：GetPixels函数，SetPixels函数。  
构造函数  
◆ static function Texture2D(width: int, height: int): Texture2D  
描述：创建新的空纹理；  
纹理为width乘height大小，TextureFormat为ARGB32带有mipmap.  
通常你会想到在创建它之后设置纹理的颜色，使用SetPixel，SetPixels和Apply函数。  
function Start()\{  
//创建一个新的纹理并将它赋给渲染器材质  
var texture=new Texture2D(128,128);  
renderer.material.mainTexture=texture;  
\}  
参见：SetPixel，SetPixels，Apply函数.  
◆ static function Texture2D(width: int, height: int, format: TextureFormat, mipmap: bool):  
Texture2D  
描述：创建新的空纹理；  
纹理为width乘height大小，具有给定的format有或没有miamap.  
通常你会想到在创建它之后设置纹理的颜色，使用SetPixel，SetPixels和Apply函数。  
创建不允许有压缩纹理格式的贴图。  
function Start()\{  
//创建一个新的纹理并将它赋给渲染器材质  
var texture=new Texture2D(128,128, TextureFofrmat.AGRB32, false);  
renderer.material.mainTexture=texture;  
\}  
参见：SetPixel，SetPixels，Apply函数.  
函数  
◆ function Apply(updateMipmaps: bool=true): void  
描述：实际地应用前面的SetPixel和SetPixels改变.  
如果updateMipmaps为true，mipmap等级也被重新计算，使用基本等级作为源.通常  
你会想在所有的情况下使用true，除非你已经使用SetPixels修改了mip等级。  
这是非常耗时的操作，因此你要在Apply调用之间改变尽可能多的像素。  
function Start()\{  
//创建一个新的纹理并赋值它到渲染器材质  
var texture=new Texture2D(128,128);  
renderer.material.mainTexture=texture;  
//用Sierpinski分形模式填充！  
for(y=0; y<texture.height; ++y) \{  
for(x=0; x<texture.width; ++x) \{  
var color=(x&y)? Color.white: Color.gray;  
texture.SetPixel(x, y, color);  
\}  
\}  
//应用所有的SetPixel调用  
texture.Apply();  
\}  
参见：SetPixel，SetPixels函数.  
◆ function Compress(highQuality: bool): void  
描述：压缩纹理问DXT格式。  
使用这个来压缩在运行时生成的纹理。压缩后的纹理使用较少的显存并可以更快地被  
渲染。  
压缩之后，如果原始纹理没有alpha通道纹理将是DXT1格式，如果它有alpha通道纹理  
将是DXT5格式.  
传递true到highQuality将在压缩过程中抖动源纹理，这可以帮助提高压缩质量但是会  
有一些慢。  
如果显卡不支持压缩或者纹理已经是压缩格式，那么Compress将不做任何事情。  
参见：SetPixels函数.  
◆ function EncodeToPNG(): byte\[\]  
描述：编码这个纹理为PNG格式。  
返回的字节数组是PNG"文件"。你可以将它们写在键盘上以便获取PNG文件，并通  
过网格发送它们。  
该函数只工作在ARGB32和RGB24纹理格式上。对于ARGB32纹理编码的PNG数  
据将包含alpha通道。对于RGB24纹理不包含alpha通道。PNG数据将不包含伽马矫正或颜  
色配置信息。  
//存储截屏为PNG文件。  
import System.1();  
//立即截屏  
function Start()\{  
UploadPNG();  
\}  
function UploadPNG()\{  
//只在渲染完成后读取屏幕缓存  
yield WaitForEndOfFrame();  
//创建一个屏幕大小的纹理，RGB24格式  
var width=Screen.width;  
var height=Screen.height;  
var tex=new Texture2D(width, height, TextureFormat.RGB24, false);  
//读取屏幕内容到纹理  
tex ReadPixels(Rect(0, 0, width, height), 0, 0);  
tex.Apply();  
//编码纹理为PNG文件  
var bytes=tex.EncodeToPNG();  
Destroy(tex);  
//处于测试目的，也在工程文件夹中写一个文件  
//File.WriteAllBytes(Application.dataPath+"/../SavedScreen.png", bytes);  
//创建一个Web表单  
var form=new WWWForm();  
form.AddField("frameCount", Time.frameCount.ToString());  
form.AddBinaryData("fileUpload",bytes);  
//上传到一个CGI脚本  
var w=WWW("[http://localhost/cgi-bin/env.cgi?post",form][http_localhost_cgi-bin_env.cgi_post_form]);  
yield w;  
if(w.error!=null)  
\{  
print(w.error);  
\}  
else\{  
print("Finished Uploading Screenshot");  
\}  
\}  
参见：ReadPixels, WaitForEndOfFrame, LoadImage.

[http_localhost_cgi-bin_env.cgi_post_form]: http://localhost/cgi-bin/env.cgi?post'%20rel=