Unity API - C

裴嘉许

2023-12-01

废话不多说，一针见血，go！
一起来看 API

Caching 缓存

缓存类允许您管理缓存AssetBundles,下载使用 WWW.LoadFromCacheOrDownload

Caching.Authorize 授权
授权这个Unity内容使用缓存

Caching.CleanCache 清除缓存
删除这个内容相关的缓存文件夹

当你已经有一个缓存许可证时，这个函数才能激活

Caching.Authorize (name, domain, size, signature);
    if (GUILayout.Button("Uninstall Game"))
        Caching.CleanCache ();

Caching.compressionEnabled
控制缓存数据的压缩。默认启用。

如果启用了缓存压缩,然后将所有数据存储在一个压缩的形式使用快速LZ4算法。这个属性只影响进一步下载。它不压缩或解压缩在缓存中现有内容。

缺省值为“true”

Caching.enabled 启用
缓存是否启用？

if (!Caching.enabled)
    GUILayout.Label ("Please turn on caching to run this game.");

Caching.expirationDelay 截止延迟
在缓存中没有被使用的AssetBundle的过期时间，单位为秒。

这个值默认为150天(12960000秒)。较低的值会导致缓存清理更积极地为了最小化磁盘存储使用。不能设置大于12960000秒延迟

Caching.IsVersionCached 是否缓存的版本
检查，如果一个资源包被缓存

if (Caching.IsVersionCached("http://myserver.com/bla.unity3d", 3))
    GUILayout.Button("Load Level");

Caching.MarkAsUsed
标记缓存文件的时间戳为当前时间

这允许你保持文件缓存即使你不是显式地加载它们
如果url缓存返回true

Caching.maximumAvailableDiskSpace
为缓存分配的总字节数

这个值可以设置为一个较小的数量,以限制缓存AssetBundles所使用的磁盘空间。 WebPlayer共享缓存允许缓存AssetBundles 50 MiB

Caching.ready 准备

Caching.spaceFree 剩余空间
可用的磁盘空间，以bytes（字节）为单位

Caching.spaceOccupied 占用空间
已经使用的磁盘空间，以bytes（字节）为单位

Camera 摄像机

Camera.AddCommandBuffer
添加一个命令执行缓冲区在指定的地方。

可以将多个命令缓冲区执行同一相机事件(甚至同一缓冲区可以多次添加)。

Camera.actualRenderingPath 实际渲染路径
实际使用的渲染路径（只读）

Camera.allCameras 所有相机
返回场景中所有启用的相机

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    public int count = Camera.allCameras.Length;
    void Example() {
        print("We've got " + count + " cameras");
    }
}

Camera.allCamerasCount 所有相机数量
当前场景中相机数量

var count = Camera.allCamerasCount;
    print ("We've got " + count + " cameras");

Camera.aspect 宽长比
宽长比（宽度除以高度）

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
    if (camera.aspect > 1.0F)
        print("Screen is more wide than tall!");
    else
        print("Screen is more tall than wide!");
    }
}

Camera.backgroundColor 背景颜色
屏幕将被清理为这个颜色

来回变化背景颜色

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public Color color1 = Color.red;
    public Color color2 = Color.blue;
    public float duration = 3.0F;
    void Update() 
    {   //设置消除标识到颜色
        float t = Mathf.PingPong(Time.time, duration) / duration;
        camera.backgroundColor = Color.Lerp(color1, color2, t);
    }
    public void Awake() 
    {
        camera.clearFlags = CameraClearFlags.SolidColor;
    }
}

Camera.CalculateObliqueMatrix 计算倾斜矩阵
计算并返回倾斜接近水平的投影矩阵

给定一个剪辑平面向量，该函数返回摄像机的投影矩阵，投影矩阵的这个剪辑平面设置为它的近平面

Camera.CameraCallback
委托类型的相机回调

使用这个 Camera.onPreCull , Camera.onPreRender 或 Camera.onPostRender 回调函数,当任何相机并呈现。

相机,调用回调将作为参数传递

Camera.cameraToWorldMatrix 相机转世界矩阵
从相机空间到世界空间的变换矩阵

在屏幕视图绘制一个黄色的球，以Distance单位，沿着相机所看方向

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public float distance = -1.0F;
    void OnDrawGizmosSelected() 
    {
        Matrix4x4 m = camera.cameraToWorldMatrix;
        Vector3 p = m.MultiplyPoint(new Vector3(0, 0, distance));
        Gizmos.color = Color.yellow;
        Gizmos.DrawSphere(p, 0.2F);
    }
}

Camera.cameraType
这是确定什么样的相机

Camera.clearFlags 清除标识
相机如何清除背景

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //用背景颜色清除（忽略天空盒）
        camera.clearFlags = CameraClearFlags.SolidColor;
    }
}

Camera.clearStencilAfterLightingPass
通常如果你使用延迟渲染相机和面具(见UI元素面具 ),你会想要模板缓冲区被清除

Camera.commandBufferCount
这架照相机上的命令缓冲区设置数量(只读)

Camera.CopyFrom 复制到
使这个相机的设置与其他相机相同

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Example() {
        camera.CopyFrom(Camera.main);
    }
}

Camera.cullingMask 消隐遮罩
这个用来选择性的渲染部分场景

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //只渲染在第一层中的物体（默认层）
        camera.cullingMask = 1 << 0;// 1/1
    }
}

Camera.current 当前相机
当前用于渲染的相机，只用于低级的渲染控制

Camera.depth 深度
相机在渲染顺序上的深度

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //设置这个相机在主相机之后渲染
        camera.depth = Camera.main.depth + 1;
    }
}

Camera.depthTextureMode 深度纹理模式
相机生成怎样的一个深度纹理

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //生成一个深度+法线纹理
        camera.depthTextureMode = DepthTextureMode.DepthNormals;
    }
}

Camera.eventMask 事件遮挡
遮挡相机的触发事件图层

正如cullingMask确定相机是否能够看到游戏对象，事件掩遮挡决定游戏物体是否能够接收鼠标事件。只有相机可见的对象，并且该对象遮挡层与相机的 eventMask 重叠，能够接收 OnMouseXXX 事件

Camera.farClipPlane 远裁剪平面
远裁剪面的距离

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        camera.farClipPlane = 100.0F;
    }
}

Camera.fieldOfView 固定视野
相机的视野，以度为单位

例一

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //设置附加到同一个游戏物体上相机的视野为60
        camera.fieldOfView = 60;
    }
}

例二
使用专门主相机

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //设置主相机的视野为 80
        Camera.main.fieldOfView = 80;
    }
}

Camera.GetAllCameras 获取所有相机
用当前场景中的摄像机填补相机的数组，而不需要分配一个新的数组
数组的大小必须大于allCamerasCount的值

Camera.GetCommandBuffers
Get命令缓冲区执行在指定的地方

Camera.hdr
这款相机使用HDR渲染吗?

Camera.layerCullDistances 层消隐距离
每层的消隐距离

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Start() 
    {
        float[] distances = new float[32];
        //设置层10的消隐为15米距离，其他所有层使用远剪裁屏幕距离
        distances[10] = 15;
        camera.layerCullDistances = distances;
    }
}

Camera.layerCullSpherical 球面层消隐
通常这种类型的消隐是通过移动相机的远平面接近眼睛执行。通过将该值设置为true，基于球面距离消隐。好处是，在原地旋转不影响可见对象

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Example() {
        camera.layerCullSpherical = true;
    }
}

Camera.main 主相机
第一个启用的被标记为“MainCanmera”的相机

Camera.nearClipPlane 近裁剪平面
近裁剪面的距离

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        camera.nearClipPlane = 0.1F;
    }
}

Camera.OnPostRender 在渲染之后
在相机渲染场景之后调用

这个脚本让你在每个相机开启/禁用雾效
在检视面板开启或禁用这个脚本
在每个相机可以开启/禁用雾效

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    private bool revertFogState = false;
    void OnPreRender() 
    {
        revertFogState = RenderSettings.fog;
        RenderSettings.fog = enabled;
    }
    void OnPostRender() 
    {
        RenderSettings.fog = revertFogState;
    }
}

Camera.OnPreCull 在消隐之前
OnPreCull在相机开始裁剪场景之前调用

附加这个到相机
反转相机中的物体，因此每个被渲染的物体是反的（**？？）

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnPreCull() 
    {
        camera.ResetWorldToCameraMatrix();
        camera.ResetProjectionMatrix();
        camera.projectionMatrix = camera.projectionMatrix * Matrix4x4.Scale(new Vector3(1, -1, 1));
    }
    void OnPreRender() 
    {   //设置为true，因此可以看到翻转的物体
        GL.SetRevertBackfacing(true);
    }
    void OnPostRender() 
    {   //设置为false，因为不想影响所有其他相机
        GL.SetRevertBackfacing(false);
    }
}

Camera.OnPreRender 在渲染之前
OnPreRender在相机开始渲染场景之前调用

这个脚本让你在每个相机开启/禁用雾效
在检视面板开启或禁用这个脚本
在每个相机可以开启/禁用雾效

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    private bool revertFogState = false;
    void OnPreRender() 
    {
        revertFogState = RenderSettings.fog;
        RenderSettings.fog = enabled;
    }
    void OnPostRender() 
    {
        RenderSettings.fog = revertFogState;
    }
}

Camera.OnRenderImage 在渲染图像之后
OnRenderImage在所有渲染完成后被调用，来渲染图片的后期处理效果

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    public Material mat;
    void OnRenderImage(RenderTexture src, RenderTexture dest) {
        Graphics.Blit(src, dest, mat);
    }
}

Camera.OnRenderObject 在渲染物体之后
OnRenderObject 被用来渲染你自己的物体，使用或者其他函数

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    public Mesh mainMesh;
    public Mesh miniMapMesh;
    void OnRenderObject() {
        if (Camera.current.name == "MiniMapcam")
            Graphics.DrawMeshNow(miniMapMesh, transform.position, transform.rotation);
        else
            Graphics.DrawMeshNow(mainMesh, transform.position, transform.rotation);
    }
}

Camera.OnWillRenderObject 在渲染物体之前
如果物体可见，每个相机都会调用OnWillRenderObject

增加otherObject的大小同时这个变换正在渲染
注意这个将被调用即使场景编辑器显示这个物体
因此，请确保在游戏视图看不到的物体，不在场景编辑器

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public GameObject otherObject;
    void OnWillRenderObject() 
    {
        otherObject.transform.localScale *= 1.0001F;
    }
}

Camera.opaqueSortMode
不透明的对象排序模式

不透明的对象是按不同的标准排序(排序层,材质队列, 材料、距离、以及材质等)最大化两个CPU效率(减少数量状态改变和提高绘制调用批处理),和GPU最大化效率 (许多gpu喜欢粗糙前后呈现以便更快的拒绝不可见表面)

Camera.orthographic 正交
相机是正交的（true），是透视的（false）？

例一

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //设置相机为正交
        camera.orthographic = true;
    }
}

例二
用于专门的主相机

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //设置主相机为正交
        Camera.main.orthographic = true;
    }
}

Camera.orthographicSize 正交大小
在正交模式下相机的一半尺寸

例一

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //设置相机的正交尺寸为5
        camera.orthographic = true;
        camera.orthographicSize = 5;
    }
}

例二
使用专门的主相机

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //设置主相机的正交尺寸为5
        Camera.main.orthographic = true;
        Camera.main.orthographicSize = 5;
    }
}

Camera.pixelHeight 相机高度
相机有多高，以像素单位

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        print("Camera is " + camera.pixelWidth + " pixels wide");
    }
}

Camera.pixelRect 像素矩形
相机被渲染到屏幕像素中的位置

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
void Update() 
{
      Rect r = camera.pixelRect;
      print("Camera displays from " + r.xMin + " to " + r.xMax + " pixel");
}
}

Camera.pixelWidth 相机宽度
相机有多宽，以像素单位

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        print("Camera is " + camera.pixelWidth + " pixels wide");
    }
}

Camera.projectionMatrix 投影矩阵
设置自定义的投影矩阵

例一
让相机以流行的方式晃动

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public Matrix4x4 originalProjection;
    void Update() 
    {
        Matrix4x4 p = originalProjection;
        //改变原始矩阵的某些值
        p.m01 += Mathf.Sin(Time.time * 1.2F) * 0.1F;
        p.m10 += Mathf.Sin(Time.time * 1.5F) * 0.1F;
        camera.projectionMatrix = p;
    }
    public void Awake() 
    {
        originalProjection = camera.projectionMatrix;
    }
}

例二
设置一个偏移中心的投影，这个透视的消失点没有必要在屏幕的中心
定义近载面大小，例如相机的近裁面偏移中心多少
改变这个值你就能看到相机视图的变化

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public float left = -0.2F;
    public float right = 0.2F;
    public float top = 0.2F;
    public float bottom = -0.2F;
    void LateUpdate() 
    {
        Camera cam = camera;
        Matrix4x4 m = PerspectiveOffCenter(left, right, bottom, top, cam.nearClipPlane, cam.farClipPlane);
        cam.projectionMatrix = m;
    }
    static Matrix4x4 PerspectiveOffCenter(float left, float right, float bottom, float top, float near, float far) {
        float x = 2.0F * near / right - left;
        float y = 2.0F * near / top - bottom;
        float a = right + left / right - left;
        float b = top + bottom / top - bottom;
        float c = -far + near / far - near;
        float d = -2.0F * far * near / far - near;
        float e = -1.0F;
        Matrix4x4 m;
        m[0, 0] = x;
        m[0, 1] = 0;
        m[0, 2] = a;
        m[0, 3] = 0;
        m[1, 0] = 0;
        m[1, 1] = y;
        m[1, 2] = b;
        m[1, 3] = 0;
        m[2, 0] = 0;
        m[2, 1] = 0;
        m[2, 2] = c;
        m[2, 3] = d;
        m[3, 0] = 0;
        m[3, 1] = 0;
        m[3, 2] = e;
        m[3, 3] = 0;
        return m;
    }
}

Camera.rect 矩形
相继被渲染到屏幕规范化坐标中的位置

Rect的范围总0（左/下）到1（右/上）

//每次按下空格键时改变视口宽度
function Update () 
{
    if (Input.GetButtonDown ("Jump")) 
    {
        //随机选择边缘
        var margin = Random.Range (0.0, 0.3);
        //设置矩形
        camera.rect = Rect (margin, 0, 1 - margin * 2, 1);
    }
}

Camera.RemoveAllCommandBuffers
删除所有命令缓冲区设置相机

Camera.RemoveCommandBuffer
从执行删除命令缓冲区在指定的地方。

如果相同的缓冲区添加多次在这个相机事件,出现的所有将被删除

Camera.RemoveCommandBuffers
从执行删除命令缓冲区在指定的地方。

该函数删除所有命令缓冲区设置相机上指定的事件

Camera.Render 渲染
手动渲染相机
这个将渲染相机，这将使用相机的清除标记，目标纹理和所有其它设置。

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    Texture2D RTImage(Camera cam) {
        RenderTexture currentRT = RenderTexture.active;
        RenderTexture.active = cam.targetTexture;
        cam.Render();
        Texture2D image = new Texture2D(cam.targetTexture.width, cam.targetTexture.height);
        image.ReadPixels(new Rect(0, 0, cam.targetTexture.width, cam.targetTexture.height), 0, 0);
        image.Apply();
        RenderTexture.active = currentRT;
        return image;
    }
}

Camera.renderingPath 渲染路径
渲染路径

Camera.RenderToCubemap 渲染到立方图
从这个相机渲染到一个立方贴图

例一

//从给定的点渲染香精到以静态立方贴图
//放置这个脚本到工程的Editor文件夹中
//然后用一个Reflective shaders 来使用这个立方贴图
class RenderCubemapWizard extends ScriptableWizard 
{
    var renderFromPosition : Transform;
    var cubemap : Cubemap;

    function OnWizardUpdate () 
    {
        helpString = "Select transform to render from and cubemap to render into";
        isValid = (renderFromPosition != null) && (cubemap != null);
    }

    function OnWizardCreate () 
    {
        //为渲染创建临时相机
        var go = new GameObject( "CubemapCamera", Camera );
        //放置它到物体上
        go.transform.position = renderFromPosition.position;
        go.transform.rotation = Quaternion.identity;

        //渲染到立方贴图    
        go.camera.RenderToCubemap( cubemap );

        //销毁临时相机
        DestroyImmediate( go );
    }

    @MenuItem("GameObject/Render into Cubemap")
    static function RenderCubemap () 
    {
        ScriptableWizard.DisplayWizard.<RenderCubemapWizard>(
        "Render cubemap", "Render!");
    }
}

例二

//附加这个脚本到使用了Reflective shader的物体上 
//实时反射立方贴图
@script ExecuteInEditMode

var cubemapSize = 128;
var oneFacePerFrame = false;
private var cam : Camera;
private var rtex : RenderTexture;

function Start () 
{
    //在启动时渲染所有六个面
    UpdateCubemap( 63 );
}

function LateUpdate () 
{
    if (oneFacePerFrame) 
    {
        var faceToRender = Time.frameCount % 6;
        var faceMask = 1 << faceToRender;
        UpdateCubemap (faceMask);
    } 
    else 
    {
        UpdateCubemap (63); //所有六个面
    }
}

function UpdateCubemap (faceMask : int) 
{
    if (!cam) 
    {
        var go = new GameObject ("CubemapCamera", Camera);
        go.hideFlags = HideFlags.HideAndDontSave;
        go.transform.position = transform.position;
        go.transform.rotation = Quaternion.identity;
        cam = go.camera;
        cam.farClipPlane = 100; //不要渲染较远的部分
        cam.enabled = false;
    }

    if (!rtex) 
    {
        rtex = new RenderTexture (cubemapSize, cubemapSize, 16);
        rtex.isPowerOfTwo = true;
        rtex.isCubemap = true;
        rtex.hideFlags = HideFlags.HideAndDontSave;
        renderer.sharedMaterial.SetTexture ("_Cube", rtex);
    }

    cam.transform.position = transform.position;
    cam.RenderToCubemap (rtex, faceMask);
}

function OnDisable () 
{
    DestroyImmediate (cam);
    DestroyImmediate (rtex);
}

Camera.RenderWithShader 用Shader渲染
用shader替代渲染相机

Camera.ResetAspect 重设长宽比
恢复长宽比为屏幕的长宽比

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        camera.ResetAspect();
    }
}

Camera.ResetFieldOfView
重置为默认的视野。

称之为结束设置的影响 fieldOfView 。默认的视野可以动态设置虚拟现实设备。

Camera.ResetProjectionMatrix 重设投影矩阵
让投影反映正常的相机参数（**？？）

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        camera.ResetProjectionMatrix();
    }
}

Camera.ResetReplacementShader 重设替换Shader
从相机上移除shader替换（**?？）

Camera.ResetStereoProjectionMatrices
使用默认的立体眼睛的投影矩阵。只有在三维平板显示器工作

Camera.ResetStereoViewMatrices
使用立体眼睛的默认视图矩阵。只有在三维平板显示器工作

Camera.ResetWorldToCameraMatrix 重设世界转相机矩阵
在场景中让渲染位置反映相机的位置

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        camera.ResetWorldToCameraMatrix();
    }
}

Camera.ScreenPointToRay 屏幕位置转射线
返回一条射线从摄像机通过一个屏幕点

打印相机直接看到物体名称

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Update() 
    {   //获取穿过屏幕中心的射线
        Ray ray = camera.ViewportPointToRay(new Vector3(0.5F, 0.5F, 0));
        //投射
        RaycastHit hit;
        if (Physics.Raycast(ray, ref hit))
            print("I'm looking at " + hit.transform.name);
        else
            print("I'm looking at nothing!");
    }
}

Camera.ScreenToViewportPoint 屏幕转视窗位置
从屏幕空间到视窗空间的变换位置

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Update() {
        transform.position = Camera.main.ScreenToViewportPoint(Input.mousePosition);
    }
}

Camera.ScreenToWorldPoint 屏幕转世界位置
从屏幕空间到世界空间的变化位置

在所选相机的近裁剪面上，绘制一个黄色的球，在左下100像素的位置

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnDrawGizmosSelected() 
    {
        Vector3 p = camera.ScreenToWorldPoint(new Vector3(100, 100, camera.nearClipPlane));
        Gizmos.color = Color.yellow;
        Gizmos.DrawSphere(p, 0.1F);
    }
}

Camera.SetReplacementShader 设置替换Shader
使相机渲染用shader替换

调用此函数后,相机将呈现它的视图与材质替换。调用 ResetReplacementShader 重置它恢复正常渲染

Camera.SetStereoProjectionMatrices
定义两个立体的投影矩阵。只有在三维平板显示器工作

Camera.SetStereoViewMatrices
定义视图矩阵对音响的眼睛。只有在三维平板显示器工作

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {

    void Start () {
    }

    void Update ()
    {
        Camera cam = GetComponent<Camera>();

        Matrix4x4 viewL = cam.worldToCameraMatrix;
        Matrix4x4 viewR = cam.worldToCameraMatrix;

        viewL[12] += 0.011f;
        viewR[12] -= 0.011f;
        cam.SetStereoViewMatrices (viewL, viewR);
    }
}

Camera.SetTargetBuffers 设置目标缓冲区域
设置相机渲染到一个或多个RenderTextures所选择的缓冲区

Camera.stereoConvergence 立体聚焦
虚拟视点相交点间距

Camera.stereoEnabled 开启立体
立体渲染
该相机的渲染是否是从虚拟视点作为一个立体输出的相机？

Camera.stereoMirrorMode
只渲染一次和使用对眼睛产生的图像

Camera.stereoSeparation 立体分离
虚拟眼间距离

Camera.targetDisplay
为这款相机设定目标显示。

此设置重定向相机呈现二次显示。最大数量的二次显示(如。监视器)支持是8

Camera.targetTexture 目标纹理
渲染纹理的目标

Camera.transparencySortMode 透明物体排序模式
透明物体的排序模式

默认情况下，透视相机排序对象是基于从摄像机的位置到对象中心的距离；和正交相机排序是基于沿视线方向的距离
如果你使用透视相机制作2D游戏，你也许会想使用TransparencySortMode.Orthographic 排序模式以便对象是基于相机的视线排

Camera.useOcclusionCulling 使用遮挡剔除
无论是否在渲染过程中相机都会使用遮挡剔除

Camera.velocity 速度
获取世界空间中相机的速度

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Update() 
    {
        print("Camera moving at " + camera.velocity.magnitude + " m/s");
    }
}

Camera.ViewportPointToRay 视窗位置转射线
返回从相机出发穿过视点的一个射线

打印相机直接看到物体名称

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Update() 
    {   //获取穿过屏幕中心的射线
        Ray ray = camera.ViewportPointToRay(new Vector3(0.5F, 0.5F, 0));
        //投射
        RaycastHit hit;
        if (Physics.Raycast(ray, ref hit))
            print("I'm looking at " + hit.transform.name);
        else
            print("I'm looking at nothing!");
    }
}

Camera.ViewportToScreenPoint 视窗转屏幕位置
从视口空间到屏幕空间的变换位置

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    public Texture2D bottomPanel;
    void VPToScreenPtExample() {
        Vector3 origin = Camera.main.ViewportToScreenPoint(new Vector3(0.25F, 0.1F, 0));
        Vector3 extent = Camera.main.ViewportToScreenPoint(new Vector3(0.5F, 0.2F, 0));
        GUI.DrawTexture(new Rect(origin.x, origin.y, extent.x, extent.y), bottomPanel);
    }
}

Camera.ViewportToWorldPoint 视窗转世界位置
从视窗空间到世界空间的变换位置

在近裁剪面的右上角绘制一个黄色的球，针对在场景视图中选中的相机

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnDrawGizmosSelected() 
    {
        Vector3 p = camera.ViewportToWorldPoint(new Vector3(1, 1, camera.nearClipPlane));
        Gizmos.color = Color.yellow;
        Gizmos.DrawSphere(p, 0.1F);
    }
}

Camera.worldToCameraMatrix 世界转相机矩阵
从世界到相机空间的变换矩阵

从Offsets位置偏移相机的渲染

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public Vector3 offset = new Vector3(0, 1, 0);
        void LateUpdate() 
        {//构建一个沿着Z轴偏移和镜像的矩阵，因为相机已经为Z轴镜像，并用于其余部分
        Vector3 camoffset = new Vector3(-offset.x, -offset.y, offset.z);
        Matrix4x4 m = Matrix4x4.TRS(camoffset, Quaternion.identity, new Vector3(1, 1, -1));
        //重载worldToCameraMatrix为偏移/镜像的变换矩阵
        camera.worldToCameraMatrix = m * transform.worldToLocalMatrix;
    }
}

Camera.WorldToScreenPoint 世界转屏幕位置
从世界空间到屏幕空间变换位置

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public Transform target;
    void Update() 
    {
        Vector3 screenPos = camera.WorldToScreenPoint(target.position);
        print("target is " + screenPos.x + " pixels from the left");
    }
}

Camera.WorldToViewportPoint 世界转视窗位置
从世界空间到视窗空间的变换位置

Target在屏幕的左边还是右边

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public Transform target;
    void Update() 
    {
        Vector3 viewPos = camera.WorldToViewportPoint(target.position);
        //视口坐标范围从0到1
        if (viewPos.x > 0.5F)
            print("target is on the right side!");
        else
            print("target is on the left side!");
    }
}

Canvas 画布

元素在画布上呈现的场景渲染后，从附加的相机或者使用叠加模式

Canvas.cachedSortingLayerValue 缓存的排序层值
基于排序层ID的缓存计算值

Canvas.ForceUpdateCanvases 强制更新画布
强制更新所有画布的内容
在最后一帧画布执行布局和内容生产的计算，仅在渲染之前，为了确保在该帧期间发生的最新的改变在画布上。这意味着在返回调用开始和首次更新返回调用时，画布下的布局和内容可能不是最新的

Canvas.GetDefaultCanvasMaterial 获取默认画布材质
返回默认材质，可被用于渲染画布中的正常元素

Canvas.isRootCanvas 是否根画布
是否是根画布？

Canvas.overridePixelPerfect 重载像素保真
允许内置的画布继承父画布的重载像素保真设置

Canvas.overrideSorting 重载排序
重载画布排序
允许内画布忽视父级别的绘画顺序和顶层或者底层

Canvas.pixelPerfect 像素保真
强制画布上的元素与像素对其。仅在Screen Space模式下显示

启用pixelPerfect可以是元素变得清晰减少模糊。但是，如果很多元素被旋转或者缩放或者细微的活动的位置活缩放比例，像素保真可能失效，之后也会失去光滑。

Canvas.pixelRect 像素矩阵
获取画布的渲染的矩形

如果在重载模式该方法将会规范。如果在世界模型该方这将是相机屏幕视口矩形。

Canvas.planeDistance 平面距离
摄像机到画布产生的距离多少

Canvas.referencePixelsPerUnit 参考像素单位
默认的单位像素的数量
控制精灵的像素密度的像素单位。对于精灵来说像素单位与画布中的参考像素单位是一样的，像素密度比是一比一

Canvas.renderMode 渲染模式
画布是在世界中还是重叠模式？

Canvas.renderOrder 呈现顺序
场景呈现的渲染画布的顺序

注意：仅当Screen Space - Overlay模式下画布是正确有序的，Screen Space - Camera和 World Space模式下基于相机的距离进行排序

Canvas.scaleFactor 缩放因素
用于缩放整个画布，一直适用于屏幕。仅在Screen Space模式下可用

Canvas.sortingLayerID 排序层ID
画布排序层的唯一ID

Canvas.sortingLayerName 排序层名
画布排序层的名称

Canvas.sortingOrder 排序顺序
画布在排序层里的顺序

Canvas.targetDisplay 目标显示
在Overlay模式下，UI画布将会出现显示索引

Canvas.worldCamera
在Screen Space - Camera模式下相机用来调整画布的尺寸。也用作发送事件到画布的世界空间

CanvasGroup 画布组

依附于GameObjects下的基础类
注意你的代码不能直接创建组件。而是写脚本代码并将其依附于一个GameObject上

CanvasGroup.alpha 透明度
设置该组的透明度。

CanvasGroup.blocksRaycasts 忽略投射
该组是否忽略投射（允许碰撞）

CanvasGroup.ignoreParentGroups 忽略父物体组
是否忽略父物体组？

如果该属性设置为true将会忽略任何父物体的设置

CanvasGroup.interactable 交互作用
是否打开交互(在该组之下启用该元素)

CanvasGroup.IsRaycastLocationValid 投射是否有效
如果该组允许投射返回true。

CanvasRenderer 画布渲染

当你添加画布时用于所有正常渲染完成之后渲染屏幕的组件。设计用于GUI应用

CanvasRenderer.absoluteDepth 绝对深度
相对于根画布的渲染器的深度

CanvasRenderer.AddUIVertexStream 添加UI顶点流
获得顶点流和分离它对应的数组(位置，颜色， uv0s, uv1s,法线和切线)

CanvasRenderer.Clear 清除
移除所有的顶点缓存

CanvasRenderer.CreateUIVertexStream 创建UI顶点流
将顶点组件转换为UIVertex流数据

CanvasRenderer.cull 剔除
表明是否忽略被渲染的几何体

CanvasRenderer.DisableRectClipping 禁用矩形裁剪
禁用矩形裁剪。

CanvasRenderer.EnableRectClipping 启用矩形裁剪
在CanvasRendered中启用矩形裁剪。指定矩形外的几何图形将会被裁剪(渲染前)

CanvasRenderer.GetAlpha 获取透明度
获取当前渲染器的透明度

CanvasRenderer.GetColor 获取颜色
获取当前的渲染器的颜色

CanvasRenderer.GetMaterial 获取材质
获取分配给 CanvasRenderer的当前材质

CanvasRenderer.GetPopMaterial 获取出栈材质
获取分配给CanvasRenderer的当前材质。用于蒙版内部

CanvasRenderer.hasMoved
如果发生任何改变，几何体的位置可能是无效的，返回true。

CanvasRenderer.hasPopInstruction 是否出站指令
启用 ‘render stack’出栈绘制调用

当渲染层级使用渲染时插入一个“pop”。在所有子物体渲染完成后该出栈指令被执行。该画布渲染器使用形成的出栈材质渲染

CanvasRenderer.hasRectClipping 矩形裁剪
如果在该渲染中矩形裁剪被启用返回true

CanvasRenderer.materialCount 材质数量
用于该渲染器的材质的数量

CanvasRenderer.popMaterialCount 出栈材质数量
用于该渲染器的材质数量。使用于图层蒙版的内部

CanvasRenderer.relativeDepth 相对深度
相对于父画布的深度

CanvasRenderer.SetAlpha 设置透明度
设置渲染的透明度。将会与UIVertex的透明度和Canvas的透明度相乘

CanvasRenderer.SetColor 设置颜色
设置渲染颜色。将会与UIVertex颜色和Canvas颜色相乘

CanvasRenderer.SetMaterial 设置材质
设置画布渲染的材质。如果指定一个材质那么它将用该画布的’MainTex’替代原材质的’MainTex’

CanvasRenderer.SetMesh 设置网格
设置该渲染使用的网格

CanvasRenderer.SetPopMaterial 设置出栈材质
设置该画布的渲染材质。用于蒙版内部

CanvasRenderer.SetTexture 设置贴图
设置该渲染器的材质的贴图

CanvasRenderer.SplitUIVertexStreams 分离UI顶点流
给定 UIVertex列表，组件类型数据流它的分离

CapsuleCollider 胶囊碰撞器

CapsuleCollider.center 中心
胶囊的中心，基于物体的自身坐标空间

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //重设中心点到变换的位置
        collider.center = Vector3.zero;
    }
}

CapsuleCollider.direction 方向
胶囊的方向

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //使胶囊的高度沿着x轴
        collider.direction = 0;
    }
}

CapsuleCollider.height 高度
胶囊的高度，基于物体的自身空间

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        collider.height = 5;
    }
}

CapsuleCollider.radius 半径
球体的半径，基于物体的自身坐标

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        collider.radius = 1;
    }
}

CharacterController 角色控制器

用CharacterController组件，它包含Rigidbody组件的一些属性，就不用用Rigidbody组件了

character一般用于主角这类用户控制的物体，它不会受到scene的重力影响，不会被其他物体推。 

程序中可以使用它的move方法移动它，当他碰到静态物体时，会停下来，遇到动态物体时会推开他，当然，这些都是可以通过activegroup来控制的。group最多有32组。因为他是一个NxU32，并通过每一位代表一个组。 

move的一个参数用来告诉程序，character的当前状态。（collisionFlags） 

当他遇到物体的时候，如果设置了回调函数，系统会通过回调函数通知程序。。(NxControllerDesc.callback) 

character还有上楼梯模式，在某些高度的台阶，可以直接上去。(NxControllerDesc.stepOffset)

character还可以设置可以走上去的斜坡。（NxControllerDesc.slopeLimit）

由于character不受场景的重力影响，所以，用户要在move函数中自己添加重力因素，也就是说，character可以浮在空中，除非那里有其他activegroup物体。

CharacterController.center 中心
相对于变换位置的角色胶囊体的中心

将胶囊体的中心向上移动

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public CharacterController controller;
    public void Awake() 
    {
        controller = GetComponent<CharacterController>();
        controller.center = new Vector3(0, 1, 0);
    }
}

CharacterController.collisionFlags 碰撞标识
在最后的CharacterController.Move调用期间，胶囊体的哪个部分与周围环境相碰撞

using UnityEngine;
using System.Collections;

public class ExampleClass : MonoBehaviour {
    void Update() {
        CharacterController controller = GetComponent<CharacterController>();
        if ((controller.collisionFlags & CollisionFlags.Above) != 0)
            print("touched the ceiling");

    }
}

CharacterController.detectCollisions 检测碰撞
其他的刚体和角色控制器是否能够与本角色控制器相碰撞（默认值始终启用）

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public CharacterController c;
    public void Awake() 
    {
        c = GetComponent<CharacterController>();
        c.detectCollisions = false;
    }
}

CharacterController.height 高度
角色胶囊体的高度

设置控制器的高度为2.0

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public CharacterController controller;
    public void Awake() 
    {
        controller = GetComponent();
        controller.height = 2.0F;
    }
}

CharacterController.isGrounded 是否地面
在最后的移动角色控制器是否触碰地面？

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Update() 
    {
        CharacterController controller = GetComponent<CharacterController>();
        if (controller.isGrounded)
            print("We are grounded");

    }
}

CharacterController.Move 移动
一个更加复杂的运动函数，每次都绝对运动

这个脚本用箭头键向前移动和侧移角色控制器。
当按下空格键时，它跳起
确保把一个character controller组件附加到同一个游戏物体上
建议你每帧只调用一次Move或者SimpleMove

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public float speed = 6.0F;
    public float jumpSpeed = 8.0F;
    public float gravity = 20.0F;
    private Vector3 moveDirection = Vector3.zero;
    void Update() 
    {
        CharacterController controller = GetComponent<CharacterController>();
        if (controller.isGrounded) 
        {   //我们着地了，所以直接通过轴重新计算move direction。
            moveDirection = new Vector3(Input.GetAxis("Horizontal"), 0, Input.GetAxis("Vertical"));
            moveDirection = transform.TransformDirection(moveDirection);
            moveDirection *= speed;
            if (Input.GetButton("Jump"))
                moveDirection.y = jumpSpeed;
        }
        //应用重力
        moveDirection.y -= gravity * Time.deltaTime;
        //移动控制器
        controller.Move(moveDirection * Time.deltaTime);
    }
}

CharacterController.OnControllerColliderHit 控制碰撞器碰撞
当控制器碰撞一个正在运动的碰撞器时，OnControllerColliderHit 被调用

这个脚本推动所有的角色碰撞到的刚体

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public float pushPower = 2.0F;
    void OnControllerColliderHit(ControllerColliderHit hit) {
        Rigidbody body = hit.collider.attachedRigidbody;
        // 没有刚体
        if (body == null || body.isKinematic)
            return;
        // 我们不想推动在我们下边的物体
        if (hit.moveDirection.y < -0.3F)
            return;
        // 通过移动方向计算推动方向，我们只把物体推到两侧，从不向上和向下推
        Vector3 pushDir = new Vector3(hit.moveDirection.x, 0, hit.moveDirection.z);
        // 如果你知道你的角色移动的有多快，那么你也可以用它乘以推动速度
        // 应用推力
        body.velocity = pushDir * pushPower;
    }
}

CharacterController.radius 半径
角色胶囊体的半径

设置控制器的半径为0.3

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public CharacterController controller;
    public void Awake() 
    {
        controller = GetComponent<CharacterController>();
        controller.radius = 0.3F;
    }
}

CharacterController.SimpleMove 简单移动
以一定的速度移动角色

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public float speed = 3.0F;
    public float rotateSpeed = 3.0F;
    void Update() 
    {
        CharacterController controller = GetComponent<CharacterController>();
        //围绕Y轴旋转
        transform.Rotate(0, Input.GetAxis("Horizontal") * rotateSpeed, 0);
        //向前后移动
        Vector3 forward = transform.TransformDirection(Vector3.forward);
        float curSpeed = speed * Input.GetAxis("Vertical");
        controller.SimpleMove(forward * curSpeed);
    }
}

CharacterController.slopeLimit 坡度限制
角色控制器的坡度度数限制

设置控制器的坡度限制为45.0度

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public CharacterController controller;
    public void Awake() 
    {
        controller = GetComponent<CharacterController>();
        controller.slopeLimit = 45.0F;
    }
}

CharacterController.skinWidth
人物的皮肤碰撞宽度。

指定的字符周围皮肤接触会产生的物理引擎。用它来避免数值精度问题

CharacterController.stepOffset 台阶偏移量
以米为单位的角色控制器的台阶偏移量
台阶高度，步高

设置控制器的台阶高度

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public CharacterController controller;
    public void Awake() 
    {
        controller = GetComponent();
        controller.stepOffset = 2.0F;
    }
}

CharacterController.velocity 速度
角色当前的相对速度

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void Update() {
        CharacterController controller = GetComponent<CharacterController>();
        Vector3 horizontalVelocity = controller.velocity;
        horizontalVelocity = new Vector3(controller.velocity.x, 0, controller.velocity.z);
        //忽略Y轴的X-Z平面上的速度
        float horizontalSpeed = horizontalVelocity.magnitude;
        //重力或者跳跃引起的速度
        float verticalSpeed = controller.velocity.y;
        //总体速度
        float overallSpeed = controller.velocity.magnitude;
    }
}

CharacterInfo 字符信息 miss

字体纹理如何渲染字符的规格

CharacterJoint 角色关节

角色关节主要用于布娃娃效果它们是一个扩展的球窝状关节，允许你在每个轴上限制关节

CharacterJoint.enableProjection 启用投射
投射不是一个物理进程并且不保护动量或者遵守几何碰撞。它最好避开真实的情况，但是在关节分离导致的不可接受的情况下可用于提高仿真的质量

CharacterJoint.highTwistLimit 旋转上限
角色关节围绕原始轴的上限

CharacterJoint.lowTwistLimit 旋转下限
角色关节围绕原始轴的下限

CharacterJoint.projectionAngle 投射角
设置投影角公差阈值(单位度)。

CharacterJoint.projectionDistance 投射距离
设置投射的线性差值阀值。

CharacterJoint.swing1Limit 旋转限制1
角色关节围绕原始轴的限制

CharacterJoint.swing2Limit 旋转限制2

CharacterJoint.swingAxis 旋转轴
旋转关节周围的二级坐标轴

CharacterJoint.swingLimitSpring 旋转极限弹簧
依附于关节旋转限制的弹性结构

CharacterJoint.twistLimitSpring 扭曲限制弹簧
依附于关节扭曲限制的弹性结构

CircleCollider2D 2D圆碰撞器

CircleCollider2D.radius 半径
圆的半径。

Cloth 布料

用来模拟物理布料的基类，通过InteractiveCloth和SkinnedCloth共享

Cloth.bendingStiffness 抗弯硬度
布料的抗弯硬度（坚挺的程度）

设置布料的bending Stiffness为1
可以是Skinned Cloth或者Interactive Cloth

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        transform.GetComponent<Cloth>().bendingStiffness = 1;
    }
}

Cloth.capsuleColliders 胶囊碰撞体列表
将与该布料实例进行碰撞的胶囊碰撞体的数组

Cloth.ClearTransformMotion 清除变换运动
从影响布料模拟改变中清除未定的变换

当布料的变换改变时，该布料不会立即跟随改变，恰恰相反，SkinnedMeshRenderer的顶点的新的位置将会通过配置约束下次更新布料模拟影响布料，因此移除改变换将会使布料运动更加逼真

Cloth.coefficients 系数
布料蒙皮系数用于设置布与蒙皮网格的交互

Cloth.collisionMassScale 碰撞质量缩放
碰撞粒子的系数增加多少

Cloth.damping 阻尼
减少布料的平滑
设置该值去减少布料实例的平滑。该值必须在0~1之间。设置该值为0将会禁用布料平滑

设置布料的damping为1
可以是Skinned Cloth或者Interactive

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        transform.GetComponent<Cloth>().damping = 1;
    }
}

Cloth.enabled 启用?
是否启用这个布料？

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        GetComponent<InteractiveCloth>().enabled = false;
    }
}

Cloth.externalAcceleration 外力
施加于布料的外力，一个恒量

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //使布料下落时，受到一半的重力（如果是受重力影响）
        transform.GetComponent<Cloth>().externalAcceleration = -Physics.gravity / 2;
    }
}

Cloth.friction 摩擦力
当角色碰撞时布料的摩擦力

Cloth.normals 法线列表
当前布料物体的法线列表

Cloth.randomAcceleration 随机外力
施加于布料的外力，一个随机变量

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   //模仿来自X轴向上的风 
        transform.GetComponent<Cloth>().randomAcceleration = new Vector3(10, 0, 0);
    }
}

Low Cloth.selfCollision 自身碰撞
是否产生自身碰撞

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        GetComponent<InteractiveCloth>().selfCollision = false;
    }
}

Cloth.SetEnabledFading 设置启用淡入淡出
淡入淡出的布料模拟

Cloth.sleepThreshold 休眠阈值
休眠阀值是布料粒子的线性速度，低于该值整块布料将会进入休眠

Cloth.solverFrequency 求解频率
每秒迭代求解次数

Cloth.sphereColliders 球形碰撞体列表
将要与布料实例发生碰撞的布料碰撞球对的列表数组

Cloth.stretchingStiffness 韧度
布料的韧性（可拉伸的程度）
必须大于0，或小于等于1。在大多数情况下，当你想要一块比较硬的布料，实际上可以减少布料的顶点数，会得到更好的效果和性能

设置布料的stretching Stiffness为1
可以是Skinned Cloth或者Interactive

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        transform.GetComponent<Cloth>().stretchingStiffness = 1;
    }
}

Low Cloth.thickness 厚度
布料表面的厚度

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {
        transform.GetComponent<Cloth>().thickness = 0.2F;
    }
}

Cloth.useContinuousCollision 使用连续碰撞
启用连续碰撞提高碰撞的稳定性

Cloth.useGravity 使用重力
是否重力影响布料模拟？

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   // 使布料不受重力的影响
        transform.GetComponent<Cloth>().useGravity = false;
    }
}

Cloth.useVirtualParticles 使用虚拟粒子
每个三角添加一个虚拟粒子提高碰撞稳定性

Cloth.vertices 顶点列表
当前布料物体的顶点位置列表

Cloth.worldAccelerationScale 世界外力范围
影响布料顶点的角色外力的世界空间的的范围大小

Cloth.worldVelocityScale 世界速度范围
将要影响布料顶点的角色运动的世界空间的范围大小

Low ClothRenderer 布料渲染器

ClothRenderer组件和InteractiveCloth 组件配合使用，在场景中使一个布料物体可见

ClothRenderer.pauseWhenNotVisible 不可见时暂停
在ClothRenderer不可见的时，暂停布料模拟

如果这个属性开启，布料只会在任意相机中可见时模拟。这样可改善物理模拟的性能

pauseWhenNotVisible = true;

ClothSkinningCoefficient 布料蒙皮系数

ClothSkinningCoefficient结构用于设置SkinnedCloth组件允许如何移动，有关SkinnedMeshRenderer是附加的

ClothSkinningCoefficient.collisionSphereDistance 碰撞球体距离
定义一个球体的一个顶点不允许进入这允许反向碰撞动画布料(**??)

Low ClothSkinningCoefficient.collisionSphereRadius 碰撞球体半径
定义一个球体的一个顶点不允许进入这允许反向碰撞动画布料

ClothSkinningCoefficient.maxDistance 最大距离
一个点是允许从蒙皮网格点位置运动的距离

SkinnedCloth组件确保布料顶点从蒙皮网格点位置逗留在最大距离内，如果最大距离为0，顶点将不模拟，但是设置到蒙皮网格顶点位置。这个行为是用于附加布料顶点到动画角色的皮肤。默认：0.2 范围 [0,inf]

Low ClothSkinningCoefficient.maxDistanceBias 最大距离偏移
通过基于蒙皮网格法线的最大距离，变形定义的球体

ClothSphereColliderPair 布料球碰撞器对

一对球碰撞体用于定义布料物体的反向碰撞的形状

ClothSphereColliderPair.first 第一个
球碰撞器对的第一个球碰撞体

ClothSphereColliderPair.second 第二个
球碰撞器对的第二个碰撞体

ClothSphereColliderPair.ClothSphereColliderPair 球碰撞器对
创建一个球碰撞器对。如果只给定一个碰撞球，ClothSphereColliderPair将会定义一个简单的球。如果给定二个碰撞球，ClothSphereColliderPair定义了一个圆锥形，ClothSphereColliderPair包含了二个球和圆锥这两个组成

ClusterInput 集群输入 miss

在Unity中集群的读写输入的接口

ClusterNetwork 集群网络 miss

一个辅助类,其中包含静态方法查询unity集群的状态

Collider 碰撞器

Collider.attachedRigidbody 附加刚体
碰撞器附加的刚体

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   // Lift the rigidbody attached to the collider.
        //升起附加在碰撞器的刚体
        collider.attachedRigidbody.AddForce(0, 100, 0);
    }
}

Collider.bounds 包围盒
碰撞器在世界坐标空间的包围盒

Collider.ClosestPointOnBounds 到包围盒最近点
到附加碰撞器的包围盒最近的点

当应用于爆炸伤害，这能用于计算伤害点数

var hitPoints : float = 100.0;
function ApplyHitPoints (explosionPos : Vector3, radius : float) {
    // The distance from the explosion position to the surface of the rigidbody
    //从爆炸点到刚体表面的距离
    var closestPoint : Vector3 = collider.ClosestPointOnBounds(explosionPos);
    var distance : float = Vector3.Distance(closestPoint, explosionPos);
    // The hit points we apply fall decrease with distance from the hit point
    //伤害点数，我们使到伤害点距离减少
    var hitPoints : float = 1.0 - Mathf.Clamp01(distance / radius);
    // This is the final hitpoints we want to apply. 10 at maximum
    //这是我们想要的最终伤害点数为10
    hitPoints *= 10;
}

Collider 碰撞器
所有碰撞器的基类（鸡肋）

Collider.isTrigger 是触发器？
碰撞器是一个触发器？

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   // Turns the attached to collider into a trigger
        //转换附加的碰撞器为一个触发器
        collider.isTrigger = true;
    }
}

Collider.material 材质
碰撞器使用的材质

如果材质被碰撞器共享，它将复制材质并指定给碰撞器

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   // Makes the collider act like ice.
        //让碰撞器像冰一样（滑动摩擦&&静摩擦==0）
        collider.material.dynamicFriction = 0;
        collider.material.staticFriction = 0;
    }
}

Collider.OnCollisionEnter 进入碰撞
当collider/rigidbody开始触动另一个rigidbody/collider时OnCollisionEnter被调用
如果碰撞器附加一个非动力学刚体，也仅发送碰撞事件

例一

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnCollisionEnter(Collision collision) 
    {   // Debug-draw all contact points and normals
        //调试绘制全部的接触点和法线
        foreach (ContactPoint contact in collision.contacts) 
        {
            Debug.DrawRay(contact.point, contact.normal, Color.white);
        }
        // Play a sound if the coliding objects had a big impact.
        //如果碰撞物体有一个更大的撞击就播放声音
        if (collision.relativeVelocity.magnitude > 2)
            audio.Play();

    }
}

例二
一个手榴弹
A grenade
一个手榴弹
- instantiates a explosion prefab when hitting a surface
当撞击表面时实例化一个爆炸预设
- then destroys itself
然后销毁它们

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public Transform explosionPrefab;
    void OnCollisionEnter(Collision collision) 
    {   // Rotate the object so that the y-axis faces along the normal of the surface
        //旋转物体，以便y轴方向沿着表面的法线
        ContactPoint contact = collision.contacts[0];
        Quaternion rot = Quaternion.FromToRotation(Vector3.up, contact.normal);
        Vector3 pos = contact.point;
        Instantiate(explosionPrefab, pos, rot);
        // Destroy the projectile
        //销毁炮弹
        Destroy(gameObject);
    }
}

Collider.OnCollisionExit 退出碰撞

当 collider/rigidbody停止触动另一个 rigidbody/collider时，OnCollisionExit被调用
如果碰撞器附加一个非动力学刚体，也仅发送碰撞事件

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnCollisionExit(Collision collisionInfo) 
    {
        print("No longer in contact with " + collisionInfo.transform.name);
    }
}

Collider.OnCollisionStay 逗留碰撞
一个碰撞器或刚体触动另一个刚体或碰撞器，在每帧都会调用OnCollisionStay，直到它们之间离开，不接触
如果碰撞器附加一个非动力学刚体，也仅发送碰撞事件

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnCollisionStay(Collision collisionInfo) 
    {   // Debug-draw all contact points and normals
        //调试绘制全部接触点和法线
        foreach (ContactPoint contact in collisionInfo.contacts) 
        {
            Debug.DrawRay(contact.point, contact.normal * 10, Color.white);
        }
    }
}

Collider.OnTriggerEnter 进入触发器
当碰撞器other进入触发器时OnTriggerEnter被调用
假如一个碰撞物体同时带有一个刚体属性
那么只发送这个触发事件

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnTriggerEnter(Collider other) 
    {   // Destroy everything that enters the trigger
        //当进入触发器销毁所有物体
        Destroy(other.gameObject);
    }
}

Collider.OnTriggerExit 退出触发器
当碰撞器离开触发器时，调用OnTriggerExit
假如一个碰撞物体同时带有一个刚体属性
那么只发送这个触发事件

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnTriggerExit(Collider other) 
    {   // Destroy everything that leaves the trigger
        //离开触发器时，销毁所有物体
        Destroy(other.gameObject);
    }
}

Collider.OnTriggerStay 逗留触发器
每个碰撞器从进入触发器那一刻到退出触发器之前，几乎每帧都会调用OnTriggerStay
假如一个碰撞物体同时带有一个刚体属性
那么只发送这个触发事件
OnTriggerStay是在每一个Time.fixedDeltaTime的时间节点上运行，不是Time.deltaTime的时间节点上运行

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnTriggerStay(Collider other) 
    {   // Applies an upwards force to all rigidbodies that enter the trigger.
        //进入触发器给所有的刚体应用向上的力
        if (other.attachedRigidbody)
            other.attachedRigidbody.AddForce(Vector3.up * 10);
    }
}

Collider.Raycast 光线投射
投射一个光线（Ray），它忽略所有碰撞器，除了这个

// pragma below is needed due to a UnityJS issue
//下面的代码运行于js
#pragma strict

function Update()
{
    var ray : Ray = Camera.main.ScreenPointToRay (Input.mousePosition);
    var hit : RaycastHit;
    if (collider.Raycast (ray, hit, 100.0)) 
    {
        Debug.DrawLine (ray.origin, hit.point);
    }
}

Collider.sharedMaterial 共享材质
碰撞器的共享物理材质

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public PhysicMaterial material;
    public void Awake() 
    {
        collider.sharedMaterial = material;
    }
}

Collision 碰撞

Collision.collider 碰撞器
我们碰撞的碰撞器

Collision.contacts 接触点列表
接触点由物理引擎产生

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnCollisionStay(Collision collision) 
    {   // Check if the collider we hit has a rigidbody
        // Then apply the force
        //检查如果碰撞的碰撞器有刚体，然后应用力
        foreach (ContactPoint contact in collision.contacts) 
        {
            print(contact.thisCollider.name + " hit " + contact.otherCollider.name);
            // Visualize the contact point
            //可视化接触点
            Debug.DrawRay(contact.point, contact.normal, Color.white);
        }
    }
}

Collision.gameObject 游戏物体
gameObject是我们碰撞的物体

Collision 碰撞
描述碰撞

Collision.relativeVelocity 相对速度
两个碰撞物体的相对线性速度

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnCollisionEnter(Collision collision) 
    {   // Play a sound when we hit an object with a big velocity
        //当以一个较大的速度碰到物体时，播放声音
        if (collision.relativeVelocity.magnitude > 2)
            audio.Play();
    }
}

Collision.rigidbody 刚体
我们碰撞的刚体如果我们碰撞的物体是一个没有附加刚体的碰撞器，返回null

Make all rigidbodies we touch fly upwards
使我们接触的全部刚体向上飞

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    void OnCollisionStay(Collision collision) 
    {   // Check if the collider we hit has a rigidbody
        //检查如果我们接触的碰撞器是一个刚体
        if (collision.rigidbody)
            // Then apply the force
            //然后应用力
            collision.rigidbody.AddForce(Vector3.up * 15);
    }
}

Collision.transform 变换
我们碰撞的物体的Transform

Color 颜色

Color.a 透明
颜色中的Alpha组件

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public Color color = Color.white;
    public void Awake() 
    {
        color.a = 0;
    }
}

Color.b 蓝色
三基色之一的蓝色通道

Color.g 绿色
三基色之一的绿色通道

Color.r 红色
三基色之一的红色通道

Color.black 黑色
纯黑色 RGBA 是 (0, 0, 0, 1)

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public void Awake() 
    {   // Assign a black color to this transform's material
        // 赋一个黑色给这个变换的材质
        transform.renderer.material.color = Color.black;
    }
}

Color.blue 蓝色
纯蓝色 RGBA 是(0, 0, 1, 1)

Color.clear 清空
完全透明 RGBA 是 (0, 0, 0, 0)

Color.Color 颜色
用给定的r,g,b,a组件构造一个新的颜色

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public Color color = new Color(0.2F, 0.3F, 0.4F, 0.5F);
}

Color.cyan 青色
青色 RGBA 是 (0, 1, 1, 1)

Color.gray 灰色 || Color.grey 灰色
灰色 RGBA 是 (0.5, 0.5, 0.5, 1)

Color.grayscale 灰度
颜色的灰度值

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public Color color = new Color(0.3F, 0.4F, 0.6F);
    public void Awake() 
    {
        print(color.grayscale);
    }
}

Color.green 绿色
纯绿色 RGBA 是 (0, 1, 0, 1)

Color.magenta 紫红色
紫红色 RGBA 是 (1, 0, 1, 1)

Color.red 红色
纯红色 RGBA 是 (1, 0, 0, 1)

Color.white 白色
纯白色 RGBA 是 (1, 1, 1, 1)

Color.yellow 黄色
黄色。 RGBA 是怪异的 (1, 235/255, 4/255, 1) ，但是颜色看起来漂亮！

Color.this [int index] 访问索引
分别用[0],[1],[2],[3]访问r,g,b,a组件

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public Color p;
    public void Awake() 
    {
        p[1] = 5;
        // the same as p.g = 5
        // 等同于 p.g = 5 
    }
}

Color.Lerp 插值
通过t在颜色a和b之间插值

Converts a white color to a black one trough time.
在一个时间段内将白色逐渐转换成黑色

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    public Color lerpedColor = Color.white;
    void Update() 
    {
        erpedColor = Color.Lerp(Color.white, Color.black, Time.time);
    }
}

Color.operator + 运算符加法
两个颜色相加，每个组件被分别相加

using UnityEngine;
using System.Collections;

public class example : MonoBehaviour {
    // blue + red = magenta
    //蓝色+红色=紫红色
    public Color result = Color.blue + Color.red;
}

Color.operator Color 运算符颜色 miss
Color.operator /运算符除法 miss
Color.operator * 运算符乘法 miss
Color.operator - 运算符减法 miss
Color.operator Vector4 运算符四维向量 miss
Color.ToString 转为字符串 miss

CombineInstance 合并实例

CombineInstance 合并实例
用来描绘网格合并的结构，使用Mesh.CombineMeshes

CombineInstance.mesh 网格
网格合并

CombineInstance.subMeshIndex 子网格索引
网格的子网格索引

CombineInstance.transform 变换
合并之前，网格变换的矩阵