C# Camera

Camera 摄像机

Camera是一个设备，玩家通过它看世界

Camera.actualRenderingPath 实际渲染路径

实际使用的渲染路径

RenderingPath actualRenderingPath;

Camera.allCameras 所有相机

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

public int count = Camera.allCameras.Length;

void Example() {

    print ("we've got" + count + "cameras");

}

Camera.allCamerasCount 所有相机数量

当前场景中相机数量

var count : int = Camera.allCamerasCount;

print ("we've got" + count + "cameras");

Camera.aspect 长宽比

长宽比

if (camera.aspect > 1.0F)

    print("Screen is more wide than tall!");

else

    print("Screen is more tall than wide!");

Camera.backgroundColor 背景颜色

屏幕将被清理为这个颜色

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

}

void Example() {

    camera.clearFlags = CameraClearFlags.SolidColor;

}

Camera.CalculateObliqueMatrix 计算倾斜矩阵

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

Matrix4x4 CalculateObliqueMatrix(Vector4 clipPlane);

Camera.cameraToWorldMatrix 相机转世界矩阵

从相机空间到世界空间的变换矩阵

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.clearFlags 清除标识(可理解为背景填充)

相机如何清除背景

camera.clearFlags = CameraClearFlags.SolidColor;

Camera.CopyFrom 复制到

使这个相机的设置与其他相机相同

camera.CopyFrom(Camera.main);

Camera.current 当前相机

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

static Camera current;

Camera.depth 深度

相机在渲染顺序上的深度

camera.depth = Camera.main.depth + 1;

Camera.depthTextureMode 深度纹理模式

相机生成怎样的一个深度纹理

public void Awake() {

    camera.depthTextureMode = DepthTextureMode.DepthNormals;

}

Camera.eventMask 事件遮挡

遮挡相机的触发事件图层

int eventMask;

Camera.farClipPlane 远裁剪平面

远裁剪面的距离

camera.farClipPlane = 100.0F;

Camera.fieldOfView 视野

相机的视野，以度为单位

public void Awake() {

    camera.fieldOfView = 60;

}

Camera.GetAllCameras 获取所有相机

用当前场景中的摄像机填补相机的数组，而不需要分配一个新的数组

static int GetAllCameras(Camera[] cameras);

Camera.hdr 高动态范围

高动态范围渲染

bool hdr;

Camera.layerCullDistances 层消隐距离

每层的消隐距离

void Start() {

    float[] distances = new float[32];

    distances[10] = 15;

    camera.layerCullDistances = distances;

}

Camera.layerCullSpherical 球面层消隐

相机如何执行每层的消隐

camera.layerCullSpherical = true;

Camera.main 主相机

第一个启用的被标记为“MainCanmera”的相机

static Camera main;

Camera.nearClipPlane 近裁剪平面

近裁剪面的距离

camera.nearClipPlane = 0.1F;

Camera.OnPostRender() 渲染之后

OnPostRender函数在相机渲染场景之后调用

private bool revertFogState = false;

void OnPreRender() {

    reverFogState = RenderSettings.fog;

    RenderSettings.fog = enabled;

}

void OnPostRender() {

    RenderSettings.fog = revertFogState;

}

Camera.OnPreCull() 消隐之前

OnPreCull在相机开始裁剪场景之前调用

void OnPreCull() {

    camera.ResetWorldToCameraMatrix();

    camera.ResetProjectionMatrix();

    camera.projectionMatrix = camera.projectionMatrix * Matrix4x4.Scale(new Vector3(1, -1, 1));

}

void OnPreRender() {

    GL.SetRevertBackfacing(true);

}

void OnPostRender() {

    GL.SetRevertBackfacing(false);

}

Camera.OnRenderImage(RenderTexture,RenderTexture) 在渲染图像之后

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

public Material mat;

void OnRenderImage(RenderTexture src, RenderTexture dest) {

    Graphics.Blit(src, dest, mat);

}

Camera.OnRenderObject() 在渲染物体之后

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

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

Camera.orthographic 正交

相机是正交的（true），是透视的（false）

camera.orthographic = true;

Camera.orthographicSize 正交大小

camera.orthographic = true;

camera.orthographicSize = 5;

Camera.pixelHeight 相机高度

相机有多高，以像素单位

print("Camera is " + camera.pixelHeight + " pixels high");

Camera.pixelRect 像素矩形

相机被渲染到屏幕像素中的位置

void Update() {

    Rect r = camera.pixelRect;

    print("Camera displays from " + r.xMin + " to " + r.xMax + " pixel");

}

Camera.pixelWidth 相机宽度

相机有多宽，以像素单位

print("Camera is " + camera.pixelWidth + " pixels wide");

Camera.projectionMatrix 投影矩阵

设置自定义的投影矩阵

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;

}

void Example() {

    originalProjection = camera.projectionMatrix;

}

Camera.rect 矩形

相继被渲染到屏幕规范化坐标中的位置

function Update () {

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

        var margin = Random.Range (0.0, 0.3);

        camera.rect = Rect (margin, 0, 1 - margin * 2, 1);

    }

}

Camera.Render 渲染

手动渲染相机

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 渲染路径

渲染路径

RenderingPath renderingPath;

Camera.RenderToCubemap 渲染到立方图

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

bool RenderToCubemap(Cubemap cubemap, int faceMask = 63);

Camera.RenderWithShader 用Shader渲染

用shader替代渲染相机

public Shader heatVisionShader;

void Example() {

    camera.RenderWithShader(heatVisionShader, "VisibleWithHeatVision");

}

Camera.ResetAspect 重设长宽比

恢复长宽比为屏幕的长宽比

void Example() {

    camera.ResetAspect();

}

Camera.ResetProjectionMatrix 重设投影矩阵

让投影反映正常的相机参数

void Example() {

    camera.ResetProjectionMatrix();

}

Camera.ResetReplacementShader 重设替换Shader

从相机上移除shader替换

void ResetReplacementShader();

Camera.ResetWorldToCameraMatrix 重设世界转相机矩阵

在场景中让渲染位置反射相机的位置

void Example() {

    camera.ResetWorldToCameraMatrix();

}

Camera.ScreenPointToRay 屏幕位置转射线

返回一条射线从摄像机通过一个屏幕点

void Update() {

    Ray ray = camera.ScreenPointToRay(new Vector3(200, 200, 0));

    Debug.DrawRay(ray.origin, ray.direction * 10, Color.yellow);

}

Camera.ScreenToViewportPoint 屏幕转视窗位置

从屏幕空间到视窗空间的变换位置

void Update() {

    transform.position = Camera.main.ScreenToViewportPoint(Input.mousePosition);

}

Camera.ScreenToWorldPoint 屏幕转世界位置

从屏幕空间到世界空间的变化位置

void OnDrawGizmosSelected() {

    Vector3 p = camera.ScreenToWorldPoint(new Vector3(100, 100, camera.nearClipPlane));

    Gizmos.color = Color.yellow;

    Gizmos.DrawSphere(p, 0.1F);

}

Camera.ResetReplacementShader 设置替换着色器

使相机渲染用着色器替换

public Shader heatVisionShader;

void Example() {

    camera.SetReplacementShader(heatVisionShader, "VisibleWithHeatVision");

}

Camera.SetTargetBuffers 设置目标缓冲区域

设置相机渲染到一个或多个RenderTextures所选择的缓冲区

void SetTargetBuffers(RenderBuffer colorBuffer, RenderBuffer depthBuffer);

Camera.stereoConvergence 立体聚焦

虚拟视点相交点间距

float stereoConvergence;

Camera.stereoEnabled 开启立体

立体渲染

bool stereoEnabled;

Camera.stereoSeparation 立体分离

虚拟眼间距离

float stereoSeparation;

Camera.targetTexture 目标纹理

描述渲染纹理

RenderTexture targetTexture;

Camera.transparencySortMode 透明物体排序模式

透明物体的排序模式

TransparencySortMode transparencySortMode;

Camera.useOcclusionCulling 使用遮挡剔除

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

bool useOcclusionCulling;

Camera.velocity 速度

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

void Update() {

    print("Camera moving at " + camera.velocity.magnitude + " m/s");

}

Camera.ViewportPointToRay 视窗位置转射线

返回从相机出发穿过视点的一个射线

void Update() {

Ray ray = camera.ViewportPointToRay(new Vector3(0.5F, 0.5F, 0));

RaycastHit hit;

if (Physics.Raycast(ray, out hit))

    print("I'm looking at " + hit.transform.name);

else

    print("I'm looking at nothing!");

}

Camera.ViewportToScreenPoint 视窗转屏幕位置

从视口空间到屏幕空间的变换位置

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 视窗转世界位置

从视窗空间到世界空间的变换位置

void OnDrawGizmosSelected() {

    Vector3 p = camera.ViewportToWorldPoint(new Vector3(1, 1, camera.nearClipPlane));

    Gizmos.color = Color.yellow;

    Gizmos.DrawSphere(p, 0.1F);

}

Camera.worldToCameraMatrix 世界转相机矩阵

从世界到相机空间的变换矩阵

public Vector3 offset = new Vector3(0, 1, 0);

void LateUpdate() {

    Vector3 camoffset = new Vector3(-offset.x, -offset.y, offset.z);

    Matrix4x4 m = Matrix4x4.TRS(camoffset, Quaternion.identity, new Vector3(1, 1, -1));

    camera.worldToCameraMatrix = m * transform.worldToLocalMatrix;

}

Camera.WorldToScreenPoint 世界转屏幕位置

从世界空间到屏幕空间变换位置

public Transform target;

void Update() {

    Vector3 screenPos = camera.WorldToScreenPoint(target.position);

    print("target is " + screenPos.x + " pixels from the left");

}

Camera.WorldToViewportPoint 世界转视窗位置

从世界空间到视窗空间的变换位置

public Transform target;

void Update() {

    Vector3 viewPos = camera.WorldToViewportPoint(target.position);

    if (viewPos.x > 0.5F)

        print("target is on the right side!");

    else

        print("target is on the left side!");

}

Camera.cullingMask 消隐遮罩

这个用来选择性的渲染部分场景

public void Awake() {

    camera.cullingMask = 1 << 0;

}