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

时间 2019-11-09

标签 unity3d unity 脚本中文系列教程十二繁體版

原文原文链接

http://dong2008hong.blog.163.com/blog/static/4696882720140313545332/web

GameObject类，继承自Object编程

Unity场景中全部实体的基类。
参见：Componentc#

变量数组

◆ var active: bool缓存

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

◆ var animation: Animation编辑器

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

◆ var audio: AudioSource函数

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

◆ 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);
}

///////////////////////////////////////////////////

//////////////////////////////////////////////////////////

参见：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);yield w;if(w.error!=null){print(w.error);}else{print("Finished Uploading Screenshot");}}参见：ReadPixels, WaitForEndOfFrame, LoadImage.