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

http://dong2008hong.blog.163.com/blog/static/469688272014032334486/

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

◆ function GetPixel(x: int, y: int): Color

描述：返回坐标(x, y)处的像素颜色。
如果像素坐标超出边界（大于宽/高或小于0），它将给予纹理的包裹模式来限制或重复。
如果你正在从纹理中读一个大的像素块，使用GetPixels可能会更快，它将返回整个像
素颜色块。
该函数只工作在ARGB32, RGB24和Alpha8纹理格式上。对于其他格式，他总是返
回不透的白色。
//设置变换的y坐标为跟着高度图
var heightmap: Texture2D;
var size=Vector3(100, 10, 100);
function Update()
{
    var x: int=transform.position.x/size.x*heightmap.width;
    var z: int=transform.position.z/size.z*heightmap.height;
    transform.position.y=heightmap.GetPixel(x,z).grayscale*size.y;
}
参见：GetPixels, SetPixel, GetPixelBilinear.

◆ function GetPixelBilinear(u: float, v: float): Color

描述：返回正规化坐标(u, y)处的过滤像素颜色。
坐标u和v从0.0到1.0，就像网格上的UV坐标。如果坐标超出边界（大于1小于0）.
它基于纹理的包裹模式来限制或重复。
返回被双线性过滤的像素颜色。
该函数只工作在ARGB32, RGB24和Alpha8纹理格式上。对于其他格式，他总是返
回不透的白色。
参见：GetPixel.

◆ function GetPixels(miplevle: int): Color[]

描述：获取一块像素颜色。
这个函数返回纹理整个mip等级的像素颜色数组。
返回的数组被放置在2D数组中，这里，像素被从左到右，从上到下放置（行序）数
组的大小是所使用的mip等级的宽乘高。默认的mip等级是零（基本纹理）在这种情况下
大小仅为纹理的大小。一般地，mip等级尺寸是mipWidth-max(1,width>>miplecvel)高度类
似。
该函数只工作在ARGB32, RGB24和Alpha8纹理格式上。对于其他格式GetPixels被忽
略。
使用GetPixels比重复调用GetPixel更快，尤其是对于大纹理. 此外，GetPixels可以访
问单独的mipmap等级.
参见：GetPixels, mipmapCount.

◆ function GetPixels(x: int, y: int, blockWidth: int, blockHeight: int, miplevel: int): Color[]

描述：获取一块像素颜色。
这个函数是上面GetPixels函数的扩展；它不会返回整个mip等级而只是返回开始于x，y
点blockWidth乘blockHeight的区域。该块必须适合使用的mip等级。返回的数组是
blockWidth*blockHeight尺寸。

◆ function LoadImage(data: byte[]): bool

描述：从一个字节数组中加载一个图片。
这个函数从原始的字节数组中加载一个JPG和PNG图片。
//通过添加.txt扩展名刀文件来加载一个.jpg或.png文件
//并拖动它到imageTextAsset
var imageTextAsset: TextAsset;
function Start()
{
    var tex=new Texture2D(4,4);
    tex.LoadImage(imageTextAsset.bytes);
    renderer.material.mainTexture=tex;
}
参见：EncodeToPNG函数.

◆ function PackTextures(textures: Textures2D[]. padding: int, maximumAtlasSize: int=
2048): Rect[]

参数

textures 纹理数组被打包到集合汇总。
padding 打包纹理的像素间距。
maximumAtlasSize 调整纹理的最大尺寸。
返回Rect[]-一个矩形数组，数组包含每个输入纹理的UV坐标集合，如果打包失败
为mull。
描述：打包多个textures到一个纹理集中。
这个函数将使用纹理集替换当前纹理。尺寸，格式和纹理是否有Mipmap可以在打包后
改变。
生成的纹理集尽可能的大以便适合所有输入的纹理，但是在没有维度上不超过
maximumAtlasSize. 如果输入的纹理不能适合纹理集合的大小，它们将被缩小。
如果所有导入的纹理是DXT1压缩格式的，纹理集也有DXT1格式. 如果所有输入纹理
被以DXT1或DXT5格式压缩，那么集合将是DXT5格式。如果任何输入的纹理是没有压
缩的，那么集合将是ARGB32来压缩格式。
如果输入的纹理没有mipmap，那么集合也将不会有mipmap。

◆ function ReadPixels(source: Rect, destX: int, destY: int, recalculateMipMaps: bool=
true: void

描述：读取屏幕像素到保存的纹理数据中。
这将从当前激活的ReaderTexture或试图（由/source/指定）拷贝一个矩形像素区域到由
destX和destY定义的位置上. 两个坐标都是用像素空间-(0,0)为左下角。
如果recalculateMipMaps被设置为真，纹理的Mip贴图也将被更新。如果
recalculateMipMaps被设置为假，你必须调用Apply重计算它们.
该函数只工作在ARGB32和RGB24纹理格式上。
参见：EncodeToPNG.

◆ function Resize(width: int, height: int, format: TextureFormat, hasMipMap: bool): bool

描述：调整纹理大小。
改变纹理的尺寸为width乘height，格式为textureFormat并有选择地创建Mip贴图.调
整大小后，纹理像素将是未定义的。这个函数非常类似与纹理构造器，除了它工作在已存
在的纹理物体上。
调用Aplly来实际上载改变后的像素到显卡。
不允许调整压缩纹理格式的大小。

◆ function Resize(width: int, height: int): bool

描述：调整纹理大小。
改变纹理的大小为width乘height。调整大小后，纹理像素将是未定义的。这个函数
非常类似与纹理构造器，除了它工作在已存在的纹理物体上。
调用Aplly来实际上载改变后的像素到显卡。
不允许调整压缩纹理格式的大小。

◆ function SetPixel(x: int, y: int, color: Color): void

描述：在坐标（x，y）处设置像素颜色。
调用Aplly来实际上载改变后的像素到显卡。上载是非常耗时的操作，因此你要在
Apply调用之间改变尽可能多的像素。
如果你需要在运行时频繁重计算一个纹理，生产一个像素颜色数组并用SetPixels一次设
置它们，这种方法要快一些。
该函数只工作在ARGN32, RGB24和Alpha8纹理格式上。对于其他格式SetPixel被
忽略。
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();

}
参见：SetPixels，GetPixel, Apply.

◆ function SetPixels(Colors: Color[], miplevel: int): void

描述：设置一块像素颜色。
这个函数取的并改变纹理整个mip等级的像素颜色数组调用Apply来实际上载改变
后的像素到显卡.
Colors数组被放置在2D数组中，这里，像素被从左到右，从上到下放置（行序）数组
的大小必须至少是所使用的mip等级的宽乘高。默认的mip等级是零（基本纹理）在这种
情况下大小仅为纹理的大小。一般地，mip等级尺寸是mipWidth-max(1,width>>miplecvel)
高度类似。
该函数只工作在ARGB32, RGB24和Alpha8纹理格式上。对于其他格式GetPixels被
忽略。
使用GetPixels比重复调用GetPixel更快，尤其是对于大纹理. 此外，GetPixels可以访问
单独的mipmap等级.
参见：GetPixels, Apply, mipmapCount.
//这个脚本用不同的颜色修改纹理的Mip等级
//(第一个等级为红色，第二个为绿色，第三个为蓝色)，你可以使用这个来查看
//那个Mip被实际使用和如何使用.
function Start()

{
     //赋值原始的纹理并赋值给材质
     var texture: Texture2D=Instantiate(Renderer.material.mainTexture);
     renderer.material.mainTexture=texture;
     //colors用来修改前3个mip等级
     var colors=new Colors[3];
     colors[0]=Color.red;
     colors[1]=Color.green;
     colors[2]=Color.blue;
     var mipCount=Mathf.Min(3, texture.mipmapCount);
     //修改每个Mip等级
     for(var mip=0; mip<mipCount; ++mip)

{
         var cols=texture.GetPixels(mip);
         for(var i=0; i<cols.Length; ++i)

{
            cols[i]=ColorLerp(cols[i], colors[mip], 0.33);
         }
         texture.SetPixel(cols, mip);
      }
      //实际应用SetPixels，不重新计算mip等级
      texture.Apply(false);
}

◆ function SetPixels(x: int, y: int, blockWidth: int, blochHeight: int, Colors: Color[],miplevel: int): void

描述：设置一块像素颜色。
这个函数是上面SetPixels函数的扩展；它不会修改整个mip等级而只是修改开始于x，y
点blockWidth乘blockHeight的区域。该colors数组必须是blockWidth*blockHeight大小，并
且可修改的块比例适应适应的Mip等级。

继承的成员
继承的变量

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不被自动销毁。

Particle
结构

参见：ParticleEmitter，Particles documentation.

变量

◆ var color: Color

描述：粒子的颜色。
颜色的Alpha通道用来淡出粒子。
参见：Particles documentation.

◆ var energy: float

描述：粒子的能量。
这是粒子生存的时间。当能量低于零时粒子将被销毁。
能量也被用于UV动画。
如果energy等于ParticleEmitter.maxEnergy第一个瓦片将被使用。
如果energy等于0最后一个瓦片将被使用。
参见：Particles documentation.

◆ var position: Vector3

描述：粒子的位置。
参见：Particles documentation.

◆ var size: float

描述：粒子的大小。
在世界空间中粒子的尺寸，以来计。
参见：Particles documentation.

◆ var velocity: Vector3

描述：粒子的速度。
如果有一个particel animator它将根据velocity移动粒子. 如果Stretch Particles被设置为
ParticleRenderMode.Stretch，这个速度也被particle render使用。
参见：Particles documentation.

Path 类

类方法

◆ static function Combine(path1: string, path2: string): string

描述：连接两个路径字符串。

如果path1没有一个有效的结束分隔符，在合并之前DirectorySeparatorChar将被追加到path1。

//Remember to import IO to make Path work.

//记得导入IO，使路径正常工作
import System.IO;
function Start ()

{
     //This will print "/First/Path/To/Some/File/At/foo.txt".
     Debug.Log(Path.Combine("/First/Path/To", "Some/File/At/foo.txt"));
}

◆ static function GetDirectoryName(path: string): string

描述：返回指定路径字符串组件的目录名字。

此方法返回路径的字符串包含的所有字符在首个和最后一个DirectorySeparatorChar或AltDirectorySeparatorChar字符之间。首个分割字符包含在内，但是最后一个分隔符不包含在返回的字符串。

//记得导入IO，是路径正常工作
import System.IO;
function Start ()

{
     //This will print "/Path/To/A/File".
     Debug.Log(Path.GetDirectoryName("/Path/To/A/File/foo.txt"));
}

◆ static function GetExtension(path: string): string

描述：返回指定路径字符串的组件扩展名。

扩展名返回包含.字符，用于从路径的其余部分分割扩展名。

//记得导入IO，使路径正常工作 import System.IO; function Start ()

{ //打印.extension Debug.Log(Path.GetExtension("/Some/File/At/foo.extension")); }

◆ static function GetFileName(path: string): string

描述：返回指定路径字符串组件的基本文件名，不带有扩展名。简单来说就是返回一个没有扩展名的文件名。

返回值包括由GetFileName()返回的字符串，去掉扩展名分隔符和扩展名。

//记得导入IO，才能是路径正常工作 import System.IO; function Start ()

{ //打印foo.extension Debug.Log(Path.GetFileName("/Some/File/At/foo.extension")); }

◆ static function GetFileNameWithoutExtension(path: string): string

描述：返回指定路径字符串组件的基本文件名，不带有扩展名。简单来说就是返回一个没有扩展名的文件名。

返回值包括由GetFileName()返回的字符串，去掉扩展名分隔符和扩展名。

//记得导入IO，使Path工作
import System.IO;
function Start ()

{
    //这会打印"foo"
    Debug.Log(Path.GetFileNameWithoutExtension("/Some/File/At/foo.extension"));
}

Physics
类

全局屋里属性和辅助方法。

类变量

◆  static var bounceThreshold: float

描述：两个碰撞物体的相对速度对于这个值时将不会反弹（默认为2）。必须为正
这个值可以在Edit->Project Settings->Physics的检视面板中改变而不是通过脚本。

Physics.bounceThreshold = 1;

◆  static var gravity: Vector3

描述：应用到场景所以刚体的重力。
重力可以通过在单体刚体上使用useGravity属性关闭。
Physics.gravity=Vector3(0,-1,0,0);

◆  static var maxAngularVelocity: float

描述：允许用于任何刚体的缺省最大角速度（默认为7）。必须为正
刚体的角速度最大为maxAngularVelocity以避免高速旋转物体的数值不稳定性。因为
这也许会阻止企图快速旋转的物体，例如车轮，你可以使用Rigidbody.maxAngularVelocity
逐刚体重载该值。
这个值可以在Edit->Project Settings->Physics的检视面板中改变而不是通过脚本。
Physics.maxAngularVelocity=10;

◆  static var minPenetrationForPenalty: float

描述：最小的接触渗透值，以便应用一个罚力（默认为0.05）必须为正
这个值可以在Edit->Project Settings->Physics的检视面板中改变而不是通过脚本。
Physics.minPenetrationForPenalty=0.1;

◆  static var sleepAngularVelocity: float

描述：缺省的角速度。低于该值的物体将开始休眠（默认为0.14）。必须为正
参考Rigidbody Sleeping获取更多信息。这个值可以使用Rigidbody.sleepAngularVelocity
来逐刚体重载。
这个值可以在Edit->Project Settings->Physics的检视面板中改变而不是通过脚本。
Physics.sleepAngularVelocity=0.1;

◆ static var sleepVelocity: float

描述：缺省的线性速度，低于改值的物体将开始休眠（默认为0.15）。必须为正。
参考Rigidbody Sleeping获取更多信息。则会更值可以使用Rigidbody.sleepVelocity来逐
刚体重载。
这个值可以在Edit->Project Setting->Physics的检视面板中改变而不是通过脚本
Physics.sleepVelocity=0.1;

◆ static var solverIterationCount: int

描述：允许用于任何刚体的缺省迭代数（默认为7）。必须为正。
solverIterationCount聚顶关节和接触点如何精确地计算。如果出现链接的物体震荡和行
为怪异，为solver Iteration Count设置一个较高的值将改善他们的稳定性（但是比较慢）。通
常值7可以在几乎所有的情况下工作的很好。
这个值可以在Edit->Project Settings->Physics的检视面板中改变而不是通过脚本.
Physics.solverIterationCount=10;

类方法

◆ static function CheckCapsule(start: Vector3, end: Vector3, radius: float, layermask: int=kDefaultRaycastLayers): bool

描述：如果有任何碰撞器接触到由世界坐标中的start和end构成的轴并具有radius半
径的胶囊时返回真。

◆ static function CheckSphere(position: Vector3, radius: float, layermask: int=
kDefaultRaycastLayers): bool

描述：如果有任何碰撞器接触到由世界坐标中的position和radius定义的球体时返回
真。

◆ static function IgnoreCollision(collider1: collider, collider2: collider, ignore: bool=true): void

描述：使碰撞检测系统忽略所有collider1和collider2之间的任何碰撞。
这是最有用的，如投射物不与发射他们的物体碰撞。
IgnoreCollision有一些限制：1）它不是持久的. 这个以为着当保存场景时，忽略碰撞
状态将不会存储在编辑器重。2）你只能将忽略碰撞应用到激活物体的碰撞器上. 当不激活
碰撞器或附加的刚体时，IgnoreCollision将丢失并且你必须再次调用Physics.IgnoreCollision.
//实例化一个子弹并使它忽略与这个物体的碰撞
var bulletPrefab: Transform;
function Start()
{
    var bullet=Instantiate(bulletPrefab);
    Physics.IgnoreCollision(bullet.collider, collider);
}

◆ static function Linecast(start : Vector3, end : Vector3, layerMask : int = kDefaultRaycastLayers) : bool

描述：如果有任何碰撞器与从start开始到end的线段相交时返回真.

如果返回真，hitInfo将包含更多关于碰撞器被碰到什么地方的信息（参考：RaycastHit）.
当投射射线时，Layer mask被用来选择性的忽略碰撞器.

var target: Transform;
function Update()

{
     if(!Physics.Linecast(transform.position, target.position})

{
         //做一些事情

ProcessData.AndDoSomeCalculations();
     }
}
当投射射线时，Layer mask被用来选择性的忽略碰撞器.

◆ static function OverlapSphere(position: Vector3, radius: float, layerMask: int=
kAllLayers): Collider[]

描述：返回触碰到的或在球体内的所有碰撞器的列表.
注意：当前这个值检查碰撞器的包围体耳不是实际的碰撞器。

◆ static function Raycast(origin: Vector3, direction: Vector3, distance: float=Mathf.Infinity,layerMask: int=kDefaultRaycastLayers): bool

参数

origin 世界坐标中射线的开始点。
direction 射线的方向。
distance 射线的长度。
layerMask 当投射射线时，layer mask被用来选择性的忽略碰撞器.
返回：布尔值-当射线碰到任何碰撞器时为真，否则为假.
描述：投射一个射线与场景中的所有碰撞器相交。
function Update()

{
     var hit: RaycastHit;
     var fwd=transform.TransformDirection(Vector3.forward);
     if(Physics.Raycast(transform.position, fwd, 10))
     {
          pring("There is something in front of the object!");
     }
}

◆ static function Raycast(origin: Vector3, direction: Vector3, out hitInfo: RaycastHit,distance: float=Mathf.Infinity, layerMask: int=kDefaultRaycastLayers): bool

参数

origin 世界坐标中射线的开始点。
direction 射线的方向。
distance 射线的长度。
hitInfo 如果返回真，hitInfo将包含更多关于碰撞器被碰到什么地方的信息（参
考: RaycaseHit）.
layerMask 当投射射线时，layer mask被用来选择性的忽略碰撞器.
返回：布尔值-当射线碰到任何碰撞器时为真，否则为假.
描述：投射一个射线并碰撞场景中的所有碰撞器闭并返回碰撞的细节。
function Update()

{
     var hit: RaycastHit;
     if(Physics.Raycast(transform.position, -Vector3 up, hit))

{
          distanceToGround=hit.distance;
      }
}
//向上投射100米
function Update()
{
     var hit: RaycastHit;
     if(Physics.Raycast(transform.position, -Vector3 up, hit, 100.0))

{
          distanceToGround=hit.distance;
      }
}

◆ static function Raycast(ray: Ray, distance: float=Mathf.Infinity, layerMask: int=
kDefaultRaycastLayers): bool

参数

ray 射线的开始点和方向。
distance 射线的长度。
layerMask 当投射射线时，layer mask被用来选择性的忽略碰撞器.
返回：布尔值-当射线碰到任何碰撞器时为真，否则为假.
描述：同上使用ray.origin和ray.direction而不是origin和direction.
var ray=Camera.main.ScreenPointToRay(Input.mousePosition);
if(Physics.Raycast(ray, 100))

{
    print("Hit something");
}

◆ static function Raycast(ray: Ray, out hitInfo: RaycastHit, distance: float=Mathf.Infinity,layerMask: int=kDefaultRaycastLayers): bool

参数

ray 射线的开始点和方向。
distance 射线的长度。
hitInfo 如果返回真，hitInfo将包含更多关于碰撞器被碰到什么地方的信息（参
考：RaycastHit）
layerMask 当投射射线时，layer mask被用来选择性的忽略碰撞器.
返回：布尔值-当射线碰到任何碰撞器时为真，否则为假.
描述：同上使用ray.origin和ray.direction而不是origin和direction.
var ray=Camera.main.ScreenPointToRay(Input.mousePosition);
var hit: RaycastHit;
if(Physics.Raycast(ray, hit, 100))

{
     Debug.DrawLine(ray.origin, hit.point);
}

◆ static function RaycastAll(ray: Ray, distance: float=Mathf.Infinity, layerMask: int=
kDefaultRaycastLayers): RaycastHit[]

function Update ()

{
     var hits : RaycastHit[];
     hits = Physics.RaycastAll (transform.position, transform.forward, 100.0);
    // Change the material of all hit colliders
    // to use a transparent Shader
    for (var i = 0;i < hits.Length; i++)

{
         var hit : RaycastHit = hits[i];
         var renderer = hit.collider.renderer;
         if (renderer)

{
              renderer.material.shader = Shader.Find("Transparent/Diffuse");
              renderer.material.color.a = 0.3;
          }
      }
}
◆ static function RaycastAll(origin: Vector3, direction: Vector3, distance: float=
Mathf.Infinity, layerMask: int=kDefaultRaycastLayers): RaycastHit[]
描述：投射一个穿过场景射线并返回所有的碰撞的东西。
function Update()

{
     var hit: RaycastHit[];
     hits=Physics.RaycastAll(transform.position,transform.forward, 100.0);
     //改变所有碰到的碰撞器的材质
     //使用一个透明Shader
     for(var i=0,i<hits.length,i++)

{
          var hit: RaycastHit=hits[i];
          var renderer=hit collider.renderer;
          if(renderer)
          {
               renderer.material.shader=Shader.Find("Transparent/Diffuse")
               renderer.material.color.a=0.3;
           }
      }
}

Ping 类

变量

◆ var ip: string

描述：ping的IP目标。

var ip="192.168.1.1";
function OnGUI()
{
    if(GUI.Button(Rect(10,10,60,30),"Ping"))
    {
        Ping(ip);
    }
}

◆ var isDone: bool

描述：ping函数已经完成？

◆ var time: int

描述：在isDone返回真厚，这个属性包含ping的时间结果。

构造函数

◆ static function Ping(address: string): Ping

描述：对提供的目标IP地址执行ping操作。
这个不执行主机名的DNS插值，所以它只接受的IP地址。

Plane 结构

表示一个平面。
平面式由一个法向量和原点到平面的距离定义的。

变量

◆ var distance: float

描述：从原点到平面的距离

构造函数
◆ staic function Plane(inNormal: Vector3, inPoint: Vector3): Plane
描述：创建一个平面
平面具有法线inNormal并通过inPoint点，inNormal不需要被规范化

◆ staic function Plane(inNormal: Vector3,d: float): Plane

描述：创建一个平面
平面具有法线inNormal和距离d，inNormal不需要被规范化

◆ staic function Plane(a: Vector3, b: Vector3, e: Vector3): Plane

描述：创建一个平面
屏幕通过给定的三个点

函数

◆ function GetDistanceToPoint(inPt: Vector3): float

描述：从平面到点的距离

◆ function GetSide(inPt: Vector3): bool

描述：一个点是否位于平面的正侧

◆ function Raycast(rayt: Ray, out enter: float): bool

描述：一个射线与平面相交
这个函数设置enter为沿着射线的距离，这个距离是它与平面相交的位置。如果这个射
线与平面平行，函数返回false并设置enter为零。

◆ function SameSide(inPt0: Vector3, inPt1: Vector3): bool

描述：两个点是否在平面的同侧

PlayerPrefsException 类，继承自Exception

这个异常时由PlayerPrefs类在web模式时抛出的，表示偏好文件超出了分配的存储空
间.

PlayerPrefs 类

在游戏会话中保持并访问玩家偏好设置。
在Mac OS X上PlayerPrefs存储在-/Library/PlayerPrefs文件夹，名文unity/[company
name]\[product name].plist,这里company和product是在Project Setting中设置的，相同
的plist用于在编辑器中运行的工程和独立模式.
在Windows独立模式下，PlayerPrefs被存储在注册表的HKCU Software[company
name]\[product name]键下，这里company和product是在Project Setting中设置的.
在Web模式，PlayerPrefs存储在Mac OS X的二进制文件
-/Library/Preferences/Unity/WebPlayerPrefs中和Windows的
%APPDATA%\Unity\WebPlayerPrefs中，一个偏好设置文件对应一个web播放器URL并且
文件大小被限制为1兆。如果超出这个限制，SetInt，SetFloat和SetString将不会存储值并相
处一个PlayerPrefsException.

类方法

◆ static function DeleteAll(): void

描述：从设置文件中移除所有键和值，谨慎的使用它们。

◆ static function DeleteKey(key: string): void

描述：从设置文件中移除key和它对应的值.

◆ static function GetFloat(key: string, defaultValue: float=OF): float

描述：返回设置文件中key对应的值，如果存在.
如果不存在，它将返回defaultValue.
print(PlayerPrefs.GetFlat("Player score"));

◆ static function GetInt(key: string, defaultValue: int): int

描述：返回设置文件中key对应的值，如果存在.
如果不存在，它将返回defaultValue.
print(PlayerPrefs.GetInt("Player score"));

◆ static function GetString(key: string, defaultValue: string=**): string

描述：返回设置文件中key对应的值，如果存在.
如果不存在，它将返回defaultValue.
print(PlayerPrefs.GetString("Player Name"));

◆ static function HasKey(key: string): bool

描述：在设置文件如果存在key则返回真.

◆ static function SetFloat(key: string, value: float): void

描述：设置由key确定的值.
print(PlayerPrefs.SetFloat("Player Score", 10.0));

◆ static function SetInt(key: string, value: int): void

描述：设置由key确定的值.
PlayerPrefs.SetInt("Player Score", 10);

◆ static function SetString(key: string, value: string): void

描述：设置由key确定的值.
PlayerPrefs.Setstring("Player Name", "Foobar");

QualitySettings 类

用于Quality Settings的 本接口.
有六个质量等级可以选择；每个等级的细节都在工程的Quality Settings中设置，在运行
的时候，当前质量等级可以使用这个类来改变。

类变量

◆ static var currentLevel: QualityLevel

描述：当前图像质量等级。
QualitySettings.currentLevel=QualityLevel.Good;
参见：QualityLevel枚举，Quality Settings.

◆ static var pixelLightCount: int

描述：影响一个物体的最大像素光源的质量。
如果有更多的光照亮该物体，最暗的一个将作为顶点光源被渲染。
如果你想更好的控制而不是使用质量设置等级，从脚本中使用这个。
//为每个物体使用最多一个像素光
QualitySettings.pixelCount=1;

参见：Quality Settings.

◆ static var softVegetation: bool

描述：使用一个双pass着色器，用于地形引擎中的植被。
如果启用，植被将有平滑的边缘，如果禁用所有植物将有硬边但是渲染会快两倍。
参见：Quality Settings.

类方法

◆ static function DecreaseLevel(): void

描述：减小当前质量等级。
QualitySettings.DecreaseLevel();
参见：IncreaseLevel, currentLevel, Quality Settings.

◆ static function IncreaseLevel(): void

描述：增加当前质量等级。
QualitySettings.IncreaseLevel();
参见：DecreaseLevel, currentLevel, Quality Settings.

Quaternion 结构

四元组用来表示旋转 它们是紧凑的，不会出现万向节锁能够很容易被插值。Unity内如使用Quaternion表示
所有旋转。
然而，它们基于复述的并不容易被理解。因此你没有必要访问或修改Quaternion组
件(x,y,z,w)；最常用的应该是事业已有的旋转（例如，来自Transform）并使用它们来构造
新的旋转（例如，在两个旋转间平滑地插值）.99%的时间你会使用四元组函数（其他函数仅额
外使用）Quaternion.LookRotation, Quaternion.Angle, Quaternion.Euler, Quaternion.Slerp,
Quaternion.FromToRotation, Quaternion.identity

变量

◆ var eulerAngles: Vector3

描述：返回表示旋转的欧拉角。
返回一个旋转，这个旋转绕着x轴旋转euler.x度，绕着y轴旋转euler.y度，绕着euler.z
轴旋转euler.x度。
//创建一个旋转
var rotation=Quaternion.identity;
//赋值一个旋转为绕着y轴30度；
rotation.eulerAngles=Vector3(0,30,0);
//打印沿着y轴的旋转角度
print(rotation.eulerAngles.y);

◆ var this[index: int]: float

描述：分别使用[0], [1],[2],[3]访问x,y,z,w组件。
Quaternion p;
p[3]=0.5;//与p.w=0.5相同
◆ var w: float
描述：Quaternion的W组件，不要直接修改这个，除非你了解四元组内部
◆ var x: float
描述：Quaternion的X组件，不要直接修改这个，除非你了解四元组内部
◆ var y: float
描述：Quaternion的Y组件，不要直接修改这个，除非你了解四元组内部
◆ var z: float
描述：Quaternion的Z组件，不要直接修改这个，除非你了解四元组内部
构造函数
◆ static function Quaternion(x: float, y: float, z: float, w: float): Quaternion
描述：用给定的x,y,z,w组件构造新的四元组。
函数
◆ function SetFromToRotation(fromDirection: Vector3, toDirection: Vector3): void
描述：创建一个从fromDirection到toDirection的旋转。
◆ function SetLookRotation(view: Vector3, up: Vector3=Vector3.up): void
描述：创建一个旋转，沿着forward看并且头沿着upwards向上
如果前向为零将记录一个错误。
◆ function ToAngleAxis(out angle: float, out axis: Vector3): void
描述：转化一个旋转为角度-轴表示。
//提取角度-来自变换选择的轴旋转
var angle=0.0;
var axis=Vector3.zero;
transform.rotation.ToAngleAxis(angle.axis);
◆ function ToString(): string
描述：返回格式化好的这个四元组的字符串。
print(Quaternion.identity):
类变量
◆ static var identity: Quaternion
描述：返回单位旋转（只读）. 这个四元组对应与"无旋转"：这个物体完全与世界或父的
轴对齐。
transform.rotation=Quaternion.identity;
类方法
◆ static function Angles(a: Quaternion, b: Quaternion): float
描述：返回两个旋转a和b之间的角度
//计算这个变换和
//target之间的角度.
var target: Transform;
function Update()
var angle=Quaternion.Angles(transform.rotation,target.rotation);
◆ static function AnglesAxis(angle: float, axis: Vector3): Quaternion
描述：创建一个旋转绕着axis轴旋转angle度。
//设置旋转绕着y轴旋转30度
transform.rotation=Quaternion.AnglesAxis(30, Vector3.up);
◆ static function Dot(a: Quaternion, b: Quaternion): float
描述：两个旋转之间的点乘。
print(Quaternion.Dot(transform.rotation, Quaternion.identity));
◆ static function Euler(x: float, y: float, z: float): Quaternion
描述：返回一个旋转，这个旋转绕着x轴旋转x度，绕着y轴旋转y度，绕着z轴旋转
z度。
//绕着y轴旋转30度
var rotation=Quaternion.Euler(0,30,0);
◆ static function Euler(euler: Vector3): Quaternion
描述：返回一个旋转，这个旋转绕着x轴旋转x度，绕着y轴旋转y度，绕着z轴旋转
z度。
//绕着y轴旋转30度
var rotation=Quaternion.Euler(Vector3(0,30,0));
◆ static function FromToRotation(fromDirection: Vector3, toDirection: Vector3):
Quaternion
描述：创建一个从fromDirection到toDirection的旋转.
通常你使用这个来旋转一个变换，这样它的一个周，例如y轴-遵循世界空间的
toDirection目标方向。
//设置旋转这样变换的y轴沿着表面的法线
transform rotation=Quaternion.FromToRotation(Vector3.up, surfaceNormal);
◆ static function Inverse(rotation: Quaternion): Quaternion)
描述：返回rotation的逆.
//设置这个变换为具有target的方向旋转
var target: Transform;
function Update()
{
transform.rotation=Quaternion.Inverse(target.rotation);
}
◆ static function Lerp(a: Quaternion, b: Quaternion, t: float): Quaternion
描述：从from到to基于t插值并规范化结果.
这个比Slerp快但是如果旋转较远看起来就较差。
//在from到to之间
//插值旋转.
//（from和to不能
//与附加脚本的物体相同）
var from: Transform;
var toL Transform;
var speed=0.1;
function Update()
{
transform.rotation=Quaternion.Lerp(from.rotation, to.rotation, Time.time*speed);
}
◆ static function LookRotation(forward: Vector3, upwards: Vector3=Vector3.up):
Quaternion
描述：创建一个旋转，沿着forward看并且沿着upwards向上
 
如果向前为零将记录一个错误。
//大多数时候你可以使用。
//transform.LookAt来代替
var target: Transform
function Update()
{
var relativePos=target.position-transform.position;
var rotation=Quaternion.LookRotation(relativePos);
transform.rotation=rotation;
}
◆ static operator!=(lhs: Quaternion, rhs: Quaternion): bool
描述：两个四元组不对等？
这个函数测试两个四元组的点乘是否小于1.0
注意，因为四元组最多可以表示两个全旋转（720度），这个比较可以返回true即使产
生旋转看起来一起。
◆ static operator*(lhs: Quaternion, rhs: Quaternion): Quaternion
描述：组合lhs和rhs旋转.
首先用lhs旋转一个点然后用rhs继续旋转，与使用组合旋转相同。注意旋转不可交换：
lhs*rhs不等于rhs*lhs.
//应用
//extraRotation当当前旋转
var extraRotation: Transform;
transform.rotation*=extraRotation.rotation;
◆ static operator*(rotation: Quaternion, point: Vector3): Vector3
描述：用rotation旋转点point
//沿着relativeDirection移动物体
//通常你应该使用transform.Move
var relativeDirection=Vector3.forward;
function Update() {
var absoluteDirection=transform.rotation*relativeDirection;
transform.position+=absoluteDirection*Time.deltaTime;
}
◆ static operator==(lhs: Quaternion, rhs: Quaternion): bool
描述：两个四元组相等？
这个函数测试两个四元组的点乘是否接近1.0
注意，因为四元组可以表示最大两个全旋转（720度），这个比较可以返回false即使产
生旋转看起来一起。
◆ static function Slerp(from: Quaternion, to: Quaternion, t: float): Quaternion
描述：从from到to基于t的球形插值.
//在from和to之间
//插值旋转.
//(from和to不能
//与附加脚本的物体相同)
var from: Transform;
var to: Transform;
var speed=0.1;
function Update() {
transform.rotation= Quaternion.Slerp(from.rotation, to.rotation, Time.time*speed);
}
Random
类
用于生成随机数据的类。
类变量
◆ static var insideUnitCircle: Vector2
描述：返回半径为1的圆内部的一个随机点（只读）。
//设置这个位置为一个半径为
//5, 中心在零点的圆环内部的一个点.
var newPosition: Vector2=Random.insideUnitCircle*5;
transform.position.x=newPosition.x;
transform.position.y=newPosition.y;
◆ static var insideUnitSphere: Vector3
描述：返回半径为1的球体内部的一个随机点（只读）。
//设置这个位置为一个半径为5
//中心在零点的球体内部的一个点.
transform.position=Random.insideUnitSphere*5;
◆ static var onUnitSphere: Vector3
描述：返回半径为1的球体表面上的一个随机点（只读）。
//在一个随机的方向上设置刚体速度为10.
rigidbody.velocity=Random.onUnitSphere*10;
◆ static var rotation: Quaternion
描述：返回s随机旋转（只读）。
//在世界坐标原点用一个随机旋转实例化一个预设
var prefab: GameObject;
Instantiate(prefab, Vector3.zero., Random.rotation);
◆ static var seed: int
描述：设置随机种子生成器。
◆ static var value: float
描述：返回一个0.0[包含]和1.0[包含]之间的随机数（只读）.
0.0和1.0会被这个函数返回。
//打印0到1之间的值
print(Random.value);
类方法
◆ static function Range(min: float, max: float): float
描述：返回一个随机的浮点数，在min[包含]和max[包含]之间（只读）.
//在x-z平面上的-10和10之间的某个位置实例化预设
var prefab: GameObject;
function Start()
{
var position=Vector3(Random Range(-10, 10), 0, Random Range(-10, 10));
Instantiate(prefab.position, Quaternion.identity);
◆ static function Range(min: int, max: int): int
描述：返回一个随机的整数，在min[包含]和max[包含]之间（只读）.
如果max等于min，min将被返回，返回的值不会是max除非min等于max
//从关卡到列表中加载一个随机的关卡
Application.LoadLevel(Random Range(0, Application.levelCount));
Ray
结果
表示射线。
射线时一个无穷线段，开始于origin并沿着direction方向。
变量
◆ var direction: Vector3
描述：射线的方向。
方向总是一个规范化的向量。如果你赋值一个非单位化长度，它将被规范化。
◆ var origin: Vector3
描述：射线的起点。
构造函数
◆ static function Ray(origin: Vector3, direction: Vector3): Ray
描述：创建一个射线从origin开始沿着direction方向。
//从变换位置开始沿着变换的z轴创建一个射线
var ray=new Ray(transform.position, transform.forward);
函数
◆ static GetPoint(distance: float): Vector3
描述：返回沿着射线距离为distance单位的点。
var r: ray;
pting(r.GetPoint(10));//沿着这个射线10个单位的点
◆ function ToString(): string
描述：返回格式化好的这个射线的字符串
RaycastHit
结构
用来从一个raycase获取信息的结构。
参见：Physics.Raycast, Physics.Linecast, Physics.RaycastAll.
变量
◆ var barycentricCoordinate: Vector3
描述：所碰到的三角形的重心坐标。
这允许你沿着3个轴插值任何顶点数据。
//附加这个脚本到相机然后它将
//绘制一个从法线指出的调试直线
function Update(){
//如果碰到物体，继续
var hit: RaycastHit;
if(!Physics.Raycst(Camera.main.ScreenPointToRay(Input.mousePosition), hit))
return;
//以防万一，确保碰撞器也有一个渲染器
//材质和纹理
var meshCollider=hit.collider as MeshCollider;
if(meshCollider==null || meshCollider.sharedMesh=null)
return;
var mesh: Mesh=meshCollider.sharedMesh;
var normals=mesh.normals;
var triangles=mesh.triangles;
//取得所碰到三角形的本地法线
var n0=normals[triangles[hit.triangleIndex*3+0]];
var n1=normals[triangles[hit.triangleIndex*3+1]];
var n2=normals[triangles[hit.triangleIndex*3+1]];
//使用碰撞点的中心坐标来插值
var baryCenter=hit.barycenterCoordinate;
//使用中心坐标插值法线
var interpolatedNormal=n0*baryCenter.x+n1*baryCenter.y+n2*baryCenter.z;
//规范化插值法线
interpolatedNormal=interpolatedNormal.Normalized;
//Transform local space normals to world space
var hitTransform: Transform:=hit.collider.transform;
interpolatedNormal=hitTransform.TransformDirection(interpolatedNormal);
//用Debug.DrawLine显示
Debug.DrawRay(hit.poing, interpolatedNormal);
◆ var collider: Collider
描述：被碰到的Collider.
如果没有碰到任何东西该属性为null否则为非null参见：Physics.Raycast,
Physics.Linecast, Physics.RaycastAll.
◆ var distance: float
描述：从射线的原点到碰撞点的距离。

参见：Physics.Raycast, Physics.Linecast, Physics.RaycastAll.
◆ var normal: Vector3
描述：射线所碰到的表面的法线。
参见：Physics.Raycast, Physics.Linecast, Physics.RaycastAll.
◆ var point: Vector3
描述：在世界空间中，射线碰到碰撞器的碰撞点。
参见：Physics.Raycast, Physics.Linecast.
◆ var rigidbody: Rigidbody
描述：碰到的碰撞器的Rigidbody. 如果该碰撞器没有附加刚体那么它为null。
参见：Physics.Raycast, Physics.Linecast, Physics.RaycastAll.
◆ var textureCoord: Vector2
描述：碰撞点的UV纹理坐标。
这个可用于3D纹理绘制或绘制弹痕。如果碰撞器时非网格碰撞器，零Vector2将被返
回.
//附加这个脚本到相机，当用户点击时
//它将在3D中绘制黑色的像素. 确保你想绘制的网格附加有
//一个网格碰撞器.
function Update()
(
//只有当我们按下鼠标
if(!input.GetMouseButton(0))
return;
//只有碰到某些东西，继续
var hit: RaycastHit;
if(!Physics.Raycast(camera.ScreenPointToRay(Input.mousePosition), hit))
return;
/以防万一，还要确保碰撞器也有一个渲染器
//材质和纹理.我们也应该忽略几何体碰撞器.
var renderer: Renderer=hit.collider.renderer;
var meshCollider=hit.collider as MeshCollider;
if(renderer==null || renderer.sharedMaterial==null || renderer.sharedMaterial.mainTexture==null ||
meshCollider==null)
return;
//现在在我们碰到的物体上绘制一个像素
var tex: Texture2D=renderer.material.mainTexture;
var pixelUV=hit.textureCoord;
pixelUV.x*=tex.width;
pixelUV.y*=tex.height;
tex.SetPixel(pixelUV.x, pixelUV.y, Color.black);
tex.Apply();
}
参见：Physics.Raycast, Physics.Linecast, Physics.RaycastAll.
◆ var textureCoord2: Vector2
描述：碰撞点的第二个UV纹理坐标。
这个可用于3D纹理绘制或绘制弹痕。如果碰撞器时非网格碰撞器，零Vector2.zero将被
返回.如果网格没有包含第二个uv集，主uv集将被返回。
//附加这个脚本到相机，当用户点击时
//它将在3D中绘制黑色的像素. 确保你想绘制的网格附加有
//一个网格碰撞器.
function Update()
(
//只有当我们按下鼠标
if(!input.GetMouseButton(0))
return;
//只有碰到某些东西，继续
var hit: RaycastHit;
if(!Physics.Raycast(camera.ScreenPointToRay(Input.mousePosition), hit))
return;
/以防万一，还要确保碰撞器也有一个渲染器
//材质和纹理.我们也应该忽略几何体碰撞器.
var renderer: Renderer=hit.collider.renderer;
var meshCollider=hit.collider as MeshCollider;
if(renderer==null || renderer.sharedMaterial==null || renderer.sharedMaterial.mainTexture==null ||
meshCollider==null)
return;
//现在在我们碰到的物体上绘制一个像素
var tex: Texture2D=renderer.material.mainTexture;
var pixelUV=hit.textureCoord2;
pixelUV.x*=tex.width;
pixelUV.y*=tex.height;
tex.SetPixel(pixelUV.x, pixelUV.y, Color.black);
tex.Apply();
}
参见：Physics.Raycast, Physics.Linecast, Physics.RaycastAll.
◆ var triangleIndex: int
描述：碰到的三角形的索引.
如果被击中的碰撞器时一个MeshCollider三角形索引才可用.
//附加这个脚本到相机然后它将
//绘制一个调试直线三角形
//在我们放置鼠标的三角形上
function Update()
(
//如果我们击中了某物，继续
var hit: RaycastHit;
if(!Physics.Raycast(camera.ScreenPointToRay(Input.mousePosition), hit))
return;
/以防万一，确保碰撞器也有一个渲染器
//材质和纹理
var meshCollider=hit.collider as MeshCollider;
if(meshCollider==null ||meshCollider.sharedMesh==null)
return;
var mesh: Mesh=meshCollider.sharedMesh;
var vertices=mesh.vertices;
var triangles=mesh.triangles;
//取回碰到的本地坐标点
var p0=vertices[triangles[hit.triangleIndex*3+0]];
var p1=vertices[triangles[hit.triangleIndex*3+1]];
var p2=vertices[triangles[hit.triangleIndex*3+1]];
//交换本地空间点到世界空间
var hitTransform: transform=hit.collider.transform;
p0=hitTransform.TransformPoint(p0);
p1=hitTransform.TransformPoint(p1);
p2=hitTransform.TransformPoint(p2);
//用Debug.DrawLine显示
Debug.DrawLine(p0, p1);
Debug.DrawLine(p1, p2);
Debug.DrawLine(p2, p0);
}
参见：Physics.Raycast, Physics.Linecast, Physics.RaycastAll.
RectOffset
类
用于矩形，边界等的偏移。
被GUIStyle用在所有地反。
变量
◆ var bottom: int
描述：底部边缘的尺寸。
◆ var horizontal: int
描述：left+right的快捷方式（只读）。
◆ var left: int
描述：左边边缘的尺寸。
◆ var right: int
描述：右边边缘的尺寸。
◆ var top: int
描述：顶部边缘的尺寸。
◆ var vertical: int
描述：top+bottom的快捷方式（只读）
函数
◆ function Add(rect: Rect): Rect
描述：向一个rect中添加边界偏移。
◆ function Remove(rect: Rect): Rect
描述：从一个rect中移除边界偏移。
Rect
结构
由x，y位置和width，height定义的2D矩阵
Rect结构主要用于2D操作；UnityGUI系统广泛的使用它，也可用来在屏幕上定位相机
参见：GUIScripting.Guide, Camera.rect, Camera.pixelRect.
变量
◆ var height: float
描述：矩形的高。
var rect=Rect(0,0,10,10);
print(rect.height);
rect.height=20;
◆ var width: float
描述：矩形的宽。
var rect=Rect(0,0,10,10);
print(rect.width);
rect.width=20;
◆ var x: float
描述：矩形的左侧坐标。
◆ var xMax: float
描述：矩形的右侧坐标
改变这个值将保持矩形的左边（这样宽度也将改变）
◆ var xMin: float
描述：矩形的左侧坐标
改变这个值将保持矩形的右边（这样宽度也将改变）
◆ var y: float
描述：矩形的顶部坐标。
var rect=Rect(10,10,100,100);
print(rect.y);
rect.x=20;
◆ var yMax: float
描述：矩形的底部坐标。
改变这个将保持矩形的顶边（这样高度也将改变）
◆ var yMin: float
描述：矩形的顶部坐标。
改变这个将保持矩形的底边（这样高度也将改变）
构造函数
◆ static function Rect(left: float, top: float, width: float, height: float): Rect
描述：创建一个新的矩形
var rect=Rect(0,0,10,10);
函数
◆ function Contains(point: Vector2): bool
◆ function Contains(point: Vector3): bool
描述：如果point的x和y位于矩阵的内部
//当坐标？？？
function Update()
{
var rect=Rect(0,0,150,150);
if(rect Contains(Input.???Position))
print("Inside")
}
◆ function ToString(): string
描述：返回格式化好的Rect字符串、
var rect=Rect(0,0,10,10);
print(rect);
类方法
◆ static function MinMaxRect(left: float, top: float, right: float, bottom: float): Rect
描述：根据min/max坐标值创建一个矩形。
◆ static operator!=(lhs: Rect, rhs: Rect): bool
描述：如果矩形不相同返回真。
◆ static operator==(lhs: Rect, rhs: Rect): bool
描述：如果矩形相同返回真。
RenderSettings
类
Render Settings包含用于场景中可视元素范围的缺省值，如雾和环境光。
参见：Render Settings manager
类变量
◆ static var ambientLight: Color
变量
◆ var height : int
描述: 解析度的像素高度。
◆ var width : int
描述: 解析度的像素宽度。
◆ var refreshRate : int
描述: 解析度的垂直刷新率 Hz。
Resources
类
Resources类允许你按照它们的路径名找到并加载物体。
所有位于Assets文件夹下名“Resources”的文件夹中的资源,都可以Resources.Load
函数访问,
在Unity中你通常不需要使用路径名来访问资源,相反你可以通过声明一个成员变量
来公开到一个资源的应用,然后在检视面板中给它赋值。使用这个技巧的时候Unity可以在构建的时候自动计算哪个资源被使用。这从根本上最大限度地减少了实际用于游戏的资源的尺寸。当你放置资源在“Resources”文件夹中时这个不会这么做,因此所有在“Resources”文件夹中的资源都将被包含在游戏中。
另一个使用路径名的缺点是，缺乏可重用性，因为脚本对于使用的资源具有硬编码要求。另一方面使用公开在检视面板中的引用，是自文档化的，对于使用你脚本的用户来说也是显而易见的。
然而，有些情况下按照名称而不是在检视面板中取回一个资源是更方便的。尤其是当在检视面板中赋值引用是不方便的时候。例如你或许想从脚本创建一个游戏物体，为程序生成的网格赋值一个纹理。
var go = new GameObject.CreatePrimitive(PrimitiveType.Plane);
go.renderer.marerial.mainTexture = Resources.Load("glass");
类方法
◆ static function Load(path : string) : Object
描述: 加载储存在Resources文件夹中的path处的资源。
如果在path处发现这个资源返回它,否则返回null。Path相对于Resources文件夹,扩展名必须被忽略。Resources文件夹可以在Assets文件夹中的任何位置。
//附加一个名为"Assets/Resources/glass"的纹理到Plane.
function Start() {
  var go = new GameObject.CreatePrimitive(PrimitiveType.Plane);
  go.renderer.material.mainTexture = Resources.Load("glass");
}
//实例化路径"Assets/Resources/enemy"处的一个预设
function Start () {
var instance : GameObject = Instantiate(Resources.Load("enemy"));
}
◆ static function Load ( path : String, type : Type) : Object
描述: 加载储存在Resources文件夹中path处的资源。
如果在path处发现这个资源就返回它，否则返回null。只有type类型的物体将被返回. Path相对于Resources文件夹，扩展名必须被忽略。Resouces文件夹可以在Assets文件夹中的任何位置。
//附加一个名为”glass”的纹理到Plane
function Start () {
 var go = new GameObject.CreatePrimitive(PrimitiveType.Cube);
 go.renderer.material.main.Texture = Resources.Load(“glass”, Texture2D);
}
//实例化名为”Resources/enemy”的一个预设
function Start () {
 var instance : GameObject = Instantiate(Resources.Load(“enemy”, GameObject);
}
◆ static function LoadAll (path : String, type : Type) : Object[]
描述: 加载Resources文件夹中的path文件夹或者文件中的所有资源。
如果path是一个文件夹，文件中的所有资源都将被返回。如果path为一个文件，只有这个资源将被返回。只有type类型的物体将被返回。Path相对于Resources文件夹。Resources文件夹可以在Assets文件夹中的任何位置。
 //加载”Resources/Texture”文件夹中所有资源
 //然后从列表中选择随机的一个
 function Start () {
  var go = new GameObject.CreatePrimitive(PrimitiveType.Cube);
  var textures : Object[] = Resources.LoadAll(“Textures”, Texture2D);
  var texture : Texture2D = textures[Random.Range(0, textures.Length)];
  go.renderer.material.mainTexture = texture;
 }
◆ static function LoadAll (path : String) : Object[]
描述: 加载Resources文件夹中的path文件夹或者文件中的所有资源。
如果path是一个文件夹，文件中的所有资源都将被返回。如果path为一个文件，只有这个资源将被返回。只有type类型的物体将被返回。Path相对于Resources文件夹。Resources文件夹可以在Assets文件夹中的任何位置。
 //加载”Resources/Texture”文件夹中所有资源
 //然后从列表中选择随机的一个
 function Start () {
  var go = new GameObject.CreatePrimitive(PrimitiveType.Cube);
  var textures : Object[] = Resources.LoadAll(“Textures”);
  var texture : Texture2D = textures[Random.Range(0, textures.Length)];
  go.renderer.material.mainTexture = texture;
 }
◆ static function LoadAssetAtPath (assetPath : String, type : Type) : Object
描述: 返回资源路径上的一个资源(只在编辑器中)。
在独立版或者web版中这个函数总是返回null。这个可以用来快速访问一个在编辑器中使用的资源。
var prefab : GameObject;
function Start () {
prefab = Resources.LoadAssetAtPath(“Assets/Artwork/mymodel.fbx”, GameObject);
}
Screen
 类
 访问显示信息。
 屏幕类用来获取支持的解析度列表，切换当前分辨率，隐藏或显示系统的鼠标指针。
类变量
◆ static var currentResolution : Resolution
描述: 当前屏幕的解析度。
如果播放器运行在窗口模式，这将返回当前左面的解析度。
print(Screen.currentResolution);
◆ static var fullScreen : bool
描述: 游戏是否运行在全屏模式下？
通过改变这个属性来切换全屏模式。
//切换全屏
Screen.fullScreen = !Screen.fullScreen;
参见: SetResolution。
◆ static var height : int
描述: 屏幕窗口的当前像素高度(只读)。
播放窗体的实际高度(在全屏模式下也是当前的分辨率高度)
◆ static var lockCursor : bool
描述: 光标是否被锁定？
 光标将被自动隐藏、居中并且不会离开这个视点。
 在web播放器中光标只在用户点击内容并且用户的鼠标没有离开内容视图的时候锁定。用户按下escape或切换到其他应用程序时光标将被自动锁定。当退出全屏模式时，光标锁定也将丢失。通过检查lockCursor状态，你可以查询光标当前是否被锁定。为了提供一个好的用户体验，建议只在用户按下按钮的时候锁定光标。你也应该光标是否解锁，例如暂停游戏或者打开游戏菜单。在web播放器和编辑器中，当你按下escape时光标将自动被解锁。在独立播放模式下你有完全的鼠标锁定控制权，因此它不会自动释放鼠标锁定，除非你切换应用程序。
//当鼠标被锁定时调用
function DidLockCursor () {
 Debug.Log(“Locking cursor”);
 //禁用按钮
 guiTexture.enabled = false;
}
//当光标被解锁时调用
//或被脚本调用Screen.lockCursor = false;
Function DidUnlockCursor () {
 Debug.Log(“Unlocking cursor”);
 //再次显示按钮
 guiTexture.enabled = true;
}
 
function OnMouseDown () {
 //锁定光标
 Screen.lockCursor = true;
}
private var wasLocked = false;
function Update () {
 //在独立模式下我们需要提供自己的键来锁定光标
 If(Input.GetKeyDown(“escape”)
  Screen.lockCursor = false;
 //我们失去了鼠标锁定？
 //例如因为用户按下escape键或因为他切换到了其他应用程序
//或者因为一些脚本设置Screen.lockCursor = false;
If(!Screen.lockCursor && wasLocked) {
 wasLocked = false;
 DidUnlockCursor();
}
//再次获得光标锁定？
else if(Screen.lockCursor && wasLocked) {
 wasLocked = true;
 DidLockCursor();
}
}
◆ static var resolutions : Resolution[]
 描述: 该显示器支持的所有全屏解析度(只读)
 返回的解析度按照宽度排序，较低的解析度位于前面。
var resolutions : Resolutions[] = Screen.resolutions;
//打印解析度
for(var res in resolutions) {
 print(res.width + “x” + res.height);
}
//切换到支持的最低全屏解析度
Screen.SetResolution(resolutions[0].width, resolutions[0].height, true);
 参见: Resolution结构, SetResolution。
◆ static var showCursor : bool
 描述: 光标是否可见？
 完全可以实现一个自定义的光标而不是系统的。要做到这一点，你要隐藏系统的，然后跟踪位置或移动并在需要的位置显示你自己的图片。
//隐藏光标
Screen.showCursor = false;
◆ static var width : int
描述: 屏幕窗口的当前像素宽度(只读)。
播放窗体的实际宽度(在全屏模式下也是当前的分辨率宽度)
类方法
◆ static function SetResolution (width : int, height : int, fullscreen : bool, preferredRefreshRate : int) : void
 描述: 切换屏幕的解析度。
 Width x height解析度将被使用。如果没有匹配的解析度支持，最近的一个将被使用。
 如果 preferredRefreshRate为0 (默认)，Unity将切换到显示器支持的最高刷新率。
 如果preferredRefreshRate不是0，如果显示器支持Unity将使用它，否则将选择所支持的最高的一个。
 在web播放器中你只需要在用户点击内容之后切换分辨率。推荐的方法是只在用户点击指定按钮的时候切换分辨率。
 //切换成640 x 480 全屏模式
 Screen. SetResolution(640, 480, true);
//切换成640 x 480 全屏模式 60hz
 Screen. SetResolution(640, 480, true, 60);
//切换成800 x 600 窗口模式
 Screen. SetResolution(800, 600, false);
 参考: resolution属性。
SoftJointLimit
 结构
 这限制是由CharacterJoint定义的。
变量
◆ var bouneyness : float
 描述: 当关节到达这个限定时，它可以使其弹回。
 bouneyness决定弹回的限制，范围{0, 1};

◆ var damper : float
 描述: 如果弹力大于0，限制被减缓。
 这是弹簧的z阻力，范围{0, 无穷};

◆ var limit : float
 描述: 关节的位置/角度限制。

◆ var spring : float
 描述: 如果大于零，限制被减缓。弹簧将推回该关节。 {0, 无穷}
String
 类
表示一系列Unicode字符文本。
变量
◆ var Length : int
 描述: 获取该实例中字符的数量。

◆ var String : static
 描述: 初始化一个新的实例化String类，它的值为一个新的Unicode字符数组。数组开始字符的位置，和一个长度。表示一个空的字符串，这个域是只读的。
SystemInfo
类
类变量
◆ static var graphicsDeviceName : string
 描述: 显示设备的名称(只读)。
 这个是用户显卡的名称，由显卡设备驱动报告。
//打印”ATi Raedon X1600 OpenGL Engine”在MacBook Pro OS X 10.4.8上
print(SystemInfo.graphicsDeviceName);
 参见: SystemInfo.graphicsDeviceVendor, SystemInfo.graphicsDeviceVersion.

◆ static var graphicsDeviceVendor : string
 描述: 显示设备的生产厂商(只读)。
 这个是用户显卡的生产厂商，由显卡设备驱动报告。
//打印”ATi Technologies Inc.” 在MacBook Pro OS X 10.4.8上
print(SystemInfo.graphicsDeviceVendor);
 参见: SystemInfo.graphicsDeviceName, SystemInfo.graphicsDeviceVersion.
◆ static var graphicsDeviceVersion : string
 描述: 该显示设备所支持的图形API版本(只读)。
 这个是用户显卡设备所支持的底层图形API版本。
 如果是OpenGL API，返回字符串包含”OpenGL”然后是”major.minor”格式的版本号，然后在方括号中试完整的版本号。
 如果是Direct3D9 API，返回的字符串包含”Direct3D 9.0c”，然后再方括号中试驱动名称和版本号。
//打印”OpenGL 2.0[2.0 ATi-1.4.40]”在MacBook Pro OS X 10.4.8下。
//打印”Direct3D 9.0c[atiumdag.dll 7.14 10.471]”在MacBook Pro/ Windows Vista下。
print(SystemInfo.graphicsDeviceVersion);
 参见: SystemInfo.graphicsDeviceName, SystemInfo.graphicsDeviceVendor.
◆ static var graphicsMemorySize : int
 描述: 显存的大小(只读)。
这个是以兆(MB)计算的显存容量。
◆ static var supportsImageEffects : bool
 描述: 是否支持图像效果?(只读)
 如果显卡支持后期处理特效则返回true。
 参见: Image Effects。
◆ static var supportsRenderTexture : bool
 描述: 是否支持渲染到纹理?(只读)
 如果显卡支持渲染到纹理则返回true。使用SupportsRenderTextureFormat来检查支持的特定渲染纹理格式。
 参见: Render Texture assets，RenderTexture类。
◆ static var supportsShadows : bool
 描述: 是否支持内置阴影?(只读)
 如果显卡支持内置阴影则返回true。
 参见: Shadows doucumentation。
类方法
◆ static function SupportsRenderTextureFormat (format : RenderTextureFormat) : bool
 描述: 是否支持该渲染纹理格式?
 如果显卡支持指定的RenderTextureFormat格式，返回true。
 参见: Render Texture assets，RenderTexture类。
Time
 类
 从Unity中获取时间的接口。
类变量
◆ static var captureFramerate : int
 描述: 如果captureFramerate被设置为大于0的值，时间将为(1.0/ captureFramerate)每帧而不考虑实际时间。如果想用一个固定的帧率捕获一个视频时可以使用这个。
 Time. captureFramerate = 25;
◆ static var deltaTime : float
 描述: 用于完成最后一帧的时间(只读)。
 如果你加或减一个每帧改变的值，你应该将它与deltaTime相乘。当你乘以Time.deltaTime时，你实际表达：我想以10米/秒移动这个物体而不是10米/帧。
 在MonoBehaviour的FixedUpdate内部调用时，返回固定帧率增量时间。
function Update () {
  var translation = Time.deltaTime * 10;
 transform.Translate(0, 0, translation);
}
◆ static var fixedDeltaTime : float
 描述: 物理和其他固定帧率更新(如MonoBehaviour的FixedUpdate)以这个间隔来执行。
 建议使用Time.deltaTime代替，因为如果在FixedUpdate函数或Update函数内部它将自动返回正确的增量时间。
 注意fixedDeltaTime间隔对应的游戏时间会受到timeScale的影响。
◆ static var fixedTime : float
 描述: 最后一次FixedUpdate调用已经开始的时间(只读)。这个是以秒计的游戏开始的时间。
 固定时间以定期的间隔来更新(相当于fixedDeltaTime)直到到达了time属性。
◆ static var frameCount : int
 描述: 已经传递的帧总数(只读)。
//确保RecaloulateValue在每帧中只执行一次某些操作
 static private var lastRecaloulation = -1;
 static function RecaloulateValue () {
  if(lastRecaloulation == Time.frameCount)
  return;
 PerformSomeCalculations();
 }
◆ static var realTimeSinceStartup : float
 描述: 从游戏开始的实时时间(只读)。
 在大多数情况下你应该使用Time.time。
 realTimeSinceStartup返回从开始到现在的时间，不会受到Time.timeScale的影响。当玩家暂停的时候realTimeSinceStartup也会增加(在后台)。使用realTimeSinceStartup时很有用的，当你想通过设置Time.timeScale为0来暂停游戏，但还在某些时候使用时间。
 注意realTimeSinceStartup返回的时间是来源于系统计时器，根据不同平台和硬件，也许会在一些连贯的帧上报告相同的时间。如果通过不同的时间来区分不同的事情，需要考虑这个(时间的差别可能变为零！)。
//打印从开始到现在的真实时间
 print(Time.realTimeSinceStartup);
//一个FPS计数器，在每个updateInterval间隔处计算帧/秒，这样显示就不会随意的改变。
var updateInterval = 0.5;
private var last Interval : double;  //最后间隔结束时间
private var frames = 0;//超过当前间隔帧
 private fps : float; //当前fps

function Start () {
  lastInterval = Time. realTimeSinceStartup;
 frames = 0;
 }
 function OnGUI () {
//显示两位小数
 GUILayout.xxxx(“” + fps.ToString(“F2”);
 }
function Update () {
  ++frames;
 var timeNow = Time.realtimeSinceStartup;
 if(timeNow > lastInterval + updateInterval) {
  fps = frames / (timeNow – lastInterval);
  frames = 0;
  lastInterval = timeNow;
 }
 }
◆ static var smoothDeltaTime : float
 描述: 一个平滑的Time.deltaTime(只读)。 
◆ static var time : float
 描述: 该帧开始的时间(只读)。从游戏开始到现在的时间。
 在MonoBehaviour的FixedUpdate内部调用时，返回fixedTime属性。
//如果 Fire1按钮(默认为Ctrl)被按下，每0.5秒实例化一个projectile。
 var projectile : GameObject;
 var fireRate = 0.5;
 private var nextFire = 0.0;
 function Update () {
  if(Input.GetButton(“Fire1”) && Time.time > nextFire) {
   nextFire = Time.time + fireRate;
  clone = Instantiate(projectile, transform.position, transform.rotation);
  }
 }
◆ static var timeScale : float
 描述: 传递时间的缩放，可以用来减慢动作效果。
 当timeScale为1.0的时候时间和真实时间一样快；当timeScale为0.5的时候时间为真实时间的一半速度；当timeScale被设置为0的时候那么游戏基本上处于暂停状态，如果所有函数都是与帧率无关的。如果降低timeScale建议同时降低Time.fixedDeltaTime相同的量。当timeScale被设置为0时FixedUpdate将不会被调用。
//当用户按下Fire1按钮时可以在1和0.7之间切换时间。
 function Update () {
  if(Input.GetButton(“Fire1”)) {
  if(Time.timeScale == 1.0) {
Time.timeScale = 0.7;
  }
  else {
Time.timeScale = 1.0;
  }
 //根据timeScale调整固定增量时间
 Time.fixedDeltaTime = 0.02 * Time.TimeScale;
 }
 }
◆ static var timeSinceLevelLoad : float
 描述: 该帧开始的时间(只读)。最后一个关卡被加载到现在的时间。
//设置GUI文本为玩家完成该关卡的时间。
 function PlayerCompletedGame () {
  guiText.text = Time. timeSinceLevelLoad.ToString;
 }
Vector2
 结构
 表示2D向量和点。
 这个在某些地方用来表示2D位置和向量(例如，在Mesh中的纹理坐标或者Material中的纹理偏移)。在大多数情况下使用一个Vector3。
变量
◆ var magnitude : float
 描述: 返回这个向量的长度(只读)。
 向量的长度是(x*x+y*y)的平方根。
 如果你只需要比较向量的长度，你可以使用sqrMagnitude(计算长度的平方式比较快的)比较它们的平方。
 参见: sqrMagnitude
◆ var sqrMagnitude : flaot
 描述: 返回这个向量长度的平方(只读)。
 计算长度的平方比magnitude更快。通常如果你只比较两个向量的长度你可以只比较它们的长度的平方。
 参见: magnitude
◆ var this[index : int] : float
 描述: 分别使用0或1来访问x和y组件。
Vector2 p;
 p[1] = 5; //与p.y = 5相同
◆ var x : float
 描述: 该向量的x组件。
◆ var y : float
 描述: 该向量的y组件。
构造函数
◆ static function Vector2 (x : float, y : float) : Vector2
 描述: 用指定的x,y组件构造一个新的向量。
函数
◆ function ToString () : String
 描述: 返回格式化好的Vector字符串。
类变量
◆ static var right : Vector2
 描述: Vector2(1,0)的简写。
◆ static var up : Vector2
 描述: Vector2(0,1)的简写。
◆ static var zero : Vector2
 描述: Vector2(0,0)的简写。
类方法
◆ static function Distance(a:Vector2, b:Vector2):float
 描述: 返回a和b之间的距离。
 Vector2.Distance(a,b)和(a-b).magnitude相同。
◆ static function Dot(lhs:Vector2, rhs:Vector2):float
 描述: 2个向量的点乘。
 返回lhs.rhs.
 对于规范化的向量，如果它们指向相同的方向Dot返回1；如果指向相反的方向返回-1；在另外的情况下返回一个数字（例如，如果向量垂直则Dot返回0）。
◆ static operator* (a:Vector2, d:float):Vector2
 描述: 用一个数乘以一个向量。
 用d乘以a的每个组件。
 // 使向量变为二倍长；打印(2.0, 4.0)
 print (Vector2(1,2) * 2.0);
◆ staic operator* (d:float, a:Vector2):Vector2
 描述: 用一个数乘以一个向量。
 用d乘以a的每个组件。
// 使向量变为二倍长； 打印（2.0, 4.0）
 print(2.0 * Vector2(1, 2));
◆ static operator + (a:Vector2, b:Vector2):Vector2
 描述: 两个向量相加。
 将对应的组件加在一起。
 // 打印(3.0, 5.0)
 print(Vector2(1,2) + Vector2(2,3));
◆ static operator–(a:Vector2, b:Vector2):Vector2
 描述: 两个向量相减。
 从a中减去b的每个对应组件。
 // 打印(-2.0, 0.0)
 print(Vector2(1,2)–Vector2(3,2));
◆ static operator–(a:Vector2):Vector2
 描述: 向量取反。
 结果中的每个组件都被取反。
 // 打印(-1.0, -2.0)
 print(-Vector2(1,2);
◆ static operator/(a:Vector2, d:float):Vector2
 描述: 用一个数除以一个向量。
 用d除以a的每个组件。
 // 使向量缩短一倍；打印(0.0, 1.0)
 print(Vector2(1,2)/2.0);
◆ static operator==(lhs:Vector2, rhs:float):Vector2
 描述: 如果向量相等返回true。
 对于非常接近相等的向量，这个也返回true。
◆ static implicit function Vector2(v:Vector3):Vector2
 描述: 把一个Vector3转化成Vector2。
 Vector3可被隐式的转化为Vector2(z被丢弃)。
◆ static implicit function Vector3(v:Vector2):Vector3
 描述: 把一个Vector2转化成Vector3。
 Vector2可被隐式的转化为Vector3(z被默认设置成0)。
◆ static function Scale(a:Vector2, b:Vector2):Vector2
 描述: 两个向量组件相乘
 结果中的每个组件都是a中的一个组件乘以b中相同的组件。
 // 打印(2.0, 6.0)
 print(Vector2.Scale(Vector2(1,2), Vector2(2,3)));
Vector3
结构
 表示3D的向量和点。
 这个结构被用在这个Unity中传递3D位置和方向，它也包含函数来做普通的向量操作。
变量
◆ var magnitude : float
 描述: 返回这个向量的长度(只读)。
 向量的长度是(x*x+y*y+z*z)的平方根。
 如果你只需要比较向量的长度，你可以使用sqrMagnitude(计算长度的平方根是较快的)比较它们的长度平方。
 参见: sqeMagnitude
◆ var normalized : Vector3
 描述: 返回这个向量，并且magnitude为1(只读)。
 规范化之后，一个向量保持相同的方向但是它的长度为1.0。
 注意当前的向量不改变并返回一个新的规范化向量，如果你像规范化当前向量，使用normalized函数。
 如果这个向量太小以至于不能规范化，将返回一个零向量。
 参见: Normalize函数
◆ var sqeMagnitude : float
 描述: 返回这个向量长度的平方(只读)。
 计算长度的平方比magnitude更快。通常如果你只比较两个向量的长度你可以只比较它们的平方。
 // 检测当一个变化比closeDistance更接近
 // 这个比使用Vector3 magnitude更快
 var other : Transform;
 var closeDistance = 5.0;
 function Update() {
  if(other) {
  var sqeLen = (other.position – transform.position).sqrMagnitude;
  // 平方我们需要比较的距离
  if(sqrLen < closeDistance * closeDistance)
print(“The other transform is close to me!”);
 }
}
 参见: magnitude
◆ var this[index : int] : float
 描述: 分别使用[0],[1],[2]访问x,y,z组件。
 Vector3 p;
 p[1] = 5; //与p.y = 5相同
◆ var x : float
 描述: 该向量的x组件。
◆ var y : float
 描述: 该向量的y组件。
◆ var z : float
 描述: 该向量的z组件。
构造函数
◆ static function Vector3(x : float, y : float, z : float) : Vector3
 描述: 用给定的x,y,z组件构建一个新的向量。
◆ static function Vector3(x : float, y : float) : Vector3
 描述: 用给定的x,y组件构建一个新的向量并设置z为0。
函数
◆ function Normalize() : void
 描述: 使该向量的magnitude为1。
 规范化之后，一个向量保持相同的方向但是它的长度为1.0。
 注意这个函数将改变当前向量。如果你想保持当前向量不改变，使用normalized变量。
 如果这个向量太小以至于不能规范化，它将被设置为0.
 参见: normalized变量
◆ function Scale(scale : Vector3) : void
 描述: 用scale的组件乘以这个向量中的每个对应组件。
◆ static function Scale(a : Vecotr3, b : Vector3) : Vecotr3
 描述: 两个向量的组件相乘。
 结果中的每个组件是a中的一个组件乘以b中的相对应组件。
 // 打印(2.0, 6.0, 12.0)
 print(Vector3.Scale(Vector3(1,2,3), Vector3(2,3,4)));
◆ function ToString() : string
 描述: 返回格式化好的Vector3字符串。
类变量
◆ static var forward : Vector3
 描述: Vector3(0, 0, 1)的简写。
 transform.position += Vector3.forward * Time.deltaTime;
◆ static var one : Vector3
 描述: Vector3(1, 1, 1)的简写。
 transform.position = Vector3.one;
◆ static var right : Vector3
 描述: Vector3(1, 0, 0)的简写。
 transform.position += Vector3.right * Time.deltaTime;
◆ static var up : Vector3
 描述: Vector3(0, 1, 0)的简写。
 transform.position += Vector3.up * Time.deltaTime;
◆ static var zero : Vector3
 描述: Vector3(0, 0, 0)的简写。
 transform.position += Vector3.zero;
类方法
◆ static function Angle(from : Vector3, to : Vector3) : float
 描述: 返回from和to之间的角度。
 // 如果这个变化的z轴看向target
 // 打印”close”
 var target : Transform;
 function Update() {
  var targetDir = target.position – transform.position;
 var forward = transform.forward;
 var angle = Vector3.Angle(targetDir, forward);
 if(angle < 5.0)
  print(“close”);
 }
◆ static function Cross(lhs : Vector3, rhs : Vector3) : float
 描述: 两个向量的叉乘。
 返回lhs x rhs。
◆ static function Distance(a : Vector3, b : Vector3) : float
 描述: 返回a和b之间的距离。
Vector3.Distance(a, b)与(a – b).magnitude相同。
 var other : Transform;
 if(other) {
  var dist = Vector3.Distance(other.position, transform.position);
 print(“Distance to other: ” + dist);
 }
◆ static function Dot(lhs : Vector3, rhs : Vector3) : float
 描述: 两个向量的点乘。
 返回lhs.rhs。
 对于normalized的向量，如果它们指向相同的方向Dot返回1；如果指向完全相反的方向则返回-1；在另外的情况下返回一个数字(例如，如果向量垂直则Dot返回0)。
 对于任意长度的向量Dot返回的值是相同的。当两个向量的角度增加的时候，这个值会变大。
 // 检测是否有其他变换在这个物体之后
 var other : Transform;
 function Update() {
  if(other) {
  var forward = transform.Transform.Distance(Vector3.forward);
   var toOther = other.position;
  transform.position;
  if(Vector3.Dot(forward, toOther) < 0)
print(“The other transform is behind me!”);
  }
 }
◆ static function Lerp(from : Vector3, to : Vector3, t : float) : Vector3
 描述: 在两个向量之间找到线性插值。
 从from到to基于t插值。
 t被裁剪到（0…1）之间。当t为0时返回from，当t为1时返回to。当t = 0.5时返回from和to的平均值。
 // 在一秒内从from开始移动到to结束
 var start : Transform;
 var end : Transform;
 function Update() {
  transform.position = Vector3.Lerp(start.position, end.position, Time.time);
 }
 // 像一个弹簧一样跟随target位置
 var target : Transform;
 var smooth = 5.0;
 function Update() {
  transform.position = Vector3.Lerp(transform.position, target.position, Time.deltaTime * smooth);
 }
◆ static function Max(lhs : Vector3, rhs : Vector3) : Vector3
 描述: 返回由lhs和rhs中最大组件组成的向量。
 var a = Vector3(1,2,3);
 var b = Vector3(4,3,2);
 print(Vector3.Max(a,b)); //打印(4.0, 3.0, 3.0);
 参见: Min函数
◆ static function Min(lhs : Vector3, rhs : Vector3) : Vector3
 描述: 返回由lhs和rhs中最小组件组成的向量。
var a = Vector3(1,2,3);
 var b = Vector3(4,3,2);
 print(Vector3.Min(a,b)); //打印(1.0, 2.0, 2.0);
 参见: Max函数
◆ static operator != (lhs : Vecotr3, rhs : Vecotr3) : bool
 描述: 如果向量不同返回true。
 非常接近的向量被认为是相等的。
 var other : Transform;
 if(other && transform.position != other.position) {
  print(“I’m at the different place than the other transform!”);
 }
◆ static operator * (a : Vector3, d : float) : Vector3
 描述: 用一个数乘以一个向量。
 用d乘以a的每个组件。
 print(Vector3(1,2,3) * 2.0); //使向量变为二倍长，打印(2.0, 4.0, 6.0)
◆ static operator * (d : float , a : Vector3) : Vector3
 描述: 用一个数乘以一个向量。
 用d乘以a的每个组件。
 print(Vector3(1,2,3) * 2.0); //使向量变为二倍长，打印(2.0, 4.0, 6.0)

◆ static operator + (a : Vector3, b : Vector3) : Vector3
 描述: 两个向量相加。
 将对应的组件加在一起。
 // 打印(5.0, 7.0, 9.0)
 print(Vector3(1,2,3) + Vector3(4,5,6));

◆ static operator - (a : Vector3, b : Vector3) : Vector3
 描述: 两个向量相减。
 将a与b对应的组件相减。
 // 打印(-5.0, -3.0, -1.0)
 print(Vector3(1,2,3) - Vector3(6,5,4));

◆ static operator - (a : Vector3) : Vector3
 描述: 向量取反。
 将a中的每个组件都取反。
 // 打印(-1.0, -2.0, -3.0)
 print(Vector3(1,2,3));

◆ static operator / (a : Vector3, d : float) : Vector3
 描述: 用一个数除以一个向量。
 用d除以a的每个组件。
 // 使向量缩短一倍，打印(0.5, 1.0, 1.5)
 print(Vector3(1,2,3) / 2.0);
◆ static operator == (lhs : Vector3, rhs : Vector3) : bool
 描述: 如果向量相等返回true。
 对于非常接近相等的向量，这个也返回真。
 var other : Transform;
 if(other && transform.position == other.position) {
  print(“I’m at the same place as the other transform”);
 }
◆ static function OrthoNormalize(ref normal : Vector3, ref tangent : Vector3) : void
 描述: 使两个向量规范化并互相正交。
 规范化normal；规范化tangent并确保它正交于normal（就是说，它们之间的角度是90度）。
 参见: Normalize函数
◆ static function OrthoNormalize(ref normal : Vector3, ref tangent : Vector3, ref binormal : Vector3) : void
 描述: 使两个向量规范化并互相正交。
 规范化normal；规范化tangent并确保它与normal。规范化binormal并确保它与normal和tangent正交。
 参见: Normalize函数
◆ static function Project(vector : Vector3 , onNormal : Vector3) : Vector3
 描述: 投影一个向量到另一个向量。
 返回投影到onNormal上的vector。如果onNormal接近零，返回零矩阵。
◆ static function Reflect(inDirection : Vector3, inNormal : Vector3) : Vector3
 描述: 沿着法线反射这个向量。
 返回的值inDirection从以inNormal为法线的表面反射。
 var originalObject : Transform;
 var reflectedObject : Transform;
 function Update() {
  // 使反射物体与凡是物体沿着世界的z轴镜像反射
 reflectedObject.position = Vector3.Reflect(originalObject.position, Vector3.right);
}
◆ static function RotateTowards(from : Vector3, to : Vector3, maxRadiansDelta : float, maxMagnitudeDelta : float) : Vector3
 描述: 旋转一个向量from到to。
 该向量将被在一个弧线上旋转而不是线形插值。本质上与Vector3.Slerp相同，但是这个函数将确保角速度和长度的改变不会超过maxRadiansDelta和maxMagnitudeDelta。
◆ function Scale(scale : Vector3) : void
 描述: 用sacle的组件乘以这个向量中的每个对应组件。
◆ static function Scale(a : Vector3, b : Vector3) : Vector3
 描述: 两个向量组件相乘。
 结果中的每个组件是a中的一个组件乘以b中相对应的组件。
 // 打印(2.0, 6.0, 12.0)
 print(Vector3.Scale(Vector3(1,2,3), Vector3(2,3,4)));
◆ static function Slerp(from : Vector3, to : Vector3, t : float) : Vector3
 描述: 在两个向量之间球形插值。
 从from到to基于t插值，返回向量的magnitude将在from和to的长度之间插值。
 t被裁剪到[0…1]之间。
 // 在sunrise和sunset之间以弧线变换一个位置
 var sunrise : Transform;
 var sunset : Transform;
 function Update() {
  // 弧线的中心
  var center = (sunrise.position – sunset.position) * 0.5;
 // 向下移动一点中心使该弧线垂直
 center.y -= 1;
 //相对于中心插值这个弧线
 var riseRelCenter = sunrise.positioni – center;
 var setRelCenter = sunset.position – center;
 transform.position = Vector3.Slerp(riseRelCenter, setRelCenter. Time.time);
 transform.position += center;
 }
 参见: Lerp函数
Vector4
 结构
 表示四维向量。
 这个结构被用在一些地方来表示四个组件的向量（例如，网格切线，shader的参数）。在其他的一些地方使用Vector5。

变量
◆ var magnitude : float
 描述: 返回这个向量的长度（只读）。
 向量的长度是(x*x+y*y+z*z+w*w)的平方根。
 如果你只需要比较向量的长度，你可以使用sqrMagnitude（计算长度的平方是比较快的）比较它们的长度平方。
 参见: sqrMagnitude
◆ var normalized : Vector4
 描述: 返回这个向量，并且magnitude为1（只读）。
 注意当前的向量不改变并返回一个新的规范化的向量。如果你像规范化当前向量，使用Normalize函数。
 如果这个向量太小以至于不能规范化，将返回一个零向量。
 参见: Normalize函数。
◆ var sqrMagnitude : float
 描述: 返回这个向量的长度的平方（只读）。
 计算长度的平方比magnitude更快。
 参见: magnitude
◆ var this[index : int] : float
 描述: 分别使用[0],[1],[2],[3]访问x,y,z,w组件。
 Vector4 p;
 p[3] = 5; // 与p.w = 5相同
◆ var w : float
 描述: 该向量的w组件。
◆ var x : float
 描述: 该向量的x组件。
◆ var y : float
 描述: 该向量的y组件。
◆ var z : float
 描述: 该向量的z组件。
构造函数
◆ static function Vector4 (x : float, y : float, z : float, w : float) : Vector4
 描述: 用给定的x,y,z,w组件构建一个新的向量。
◆ static function Vector4 (x : float, y : float, z : float) : Vector4
 描述: 用给定的x,y,z组件构建一个新的向量并设置w为0。
◆ static function Vector4 (x : float, y : float) : Vector4
 描述: 用给定的x,y组件构建一个新的向量并设置z和w为0。
函数
◆ function Normalize() : void
 描述: 使该向量的magnitude值为1。
 注意这个函数将改变当前向量。如果你想保持当前向量不改变，使用normalized变量。
 如果这个向量太小以至于不能规范化，它将被设置为0。
 参见: normalized变量
◆ function Scale(scale : Vector4) : void
 描述: 用scale的组件乘以这个向量中的每个对应组件。
◆ static function Scale(a : Vector4, b : Vector4) : Vector4
 描述: 两个向量的组件相乘。
 结果中的每个组件是a中的一个组件乘以b中相同的组件。
 // 打印(2.0, 6.0, 12.0, 12.0)
 print(Vector4.Scale(Vector4(1,2,3,4), Vector4(2,3,4,5)));
◆ function ToString() : String
 描述: 返回格式化好的vector字符串
类变量
◆ static var one : Vector4
 描述: Vector4(1,1,1,1)的简写。
◆ static var zero : Vector4
 描述: Vector4(0,0,0,0)的简写。
类方法
◆ static function Distance(a : Vector4, b : Vector4) : float
 描述: 返回a和b之间的距离。
 Vector4 Distance(a,b)和(a-b).magnitude相同。
◆ static function Dot(lhsVector4, rhsVector4) : float
 描述: 两个向量的点乘。
 返回lhs.rhs。
◆ static function Lerp(from : Vector4, to : Vector4, t : float) : Vector4
 描述: 在两个向量之间线形插值。
 从from到to 基于t插值。
 t被裁剪到[0…1]之间，当t为0时返回from，当t为1时返回to，当t = 0.5时返回from与to的平均值。
◆ static operator != (lhs : Vector4, rhs : Vector4) : bool
 描述: 如果向量不同返回真。
 非常接近的向量被认为是相等的。
◆ static operator * (a : Vector4, d : float) : Vector4
 描述: 用一个数乘以一个向量。
 用d乘以a的每个组件。
 // 使向量变为二倍长，打印(2.0, 4.0, 6.0, 8.0)
 print(Vector4(1,2,3,4) * 2.0);
◆ static operator * (d : float, a : Vector4) : Vector4
 描述: 用一个数乘以一个向量。
 用d乘以a的每个组件。
 // 使向量变为二倍长，打印(2.0, 4.0, 6.0, 8.0)
 print(2.0 * Vector4(1,2,3,4));
◆ static operator + (a : Vector4, b : Vector4) : Vector4
 描述: 两个向量相加。
 将对应的组件加在一起。
 // 打印(5.0, 7.0, 9.0, 11.0)
 print(Vector4(1,2,3,4) + Vector4(4,5,6,7));
◆ static operator - (a : Vector4, b : Vector4) : Vector4
 描述: 两个向量相减。
 从a中减去b中每个对应的组件。
 // 打印(-5.0, -3.0, -1.0, 1.0)
 print(Vector4(1,2,3,4) + Vector4(6,5,4,3));
◆ static operator - (a : Vector4) : Vector4
 描述:向量取反。
 a中的每个组件都被取反。
 // 打印(-4.0, -3.0, -2.0, -1.0)
 print(-Vector4(4,3,2,1));
◆ static operator / (a : Vector4, d : float) : Vector4
 描述: 用一个数除以一个向量。
 从d除以a中每个组件。
 // 使向量缩短一半，打印(0.5, 1.0, 1.5, 2.0)
 print(Vector4(1,2,3,4) / 2.0);
◆ static operator == (lhs : Vector4, rhs : Vector4) : bool
 描述: 如果向量相等返回true。
 对于非常接近相等的向量，这个也返回true。
◆ static implicit function Vector3(v : Vector4) : Vector3
 描述: 把一个Vector4转换为一个Vector3。
 Vector4可以被隐式转换成Vector3(w被丢弃)。
 function Start() {
  // shader总是Vector4。但是这个值被转化成一个Vector3。
 var value : Vector3 = renderer.material.GetVector(“_SomeVariable”);
 }
◆ static implicit function Vector4(v : Vector3) : Vector4
 描述: 把一个Vector3转换为一个Vector4。
 Vector3可以被隐式转换成Vector4(w被设置为0)。
 function Start() {
  // shader总是Vector4。这个值从一个Vector3转换为一个Vector4。
 var value : Vector3 = Vector3.one;
 renderer.material.SetVector(“_SomeVariable”, value);
 }
◆ static function Project(a : Vector4, b : Vector4) : Vector4
 描述: 投影一个向量到另一个向量。
 返回投影到b的a。
◆ static Scale(scale : Vector4) : void
 描述: 用scale的组件乘以这个向量中的每个对应组件。
◆ static function Scale(a : Vector4, b : Vector4) : Vector4
 描述: 两个向量的组件相乘。
 结果中每个组件都是a中的一个组件乘以b中的对应组件。
 // 打印(2.0, 6.0, 12.0 , 20.0)
 print(Vector4.Scale(Vector4(1,2,3,4), Vector4(2,3,4,5)));