脚本学习 函数接口说明

原文出自：http://design.gugebb.com/t24-topic

===============================================================

◆ 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; style="PADDING-BOTTOM: 0px; WIDOWS: 2; TEXT-TRANSFORM: none; BACKGROUND-COLOR: rgb(255,255,255); TEXT-INDENT: 0px; MARGIN: 0px; PADDING-LEFT: 0px; PADDING-RIGHT: 0px; FONT: 13px/18px Verdana, Arial, Helvetica, sans-serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: rgb(107,107,107); WORD-SPACING: 0px; PADDING-TOP: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px" {
for(x=0; x<TEXTURE.WIDTH; style="PADDING-BOTTOM: 0px; MARGIN: 0px; PADDING-LEFT: 0px; PADDING-RIGHT: 0px; PADDING-TOP: 0px" {
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; style="PADDING-BOTTOM: 0px; MARGIN: 0px; PADDING-LEFT: 0px; PADDING-RIGHT: 0px; PADDING-TOP: 0px" ++mip){
var cols=texture.GetPixels(mip);
for(var i=0; i<COLS.LENGTH; style="PADDING-BOTTOM: 0px; MARGIN: 0px; PADDING-LEFT: 0px; PADDING-RIGHT: 0px; PADDING-TOP: 0px" ++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
描述：
◆ static function GetDirectoryName(path: string): string
描述：
◆ static function GetExtension(path: string): string
描述：
◆ static function GetFileName(path: string): string
描述：
◆ static function GetFileNameWithoutExtension(path: string): string
描述：
Physics
類
全局屋裡屬性和輔助方法。
類變量
◆ static var bounceThreshold: float
描述：兩個碰撞物體的相對速度對於這個值時將不會反彈（默認為2）。必須為正
這個值可以在Edit->Project Settings->Physics的檢視面板中改變而不是通過腳本。
◆ 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 Linecase(start: Vector3, end: Vector3, layerMask: int=
kDefaultRaycastLayers): bool
描述：如果有任何碰撞器與從start開始到end的線段相交時返回真.
var target: Transform;
function Update(){
if(!Physics.Linecast(transform.position, target.position}){
//做一些事情
}
}
當投射射線時，Layer mask被用來選擇性的忽略碰撞器.
◆ static function Linecase(start: Vector3, end: Vector3, out hitInfo: RaycastHit, layerMask:
int=kDefaultRaycastLayers): bool
描述：如果有任何碰撞器與從start開始到end的線段相交時返回真.
如果返回真，hitInfo將包含更多關於碰撞器被碰到什麼地方的信息（參考：RaycastHit）.
當投射射線時，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[]
◆ 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++) style="PADDING-BOTTOM: 0px; MARGIN: 0px; PADDING-LEFT: 0px; PADDING-RIGHT: 0px; PADDING-TOP: 0px" {
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 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[包含]之間（只讀）.
//在xz平面上的-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 horizo​​ntal: 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 () {
++fra​​mes;
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更快