写给VR手游开发小白的教程：（二）UnityVR插件CardboardSDKForUnity解析（一）

现在我们已经有了开发环境，还没安装环境的小伙伴可以看上一篇：

（一）Unity3D进行Android开发的环境搭建（虚拟机调试）

今天主要介绍的是谷歌为自己的Cardboard平台提供的开发工具Cardboard SDK插件解析。Cardboard是谷歌公司在14年发布的一款极具创意的产品，由手机内部的传感器支持，它仅需硬纸板和两片透镜就能打造移动平台上的VR体验。Cardboard这里不多做介绍，网上可以买到原装正版，价格在50以内很便宜，有条件的人可以去体验一下。

在正式开始之前，先说明一下本节需要对Unity3D引擎有一些基础才能较流畅的看完，若是中间有疑问可以评论也可私信，疑问较多也可以再补充一章专门介绍基础的东西。

上一章忘记说了，如果是VR应用的话，就不要在虚拟机里跑了（虚拟机根本没有传感器去定位你的头部，也就不存在VR一说了，不过简单的小游戏还是可以在虚拟机上跑的，所以如果是跑大型应用的话，还是选择真机吧），虚拟机的存在其实纯粹是为了学习示例用的。

没有真机的同学，这个demo在Unity里也可以跑，具体按住Alt移动鼠标就相当于转动头部，按住Ctrl移动鼠标相当于歪脖子看。

/***************************************************************分割线*******************************************************************/

首先要为Unity安装这个插件，对于本插件，目前网上有些资源是不带demo的，正好我这边有一个带demo的，附上下载地址：

http://download.csdn.net/detail/mao_xiao_feng/9577849

导入以后，工程目录下多了以下两个文件夹，双击打开DemoScene下的场景

场景大概就是以下这个样子了，这个demo是插件中提供的官方示例，一定要把里面所有东西都研究透，才能很好理解SDK当中的每一个脚本的功能。

直接切入主题，看到CardboardMain这个物体已经被设为了Prefab，那么它一定是获得VR效果的关键性物体，事实上所有VR的实现都在这个物体极其子物体下，我们把它一层层的剥离开来。

CardboardMain物体上只绑定了这一个脚本，开始看源码

using UnityEngine;
using System;
using System.Collections;
using System.Collections.Generic;

// The Cardboard object communicates with the head-mounted display in order to:
// -  Query the device for viewing parameters
// -  Retrieve the latest head tracking data
// -  Provide the rendered scene to the device for distortion correction

public class Cardboard : MonoBehaviour {
  // The singleton instance of the Cardboard class.
  public static Cardboard SDK {
    get {
      if (sdk == null) {
        sdk = UnityEngine.Object.FindObjectOfType();
      }
      if (sdk == null) {
        Debug.Log("Creating Cardboard object");
        var go = new GameObject("Cardboard");
        sdk = go.AddComponent();
        go.transform.localPosition = Vector3.zero;
      }
      return sdk;
    }
  }
  private static Cardboard sdk = null;

  public bool DistortionCorrection {
    get {
      return distortionCorrection;
    }
    set {
      if (value != distortionCorrection && device != null) {
        device.SetDistortionCorrectionEnabled(value && NativeDistortionCorrectionSupported);
      }
      distortionCorrection = value;
    }
  }
  [SerializeField]
  private bool distortionCorrection = true;

  public bool VRModeEnabled {
    get {
      return vrModeEnabled;
    }
    set {
      if (value != vrModeEnabled && device != null) {
        device.SetVRModeEnabled(value);
      }
      vrModeEnabled = value;
    }
  }
  [SerializeField]
  private bool vrModeEnabled = true;

  public bool EnableAlignmentMarker {
    get {
      return enableAlignmentMarker;
    }
    set {
      if (value != enableAlignmentMarker && device != null) {
        device.SetAlignmentMarkerEnabled(value && NativeUILayerSupported);
      }
      enableAlignmentMarker = value;
    }
  }
  [SerializeField]
  private bool enableAlignmentMarker = true;

  public bool EnableSettingsButton {
    get {
      return enableSettingsButton;
    }
    set {
      if (value != enableSettingsButton && device != null) {
        device.SetSettingsButtonEnabled(value && NativeUILayerSupported);
      }
      enableSettingsButton = value;
    }
  }
  [SerializeField]
  private bool enableSettingsButton = true;

  public bool TapIsTrigger = true;

  public float NeckModelScale {
    get {
      return neckModelScale;
    }
    set {
      value = Mathf.Clamp01(value);
      if (!Mathf.Approximately(value, neckModelScale) && device != null) {
        device.SetNeckModelScale(value);
      }
      neckModelScale = value;
    }
  }
  [SerializeField]
  private float neckModelScale = 0.0f;

  public bool AutoDriftCorrection {
    get {
      return autoDriftCorrection;
    }
    set {
      if (value != autoDriftCorrection && device != null) {
        device.SetAutoDriftCorrectionEnabled(value);
      }
      autoDriftCorrection = value;
    }
  }
  [SerializeField]
  private bool autoDriftCorrection = true;

#if UNITY_IOS
  public bool SyncWithCardboardApp {
    get {
      return syncWithCardboardApp;
    }
    set {
      if (value && value != syncWithCardboardApp) {
        Debug.LogWarning("Remember to enable iCloud capability in Xcode, "
            + "and set the 'iCloud Documents' checkbox. "
            + "Not doing this may cause the app to crash if the user tries to sync.");
      }
      syncWithCardboardApp = value;
    }
  }
  [SerializeField]
  private bool syncWithCardboardApp = false;
#endif

#if UNITY_EDITOR
  // Mock settings for in-editor emulation of Cardboard while playing.
  public bool autoUntiltHead = true;

  // Whether to perform distortion correction in the editor.
  public bool simulateDistortionCorrection = true;

  // Use unity remote as the input source.
  [HideInInspector]
  public bool UseUnityRemoteInput = false;

  public CardboardProfile.ScreenSizes ScreenSize {
    get {
      return screenSize;
    }
    set {
      if (value != screenSize) {
        screenSize = value;
        device.UpdateScreenData();
      }
    }
  }
  [SerializeField]
  private CardboardProfile.ScreenSizes screenSize = CardboardProfile.ScreenSizes.Nexus5;

  public CardboardProfile.DeviceTypes DeviceType {
    get {
      return deviceType;
    }
    set {
      if (value != deviceType) {
        deviceType = value;
        device.UpdateScreenData();
      }
    }
  }
  [SerializeField]
  public CardboardProfile.DeviceTypes deviceType = CardboardProfile.DeviceTypes.CardboardJun2014;
#endif

  // The VR device that will be providing input data.
  private static BaseVRDevice device;

  public bool NativeDistortionCorrectionSupported { get; private set; }

  public bool NativeUILayerSupported { get; private set; }

  // The texture that Unity renders the scene to. This is sent to the VR device,
  // which renders it to screen, correcting for lens distortion.
  public RenderTexture StereoScreen {
    get {
      // Don't need it except for distortion correction.
      if (!distortionCorrection || !vrModeEnabled) {
        return null;
      }
      if (stereoScreen == null && NativeDistortionCorrectionSupported) {
        StereoScreen = CreateStereoScreen();  // Note: use set{}
      }
      return stereoScreen;
    }
    set {
      if (value == stereoScreen) {
        return;
      }
      if (!NativeDistortionCorrectionSupported && value != null) {
        Debug.LogError("Can't set StereoScreen: native distortion correction is not supported.");
        return;
      }
      if (stereoScreen != null) {
        stereoScreen.Release();
      }
      stereoScreen = value;
      if (stereoScreen != null && !stereoScreen.IsCreated()) {
        stereoScreen.Create();
      }
      if (device != null) {
        device.SetStereoScreen(stereoScreen);
      }
    }
  }
  private static RenderTexture stereoScreen = null;

  public bool UseDistortionEffect {
    get {
      return !NativeDistortionCorrectionSupported && distortionCorrection && vrModeEnabled
          && SystemInfo.supportsRenderTextures;
    }
  }

  // Describes the current device, including phone screen.
  public CardboardProfile Profile {
    get {
      return device.Profile;
    }
  }

  // Distinguish the stereo eyes.
  public enum Eye {
    Left,
    Right,
    Center
  }

  // When asking for project, viewport, etc, whether to assume viewing through
  // the lenses.
  public enum Distortion {
    Distorted,   // Viewing through the lenses
    Undistorted  // No lenses
  }

  // The transformation of head from origin in the tracking system.
  public Pose3D HeadPose {
    get {
      return device.GetHeadPose();
    }
  }

  // The transformation from head to eye.
  public Pose3D EyePose(Eye eye) {
    return device.GetEyePose(eye);
  }

  // The projection matrix for a given eye.
  public Matrix4x4 Projection(Eye eye, Distortion distortion = Distortion.Distorted) {
    return device.GetProjection(eye, distortion);
  }

  // The screen-space rectangle each eye should render into.
  public Rect Viewport(Eye eye, Distortion distortion = Distortion.Distorted) {
    return device.GetViewport(eye, distortion);
  }

  // The distance range from the viewer in user-space meters where objects
  // may be viewed comfortably in stereo.  If the center of interest falls
  // outside this range, the stereo eye separation should be adjusted to
  // keep the onscreen disparity within the limits set by this range.
  public Vector2 ComfortableViewingRange {
    get {
      return defaultComfortableViewingRange;
    }
  }
  private readonly Vector2 defaultComfortableViewingRange = new Vector2(1.0f, 100000.0f);

  private void InitDevice() {
    if (device != null) {
      device.Destroy();
    }
    device = BaseVRDevice.GetDevice();
    device.Init();

    List diagnostics = new List();
    NativeDistortionCorrectionSupported = device.SupportsNativeDistortionCorrection(diagnostics);
    if (diagnostics.Count > 0) {
      Debug.LogWarning("Built-in distortion correction disabled. Causes: ["
                       + String.Join("; ", diagnostics.ToArray()) + "]");
    }
    diagnostics.Clear();
    NativeUILayerSupported = device.SupportsNativeUILayer(diagnostics);
    if (diagnostics.Count > 0) {
      Debug.LogWarning("Built-in UI layer disabled. Causes: ["
                       + String.Join("; ", diagnostics.ToArray()) + "]");
    }

    device.SetVRModeEnabled(vrModeEnabled);
    device.SetDistortionCorrectionEnabled(distortionCorrection
        && NativeDistortionCorrectionSupported);
    device.SetAlignmentMarkerEnabled(enableAlignmentMarker
        && NativeUILayerSupported);
    device.SetSettingsButtonEnabled(enableSettingsButton
        && NativeUILayerSupported);
    device.SetNeckModelScale(neckModelScale);
    device.SetAutoDriftCorrectionEnabled(autoDriftCorrection);

    device.UpdateScreenData();
  }

  // NOTE: Each scene load causes an OnDestroy of the current SDK, followed
  // by and Awake of a new one.  That should not cause the underlying native
  // code to hiccup.  Exception: developer may call Application.DontDestroyOnLoad
  // on the SDK if they want it to survive across scene loads.
  void Awake() {
    if (sdk == null) {
      sdk = this;
    }
    if (sdk != this) {
      Debug.LogWarning("Cardboard SDK object should be a singleton.");
      enabled = false;
      return;
    }
#if UNITY_IOS
    Application.targetFrameRate = 60;
#endif
    InitDevice();
    AddDummyCamera();
    StereoScreen = null;
  }

  public event Action OnTrigger;

  public event Action OnTilt;

  public bool Triggered { get; private set; }

  public bool Tilted { get; private set; }

  private bool updated = false;

  private CardboardUILayer uiLayer = null;

  public void UpdateState() {
    if (!updated) {
      device.UpdateState();
      if (TapIsTrigger) {
        if (Input.GetMouseButtonUp(0)) {
          device.triggered = true;
        }
        if (Input.GetKeyUp(KeyCode.Escape)) {
          device.tilted = true;
        }
      }
      updated = true;
    }
  }

  private void DispatchEvents() {
    Triggered = device.triggered;
    Tilted = device.tilted;
    device.triggered = false;
    device.tilted = false;

    if (Tilted) {
      if (OnTilt != null) {
        OnTilt();
      }
    }
    if (Triggered) {
      if (OnTrigger != null) {
        OnTrigger();
      }
    }
  }

  private void AddDummyCamera() {
    var go = gameObject;
    if (go.GetComponent()) {
      go = new GameObject("CardboardDummy");
      go.transform.parent = gameObject.transform;
    }
    var cam = go.AddComponent();
    cam.clearFlags = CameraClearFlags.SolidColor;
    cam.backgroundColor = Color.black;
    cam.cullingMask = 0;
    cam.useOcclusionCulling = false;
    cam.depth = -100;
  }

  IEnumerator EndOfFrame() {
    while (true) {
      yield return new WaitForEndOfFrame();
      UpdateState();
      device.PostRender(vrModeEnabled);
      if (vrModeEnabled && !NativeUILayerSupported) {
        if (uiLayer == null) {
          uiLayer = new CardboardUILayer();
        }
        uiLayer.Draw();
      }
      DispatchEvents();
      updated = false;
    }
  }

  // Return a StereoScreen with sensible default values.
  public RenderTexture CreateStereoScreen() {
    return device.CreateStereoScreen();
  }

  // Reset the tracker so that the user's current direction becomes forward.
  public void Recenter() {
    device.Recenter();
  }

  // Set the screen coordinates of the mouse/touch event.
  public void SetTouchCoordinates(int x, int y) {
    device.SetTouchCoordinates(x, y);
  }

  void OnEnable() {
    device.OnPause(false);
    StartCoroutine("EndOfFrame");
  }

  void OnDisable() {
    StopCoroutine("EndOfFrame");
    device.OnPause(true);
  }

  void OnApplicationPause(bool pause) {
    device.OnPause(pause);
  }

  void OnApplicationFocus(bool focus) {
    device.OnFocus(focus);
  }

  void OnLevelWasLoaded(int level) {
    device.Reset();
  }

  void OnDestroy() {
    if (device != null) {
      device.Destroy();
    }
    if (sdk == this) {
      sdk = null;
    }
  }

  void OnApplicationQuit() {
    device.OnApplicationQuit();
  }

  //********* OBSOLETE ACCESSORS *********

  [System.Obsolete("Use DistortionCorrection instead.")]
  public bool nativeDistortionCorrection {
    get { return DistortionCorrection; }
    set { DistortionCorrection = value; }
  }

  [System.Obsolete("InCardboard is deprecated.")]
  public bool InCardboard { get { return true; } }

  [System.Obsolete("Use Triggered instead.")]
  public bool CardboardTriggered { get { return Triggered; } }

  [System.Obsolete("Use HeadPose instead.")]
  public Matrix4x4 HeadView { get { return HeadPose.Matrix; } }

  [System.Obsolete("Use HeadPose instead.")]
  public Quaternion HeadRotation { get { return HeadPose.Orientation; } }

  [System.Obsolete("Use HeadPose instead.")]
  public Vector3 HeadPosition { get { return HeadPose.Position; } }

  [System.Obsolete("Use EyePose() instead.")]
  public Matrix4x4 EyeView(Eye eye) {
    return EyePose(eye).Matrix;
  }

  [System.Obsolete("Use EyePose() instead.")]
  public Vector3 EyeOffset(Eye eye) {
    return EyePose(eye).Position;
  }

  [System.Obsolete("Use Projection() instead.")]
  public Matrix4x4 UndistortedProjection(Eye eye) {
    return Projection(eye, Distortion.Undistorted);
  }

  [System.Obsolete("Use Viewport() instead.")]
  public Rect EyeRect(Eye eye) {
    return Viewport(eye, Distortion.Distorted);
  }

  [System.Obsolete("Use ComfortableViewingRange instead.")]
  public float MinimumComfortDistance { get { return ComfortableViewingRange.x; } }

  [System.Obsolete("Use ComfortableViewingRange instead.")]
  public float MaximumComfortDistance { get { return ComfortableViewingRange.y; } }
}

上面的源代码理解起来比较麻烦，我解析的时候会把变量定义等一些顺序调换一下
注释部分

The Cardboard object communicates with the head-mounted display in order to:Query the device for viewing parameters  Retrieve the latest head tracking data  Provide the rendered scene to the device for distortion correction 翻译/*Cardboard物体与头盔显示器进行交互以获得设备上的一些参数，返回最近头部跟踪数据，为被渲染的场景提供失真校正*/

定义了一个Cardboard类型的静态公有变量SDK，主要用来获取游戏中的Cardboard.cs脚本，可以看到它是只读的，即SDK提供了一个共有的访问接口，在任何时候它都只有一个实例。 // The singleton instance of the Cardboard class. 翻译/*Cardboard类的单件实例*/---关于单件模式，编程用的还是挺多的。

BaseVRDevice类型的私有静态变量device，BaseVRDevice也是插件当中定义的一个类，注意！！它与Cardboard类不同，它不是脚本类！！这个变量用的比较多  // The VR device that will be providing input data. 翻译/*VR设备（在这里直接理解为手机吧！）提供输入的数据*/

公有bool类型的变量DistortionCorrection，默认为true。DistortionCorrection我把它翻译为失真校正（暂且这样翻译吧），读属性不说了，写属性加了个if语句，想说明假如设备接入了并且支持失真校正功能，才能修改它的值，不然一直为true。（这个变量是控制扭曲的，开或者关的效果如下，差距应该一目了然）

同上还有VRModeEnabled（VR模式的使能，开了就是分屏），EnableAlignmentMarker（就是下图黄圈中间那根线，关了，线就没了），EnableSettingsButton（就是下图绿圈内的设置按钮，同样也是关了就没了），AutoDriftCorrection（这个属性还没搞懂先放着），NeckModelScale（这个是专业术语，应该是颈部的微调吧...猜的，值在0-1之间，调整的话视角会有微小的变化，但可以忽略不计）

后面从#if UNITY_IOS到#endif中间的部分是预编译部分，根据ios，unity_editor，android选择性的编译，可以根据自己的平台选择性的看。我们现在使用unity编辑器在运行，所以他编译的是#if UNITY_EDITOR到#endif中间的这部分。

RenderTexture类型的公有变量StereoScreen，渲染纹理是一种即时更新的纹理。//The texture that Unity renders the scene to. This is sent to the VR device,which renders it to screen, correcting for lens distortion. 翻译/*Unity渲染场景产生的纹理，它被传输到VR设备上，在屏幕上被绘制产生正确的透镜弯曲效果*/这个变量的读属性当vr模式或者distortionCorrection关闭时，为null，写属性也只有在支持distortionCorrection的时候可以使用，总的来说，可以把它看作产生弯曲效果的一个工具或者一个中间量。

bool类型只读属性的UseDistortionEffect，这个量是用来判断透镜效果是否开启的量，后面会用到。

CardboardProfile类型的公有变量Profile，也是只读的。 // Describes the current device, including phone screen. 翻译/*描述当前设备，包括手机屏幕*/

公有枚举类型Eye。 // Distinguish the stereo eyes. 翻译/*看立体效果时用来区分左右眼*/

公有枚举类型Distortion。这个量主要控制在某些特殊情况下是否需要透镜预览，在下面会用到

Pose3D类型的公有量HeadPose。  // The transformation of head from origin in the tracking system.  翻译/*在跟踪在系统中，头部距离起始点的信息*/由于这里Pose3D也是插件自定义的类，后续需要分析Pose3D这个类才能知道信息是如何传递的。同理还有变量EyePose。

返回Matrix4x4类型的方法Projection(Eye eye, Distortion distortion = Distortion.Distorted)返回结果是device.GetProjection(eye, distortion);从两个参数推断这个方法是要根据眼睛计算返回一个投影矩阵，在Unity圣典中阐述过Matrix4x4类型的投影矩阵，关于投影矩阵，涉及到计算机图形学的东西，我目前也正在学习，给一个链接大家可以学习一下。

http://blog.csdn.net/yanwei2016/article/details/7326180

Viewport(Eye eye, Distortion distortion = Distortion.Distorted)方法返回视口矩形，应该是处理在屏幕上的位置的一个方法

Vector2类型的变量ComfortableViewingRange，只读，控制我们去看空间中物体的一个最舒服的距离范围，这个量不需要去配置，理解就行。

私有方法InitDevice()用于初始化设备，因为涉及到BaseVRDevice类，我们以后再去解析其细节。

私有方法AddDummyCamera()用来添加一个黑色背景，当然背景也可以自己更换。

一些琐碎的定义先到这里

/********************************************************分割线********************************************************************/

NOTE: Each scene load causes an OnDestroy of the current SDK, followed by and Awake of a new one.  That should not cause the underlying native code to hiccup.  Exception: developer may call Application.DontDestroyOnLoad on the SDK if they want it to survive across scene loads.

翻译/*说明：每一个新场景被加载会导致现在sdk的destroy，然后产生新的sdk，这会发生一些问题（这句话实在不会翻译了），所以开发者们在切换场景的时候如果希望sdk依然存活，可以使用Application.DontDestroyOnLoad*/。这里其实可以间接的说明SDK是采用的单件模式，因为我们无法用new（）去创建，而且自始而终最多只有一个实例。

比较关键的awake函数来了

  void Awake() {
    if (sdk == null) {
      sdk = this;
    }
    if (sdk != this) {
      Debug.LogWarning("Cardboard SDK object should be a singleton.");
      enabled = false;
      return;
    }
#if UNITY_IOS
    Application.targetFrameRate = 60;
#endif
    InitDevice();
    AddDummyCamera();
    StereoScreen = null;
  }相信上面的语句根据我之前的解释大家都能看懂了

这个类中没有Update（）所以我认为更新可能放在BaseVRDevice类型的device里面了。

我先码到这里（太累了），后面接着此篇，另外会解析BaseVRDevice这个类（很重要！！），还有CardboardProfile这个类。

总结：这一章还只是把每个类的功能和大致框架整理了一下，并没有涉及到很多细节的东西，也没有涉及到原理，注意我们现在还在顶端的父物体Cardboard物体上分析，后面当涉及到原理的的时候，就要开始看下层的Head，和它的子物体几个camera了。