Unity ARKit Plugin リファレンスまとめを試みる

この記事は KLab Advent Calendar 2017 23日目の記事です。
Advent Calendar も大詰めですね。mizusawa-k です。よろしくお願いします。

はじめに

Unity から提供されている Unity ARKit Plugin を触っていたところ、API ドキュメントと思しきものが見当たらなく
「各ファイル、クラスごとのインターフェースをまとめた API リファレンス的なものが欲しいな。」
と思ったので本記事にてまとめていきたいと思います。

Unity ARKit Plugin とは

Unity ARKit Plugin とは、iOS 11 から搭載された ARKit の機能を Unity で使えるようにしたアセットのことです。

対応バージョン

• Unity 5.6.2 以降
• Xcode 9 以降
• Mac OS X 10.13以降

Unity ARKit Plugin リファレンスまとめ

本リファレンスの対象バージョン

• 1.0.12

Plugins/iOS/UnityARKitEditor

ファイル一覧

• UnityARBuildPostprocessor.cs

UnityARBuildPostprocessor.cs

Public

    // Build postprocessor. Currently only needed on:
    // - iOS: no dynamic libraries, so plugin source files have to be copied into Xcode project
    [PostProcessBuild]
    public static void OnPostprocessBuild(BuildTarget target, string pathToBuiltProject);

Private

    private static UnityARKitPluginSettings LoadSettings();

    // Replaces the first C++ macro with the given name in the source file. Only changes
    // single-line macro declarations, if multi-line macro declaration is detected, the
    // function returns without changing it. Macro name must be a valid C++ identifier.
    internal static bool ReplaceCppMacro(string[] lines, string name, string newValue);

    internal static void AddOrReplaceCppMacro(ref string[] lines, string name, string newValue);

    static void UpdateDefinesInFile(string file, Dictionary<string, bool> valuesToUpdate);

    private static void OnPostprocessBuildIOS(string pathToBuiltProject);

Plugins/iOS/UnityARKit/Helper

ファイル一覧

• AR3DOFCameraManager.cs
• ARPlaneAnchorGameObject.cs
• DontDestroyOnLoad.cs
• PointCloudParticleExample.cs
• UnityARAmbient.cs
• UnityARAnchorManager.cs
• UnityARCameraManager.cs
• UnityARCameraNearFar.cs
• UnityARGeneratePlane.cs
• UnityARHitTestExample.cs
• UnityARKitControl.cs
• UnityARKitLightManager.cs
• UnityARMatrixOps.cs
• UnityARUserAnchorComponent.cs
• UnityARUtility.cs
• UnityARVideo.cs
• UnityPointCloudExample.cs

AR3DOFCameraManager.cs

public class AR3DOFCameraManager : MonoBehaviour {

    public Camera m_camera;
    private UnityARSessionNativeInterface m_session;
    private Material savedClearMaterial;

    // Use this for initialization
    void Start ();

    public void SetCamera(Camera newCamera);

    private void SetupNewCamera(Camera newCamera);

    // Update is called once per frame
#if !UNITY_EDITOR
    void Update ();
#endif

}

ARPlaneAnchorGameObject.cs

Public

    public class ARPlaneAnchorGameObject
    {
        public GameObject gameObject;
        public ARPlaneAnchor planeAnchor;
    }

DontDestroyOnLoad.cs

Public

public class DontDestroyOnLoad : MonoBehaviour {

    // Use this for initialization
    void Start ();

    // Update is called once per frame
    void Update ();
}

PointCloudParticleExample.cs

Public

public class PointCloudParticleExample : MonoBehaviour {
    public ParticleSystem pointCloudParticlePrefab;
    public int maxPointsToShow;
    public float particleSize = 1.0f;
    private Vector3[] m_PointCloudData;
    private bool frameUpdated = false;
    private ParticleSystem currentPS;
    private ParticleSystem.Particle [] particles;

    // Use this for initialization
    void Start ();

    public void ARFrameUpdated(UnityARCamera camera);

    // Update is called once per frame
    void Update ();
}

UnityARAmbient.cs

Public

    public class UnityARAmbient : MonoBehaviour
    {
        private Light l;

        public void Start();

        void UpdateLightEstimation(UnityARCamera camera);

        void OnDestroy();
    }

UnityARAnchorManager.cs

Public

    public class UnityARAnchorManager 
    {
        private Dictionary<string, ARPlaneAnchorGameObject> planeAnchorMap;

        public UnityARAnchorManager ();

        public void AddAnchor(ARPlaneAnchor arPlaneAnchor);

        public void RemoveAnchor(ARPlaneAnchor arPlaneAnchor);

        public void UpdateAnchor(ARPlaneAnchor arPlaneAnchor);

        public void Destroy();

        planeAnchorMap.Clear ();

        public List<ARPlaneAnchorGameObject> GetCurrentPlaneAnchors();
    }

UnityARCameraManager.cs

Public

public class UnityARCameraManager : MonoBehaviour {

    public Camera m_camera;
    private UnityARSessionNativeInterface m_session;
    private Material savedClearMaterial;

    [Header("AR Config Options")]
    public UnityARAlignment startAlignment = UnityARAlignment.UnityARAlignmentGravity;
    public UnityARPlaneDetection planeDetection = UnityARPlaneDetection.Horizontal;
    public bool getPointCloud = true;
    public bool enableLightEstimation = true;

    // Use this for initialization
    void Start ();

    public void SetCamera(Camera newCamera);

    private void SetupNewCamera(Camera newCamera);

    // Update is called once per frame
    void Update ();
}

UnityARCameraNearFar.cs

Public

[RequireComponent(typeof(Camera))]
public class UnityARCameraNearFar : MonoBehaviour {

    private Camera attachedCamera;
    private float currentNearZ;
    private float currentFarZ;

    // Use this for initialization
    void Start ();

    void UpdateCameraClipPlanes();

    // Update is called once per frame
    void Update ();
}

UnityARGeneratePlane.cs

Public

    public class UnityARGeneratePlane : MonoBehaviour
    {
        void OnDestroy();
        void OnGUI();
    }

UnityARHitTestExample.cs

Public

    public class UnityARHitTestExample : MonoBehaviour
    {
        public Transform m_HitTransform;

            bool HitTestWithResultType (ARPoint point, ARHitTestResultType resultTypes);

        // Update is called once per frame
        void Update ();
    }

UnityARKitControl.cs

Public

    public class UnityARKitControl : MonoBehaviour {

        UnityARSessionRunOption [] runOptions = new UnityARSessionRunOption[4];
        UnityARAlignment [] alignmentOptions = new UnityARAlignment[3];
        UnityARPlaneDetection [] planeOptions = new UnityARPlaneDetection[4];

        int currentOptionIndex = 0;
        int currentAlignmentIndex = 0;
        int currentPlaneIndex = 0;

        // Use this for initialization
        void Start ();

        // Update is called once per frame
        void Update ();
        void OnGUI();
    }

UnityARKitLightManager.cs

Public

public class UnityARKitLightManager : MonoBehaviour {

    Light [] lightsInScene;
    SphericalHarmonicsL2 shl;

    // Use this for initialization
    void Start ();

    void OnDestroy();

    Light []  FindAllLights();

    void UpdateLightEstimations(UnityARCamera camera);

    void UpdateBasicLightEstimation(UnityARLightEstimate uarle);
    }

    void UpdateDirectionalLightEstimation(UnityARDirectionalLightEstimate uardle);
}

UnityARMatrixOps.cs

Public

    public class UnityARMatrixOps
    {
        public static Vector3 GetPosition(Matrix4x4 matrix);

        public static Quaternion GetRotation(Matrix4x4 matrix);

        static Quaternion QuaternionFromMatrix(Matrix4x4 m);
    }

UnityARUserAnchorComponent.cs

Public

    public class UnityARUserAnchorComponent : MonoBehaviour {

        private string m_AnchorId;

        public string AnchorId  { get { return m_AnchorId; } }

        void Awake();
        void Start ();

        public void AnchorRemoved(ARUserAnchor anchor);

        void OnDestroy();

        private void GameObjectAnchorUpdated(ARUserAnchor anchor);
    }

UnityARUtility.cs

Public

    public class UnityARUtility
    {
        private MeshCollider meshCollider; //declared to avoid code stripping of class
        private MeshFilter meshFilter; //declared to avoid code stripping of class
        private static GameObject planePrefab = null;

        public static void InitializePlanePrefab(GameObject go);

        public static GameObject CreatePlaneInScene(ARPlaneAnchor arPlaneAnchor);

        public static GameObject UpdatePlaneWithAnchorTransform(GameObject plane, ARPlaneAnchor arPlaneAnchor);
    }

UnityARVideo.cs

Public

    public class UnityARVideo : MonoBehaviour
    {
        public Material m_ClearMaterial;

        private CommandBuffer m_VideoCommandBuffer;
        private Texture2D _videoTextureY;
        private Texture2D _videoTextureCbCr;
    private Matrix4x4 _displayTransform;

    private bool bCommandBufferInitialized;

    public void Start();
    void UpdateFrame(UnityARCamera cam);

    void InitializeCommandBuffer();

    void OnDestroy();

#if !UNITY_EDITOR
        public void OnPreRender();
#else

    public void SetYTexure(Texture2D YTex);

    public void SetUVTexure(Texture2D UVTex);
    public void OnPreRender();

#endif
    }

UnityPointCloudExample.cs

Public

public class UnityPointCloudExample : MonoBehaviour
{
    public uint numPointsToShow = 100;
    public GameObject PointCloudPrefab = null;
    private List<GameObject> pointCloudObjects;
    private Vector3[] m_PointCloudData;

    public void Start();

    public void ARFrameUpdated(UnityARCamera camera);

    public void Update();
}

Plugins/iOS/UnityARKit/NativeInterface

ファイル一覧

• ARAnchor.cs
• ARCamera.cs
• ARErrorCode.cs
• ARFaceAnchor.cs
• ARFrame.cs
• ARHitTestResult.cs
• ARHitTestResultType.cs
• ARLightEstimate.cs
• ARPlaneAnchor.cs
• ARPlaneAnchor.cs
• ARPlaneAnchorAlighment.cs
• ARPoint.cs
• ARRect.cs
• ARSize.cs
• ARTextureHandles.cs
• ARTrackingQuality.cs
• ARTrackingState.cs
• ARTrackingStateReason.cs
• ARUserAnchor.cs
• UnityARSessionNativeInterface.cs

ARAnchor.cs

Public

    public struct ARAnchor
    {
        public string identifier;

        /**
        The transformation matrix that defines the anchor's rotation, translation and scale in world coordinates.
         */
        public Matrix4x4 transform;
    }

ARCamera

Public

    public struct ARCamera
    {
        /**
         The transformation matrix that defines the camera's rotation and translation in world coordinates.
        */

        public Matrix4x4 worldTransform;

        /**
         The camera's orientation defined as Euler angles.

         @dicussion The order of components in this vector matches the axes of rotation:
                       1. Pitch (the x component) is the rotation about the node's x-axis (in radians)
                       2. Yaw   (the y component) is the rotation about the node's y-axis (in radians)
                       3. Roll  (the z component) is the rotation about the node's z-axis (in radians)
                    ARKit applies these rotations in the reverse order of the components:
                       1. first roll
                       2. then yaw
                       3. then pitch
         */

        public Vector3 eulerAngles;

        public ARTrackingQuality trackingQuality;

        /**
         The camera intrinsics.
         @discussion The matrix has the following contents:
         fx 0   px
         0  fy  py
         0  0   1
         fx and fy are the focal length in pixels.
         px and py are the coordinates of the principal point in pixels.
         The origin is at the center of the upper-left pixel.
         */

        public Vector3 intrinsics_row1;
        public Vector3 intrinsics_row2;
        public Vector3 intrinsics_row3;

        public ARSize imageResolution;

    }

ARErrorCode

Public

    public enum ARErrorCode : long
    {
        /** Unsupported session configuration. */
        ARErrorCodeUnsupportedConfiguration   = 100,

        /** A sensor required to run the session is not available. */
        ARErrorCodeSensorUnavailable          = 101,

        /** A sensor failed to provide the required input. */
        ARErrorCodeSensorFailed               = 102,

        /** World tracking has encountered a fatal error. */
        ARErrorCodeWorldTrackingFailed        = 200,

    }

ARFaceAnchor.cs

Public

    public static class ARBlendShapeLocation
    {
         public const string  BrowDownLeft        =   "browDown_L";
         public const string  BrowDownRight       =   "browDown_R";
         public const string  BrowInnerUp         =   "browInnerUp";
         public const string  BrowOuterUpLeft     =   "browOuterUp_L";
         public const string  BrowOuterUpRight    =   "browOuterUp_R";
         public const string  CheekPuff           =   "cheekPuff";
         public const string  CheekSquintLeft     =   "cheekSquint_L";
         public const string  CheekSquintRight    =   "cheekSquint_R";
         public const string  EyeBlinkLeft        =   "eyeBlink_L";
         public const string  EyeBlinkRight       =   "eyeBlink_R";
         public const string  EyeLookDownLeft     =   "eyeLookDown_L";
         public const string  EyeLookDownRight    =   "eyeLookDown_R";
         public const string  EyeLookInLeft       =   "eyeLookIn_L";
         public const string  EyeLookInRight      =   "eyeLookIn_R";
         public const string  EyeLookOutLeft      =   "eyeLookOut_L";
         public const string  EyeLookOutRight     =   "eyeLookOut_R";
         public const string  EyeLookUpLeft       =   "eyeLookUp_L";
         public const string  EyeLookUpRight      =   "eyeLookUp_R";
         public const string  EyeSquintLeft       =   "eyeSquint_L";
         public const string  EyeSquintRight      =   "eyeSquint_R";
         public const string  EyeWideLeft         =   "eyeWide_L";
         public const string  EyeWideRight        =   "eyeWide_R";
         public const string  JawForward          =   "jawForward";
         public const string  JawLeft             =   "jawLeft";
         public const string  JawOpen             =   "jawOpen";
         public const string  JawRight            =   "jawRight";
         public const string  MouthClose          =   "mouthClose";
         public const string  MouthDimpleLeft     =   "mouthDimple_L";
         public const string  MouthDimpleRight    =   "mouthDimple_R";
         public const string  MouthFrownLeft      =   "mouthFrown_L";
         public const string  MouthFrownRight     =   "mouthFrown_R";
         public const string  MouthFunnel         =   "mouthFunnel";
         public const string  MouthLeft           =   "mouthLeft";
         public const string  MouthLowerDownLeft  =   "mouthLowerDown_L";
         public const string  MouthLowerDownRight =   "mouthLowerDown_R";
         public const string  MouthPressLeft      =   "mouthPress_L";
         public const string  MouthPressRight     =   "mouthPress_R";
         public const string  MouthPucker         =   "mouthPucker";
         public const string  MouthRight          =   "mouthRight";
         public const string  MouthRollLower      =   "mouthRollLower";
         public const string  MouthRollUpper      =   "mouthRollUpper";
         public const string  MouthShrugLower     =   "mouthShrugLower";
         public const string  MouthShrugUpper     =   "mouthShrugUpper";
         public const string  MouthSmileLeft      =   "mouthSmile_L";
         public const string  MouthSmileRight     =   "mouthSmile_R";
         public const string  MouthStretchLeft    =   "mouthStretch_L";
         public const string  MouthStretchRight   =   "mouthStretch_R";
         public const string  MouthUpperUpLeft    =   "mouthUpperUp_L";
         public const string  MouthUpperUpRight   =   "mouthUpperUp_R";
         public const string  NoseSneerLeft       =   "noseSneer_L";
         public const string  NoseSneerRight      =   "noseSneer_R";
    }

    public struct UnityARFaceGeometry
    {
        public int vertexCount;
        public IntPtr vertices;
        public int textureCoordinateCount;
        public IntPtr textureCoordinates;
        public int triangleCount;
        public IntPtr triangleIndices;

    }

    public struct UnityARFaceAnchorData 
    {
        public IntPtr ptrIdentifier;

        /**
        The transformation matrix that defines the anchor's rotation, translation and scale in world coordinates.
         */
        public UnityARMatrix4x4 transform;

        public string identifierStr { get { } }

        public UnityARFaceGeometry faceGeometry;
        public IntPtr blendShapes;

    };

    public class ARFaceGeometry
    {
        private UnityARFaceGeometry uFaceGeometry;

        public ARFaceGeometry (UnityARFaceGeometry ufg);
        public int vertexCount { get { } }
        public int triangleCount {  get  { } }
        public int textureCoordinateCount { get { } }

        public Vector3 [] vertices { get { } }

        public Vector2 [] textureCoordinates { get { } }

        public int [] triangleIndices { get { } }

        Vector3 [] MarshalVertices(IntPtr ptrFloatArray, int vertCount);

        int [] MarshalIndices(IntPtr ptrIndices, int triCount);

        Vector2 [] MarshalTexCoords(IntPtr ptrTexCoords, int texCoordCount);

    }

    public class ARFaceAnchor 
    {
        private UnityARFaceAnchorData faceAnchorData;
        private static Dictionary<string, float> blendshapesDictionary;

        public ARFaceAnchor (UnityARFaceAnchorData ufad);

        public string identifierStr { get { } }

        public Matrix4x4 transform { get { } }

        public ARFaceGeometry faceGeometry { get { } }

        public Dictionary<string, float> blendShapes { get { } }

        delegate void DictionaryVisitorHandler(IntPtr keyPtr, float value);

        [DllImport("__Internal")]
        private static extern void GetBlendShapesInfo(IntPtr ptrDic, DictionaryVisitorHandler handler);

        Dictionary<string, float> GetBlendShapesFromNative(IntPtr blendShapesPtr);

        [MonoPInvokeCallback(typeof(DictionaryVisitorHandler))]
        static void AddElementToManagedDictionary(IntPtr keyPtr, float value);
    }

ARFrame

Public

public struct ARFrame
{
    /**
     A timestamp identifying the frame.
     */
    public double timestamp;

    /**
    The frame's captured image.
    */
    public IntPtr capturedImage;

    /**
     The camera used to capture the frame's image.
     @discussion The camera provides the device's position and orientation as well as camera parameters.
     */
    public ARCamera camera;

    /**
    A list of anchors in the scene.
    */
    //List<ARAnchor> anchors;

    /**
    A light estimate representing the light in the scene.
    @discussion Returns nil if there is no light estimation.
     */
    ARLightEstimate lightEstimate;

}

ARHitTestResult

Public

public struct ARHitTestResult
{
    /**
     The type of the hit-test result.
    */
    public ARHitTestResultType type;

    /**
    The distance from the camera to the intersection in meters.
    */
    public double distance;

    /**
    The transformation matrix that defines the intersection's rotation, translation and scale
    relative to the anchor or nearest feature point.
    */
    public Matrix4x4 localTransform;

    /**
    The transformation matrix that defines the intersection's rotation, translation and scale
    relative to the world.
    */
    public Matrix4x4 worldTransform;

    /**
    The anchor that the hit-test intersected.
    */
    public string anchorIdentifier;

    /**
    True if the test represents a valid hit test. Data is undefined otherwise.
    */
    public bool isValid;
}

ARHitTestResultType.cs

Public

[Flags]
public enum ARHitTestResultType : long
{
    /** Result type from intersecting the nearest feature point. */
    ARHitTestResultTypeFeaturePoint     = (1 << 0),

    /** Result type from detecting and intersecting a new horizontal plane. */
    ARHitTestResultTypeHorizontalPlane  = (1 << 1),

    /** Result type from detecting and intersecting a new vertical plane. */
    ARHitTestResultTypeVerticalPlane    = (1 << 2),

    /** Result type from intersecting with an existing plane anchor. */
    ARHitTestResultTypeExistingPlane    = (1 << 3),

    /** Result type from intersecting with an existing plane anchor, taking into account the plane's extent. */
    ARHitTestResultTypeExistingPlaneUsingExtent  = ( 1 << 4)
}

ARLightEstimate.cs

Public

    public struct ARLightEstimate
    {
        public float ambientIntensity;
    }

    [Serializable]
    public struct UnityARLightEstimate
    {
        public float ambientIntensity;
        public float ambientColorTemperature;

        public UnityARLightEstimate(float intensity, float temperature);
    };

    public struct MarshalDirectionalLightEstimate
    {
        public Vector4 primaryDirAndIntensity;
        public IntPtr  sphericalHarmonicCoefficientsPtr;

        public float [] SphericalHarmonicCoefficients { get { } } 

        float [] MarshalCoefficients(IntPtr ptrFloats);

        void RotateForUnity(ref float[] shc, int startIndex);
    }

    public class UnityARDirectionalLightEstimate
    {
        public Vector3 primaryLightDirection;
        public float primaryLightIntensity;
        public float [] sphericalHarmonicsCoefficients;

        public UnityARDirectionalLightEstimate (float [] SHC, Vector3 direction, float intensity);
    };

    public enum LightDataType
    {
        LightEstimate,
        DirectionalLightEstimate
    }

    public struct UnityMarshalLightData
    {
        public LightDataType arLightingType;
        public UnityARLightEstimate arLightEstimate;
        public MarshalDirectionalLightEstimate arDirectonalLightEstimate;

        public UnityMarshalLightData(LightDataType ldt, UnityARLightEstimate ule, MarshalDirectionalLightEstimate mdle);

        public static implicit operator UnityARLightData(UnityMarshalLightData rValue);
    }

    public struct UnityARLightData
    {
        public LightDataType arLightingType;
        public UnityARLightEstimate arLightEstimate;
        public UnityARDirectionalLightEstimate arDirectonalLightEstimate;

        public UnityARLightData(LightDataType ldt, UnityARLightEstimate ule, UnityARDirectionalLightEstimate udle);
    }

ARPlaneAnchor.cs

Public

    public struct ARPlaneAnchor 
    {
        public string identifier;

        /**
        The transformation matrix that defines the anchor's rotation, translation and scale in world coordinates.
         */
        public Matrix4x4 transform;

        /**
         The alignment of the plane.
         */
        public ARPlaneAnchorAlignment alignment;

        /**
        The center of the plane in the anchor’s coordinate space.
         */
        public Vector3 center;

        /**
        The extent of the plane in the anchor’s coordinate space.
         */
        public Vector3 extent;
    }

ARPlaneAnchorAlighment.cs

Public

    public enum ARPlaneAnchorAlignment : long
    {
        /** A plane that is horizontal with respect to gravity. */
        ARPlaneAnchorAlignmentHorizontal
    }

ARPoint.cs

Public

    public struct ARPoint
    {
        public double x;
        public double y;
    }

ARRect.cs

Public

    public struct ARRect
    {
        public ARPoint origin;
        public ARSize  size;
    }

ARSize.cs

Public

    public struct ARSize
    {
        public double width;
        public double height;
    }

ARTextureHandles.cs

Public

    public struct ARTextureHandles
    {
        // Native (Metal) texture handles for the device camera buffer
        public IntPtr textureY;
        public IntPtr textureCbCr;
    }

ARTrackingQuality.cs

Public

public enum ARTrackingQuality : long
{
    /** The tracking quality is not available. */
    ARTrackingQualityNotAvailable,

    /** The tracking quality is limited, relying only on the device's motion. */
    ARTrackingQualityLimited,

    /** The tracking quality is poor. */
    ARTrackingQualityPoor,

    /** The tracking quality is good. */
    ARTrackingQualityGood

}

ARTrackingState.cs

Public

public enum ARTrackingState
{
    /** Tracking is not available. */
    ARTrackingStateNotAvailable,

    /** Tracking is limited. See tracking reason for details. */
    ARTrackingStateLimited,

    /** Tracking is Normal. */
    ARTrackingStateNormal,
}

ARTrackingStateReason.cs

Public

public enum ARTrackingStateReason
{
    /** Tracking is not limited. */
    ARTrackingStateReasonNone,

    /** Tracking is limited due to initialization in progress. */
    ARTrackingStateReasonInitializing,

    /** Tracking is limited due to a excessive motion of the camera. */
    ARTrackingStateReasonExcessiveMotion,

    /** Tracking is limited due to a lack of features visible to the camera. */
    ARTrackingStateReasonInsufficientFeatures,
}

ARUserAnchor.cs

Public

public struct ARUserAnchor 
{
    public string identifier;

    /**
    The transformation matrix that defines the anchor's rotation, translation and scale in world coordinates.
    */
    public Matrix4x4 transform;
}

UnityARSessionNativeInterface.cs

Public

    /// <summary>
    /// A struct that allows us go from native Matrix4x4 to managed
    /// </summary>
    public struct UnityARMatrix4x4
    {
        public Vector4 column0;
        public Vector4 column1;
        public Vector4 column2;
        public Vector4 column3;

        public UnityARMatrix4x4(Vector4 c0, Vector4 c1, Vector4 c2, Vector4 c3);
    };

    [Serializable]
    public struct UnityVideoParams
    {
        public int yWidth;
        public int yHeight;
        public int screenOrientation;
        public float texCoordScale;
        public IntPtr cvPixelBufferPtr;
    };

    public struct UnityARCamera
    {
        public UnityARMatrix4x4 worldTransform;
        public UnityARMatrix4x4 projectionMatrix;
        public ARTrackingState trackingState;
        public ARTrackingStateReason trackingReason;
        public UnityVideoParams videoParams;
        public UnityARLightData lightData;
        public UnityARMatrix4x4 displayTransform;
        public Vector3[] pointCloudData;

        public UnityARCamera(UnityARMatrix4x4 wt, UnityARMatrix4x4 pm, ARTrackingState ats, ARTrackingStateReason atsr, UnityVideoParams uvp, UnityARLightData lightDat, UnityARMatrix4x4 dt, Vector3[] pointCloud);
    };

    public struct UnityARAnchorData {
        public IntPtr ptrIdentifier;

        /**
        The transformation matrix that defines the anchor's rotation, translation and scale in world coordinates.
        */
        public UnityARMatrix4x4 transform;

        /**
        The alignment of the plane.
        */
        public ARPlaneAnchorAlignment alignment;

        /**
        The center of the plane in the anchor’s coordinate space.
        */
        public Vector4 center;

        /**
        The extent of the plane in the anchor’s coordinate space.
        */
        public Vector4 extent;

        public string identifierStr { get { } }

        public static UnityARAnchorData UnityARAnchorDataFromGameObject(GameObject go);
    };

    public struct UnityARUserAnchorData 
    {
        public IntPtr ptrIdentifier;

        /**
        The transformation matrix that defines the anchor's rotation, translation and scale in world coordinates.
         */
        public UnityARMatrix4x4 transform;

        public string identifierStr { get { } }

        public static UnityARUserAnchorData UnityARUserAnchorDataFromGameObject(GameObject go);
    };

    public struct UnityARHitTestResult
    {
        /**
         The type of the hit-test result.
         */
        public ARHitTestResultType type;

        /**
        The distance from the camera to the intersection in meters.
        */
        public double distance;

        /**
        The transformation matrix that defines the intersection's rotation, translation and scale
        relative to the anchor or nearest feature point.
        */
        public Matrix4x4 localTransform;

        /**
        The transformation matrix that defines the intersection's rotation, translation and scale
        relative to the world.
        */
        public Matrix4x4 worldTransform;

        /**
        The anchor that the hit-test intersected.
        */
        public IntPtr anchor;

        /**
        True if the test represents a valid hit test. Data is undefined otherwise.
        */
        public bool isValid;

    };

    public enum UnityARAlignment
    {
        UnityARAlignmentGravity,
        UnityARAlignmentGravityAndHeading,
        UnityARAlignmentCamera
    }

    public enum UnityARPlaneDetection
    {
        None = 0,
        Horizontal = (1 << 0)
    }

    public struct ARKitSessionConfiguration
    {
        public UnityARAlignment alignment; 
        public bool getPointCloudData;
        public bool enableLightEstimation;
        public bool IsSupported { get { } private set {} }

        public ARKitSessionConfiguration(UnityARAlignment alignment = UnityARAlignment.UnityARAlignmentGravity,
                                            bool getPointCloudData = false, 
                                            bool enableLightEstimation = false);

        [DllImport("__Internal")]
        private static extern bool IsARKitSessionConfigurationSupported();
    }

    public struct ARKitWorldTrackingSessionConfiguration
    {
        public UnityARAlignment alignment; 
        public UnityARPlaneDetection planeDetection;
        public bool getPointCloudData;
        public bool enableLightEstimation;
        public bool IsSupported { get { } private set { } }

        public ARKitWorldTrackingSessionConfiguration(UnityARAlignment alignment = UnityARAlignment.UnityARAlignmentGravity,
                UnityARPlaneDetection planeDetection = UnityARPlaneDetection.Horizontal,
        bool getPointCloudData = false, 
        bool enableLightEstimation = false);

        [DllImport("__Internal")]
        private static extern bool IsARKitWorldTrackingSessionConfigurationSupported();
    }

    public struct ARKitFaceTrackingConfiguration
    {
        public UnityARAlignment alignment; 
        public bool enableLightEstimation;
        public bool IsSupported { get { } private set {} }

        public ARKitFaceTrackingConfiguration(UnityARAlignment alignment = UnityARAlignment.UnityARAlignmentGravity,
            bool enableLightEstimation = false);

#if UNITY_EDITOR
        private bool IsARKitFaceTrackingConfigurationSupported();
#else
        [DllImport("__Internal")]
        private static extern bool IsARKitFaceTrackingConfigurationSupported();
#endif

    }

    public enum UnityARSessionRunOption {
        /** The session will reset tracking. */
        ARSessionRunOptionResetTracking           = (1 << 0),

        /** The session will remove existing anchors. */
        ARSessionRunOptionRemoveExistingAnchors   = (1 << 1)
    }

    public class UnityARSessionNativeInterface {

        // Plane Anchors
        public delegate void ARFrameUpdate(UnityARCamera camera);
        public static event ARFrameUpdate ARFrameUpdatedEvent;

        public delegate void ARAnchorAdded(ARPlaneAnchor anchorData);
        public static event ARAnchorAdded ARAnchorAddedEvent;

        public delegate void ARAnchorUpdated(ARPlaneAnchor anchorData);
        public static event ARAnchorUpdated ARAnchorUpdatedEvent;

        public delegate void ARAnchorRemoved(ARPlaneAnchor anchorData);
        public static event ARAnchorRemoved ARAnchorRemovedEvent;

        // User Anchors
        public delegate void ARUserAnchorAdded(ARUserAnchor anchorData);
        public static event ARUserAnchorAdded ARUserAnchorAddedEvent;

        public delegate void ARUserAnchorUpdated(ARUserAnchor anchorData);
        public static event ARUserAnchorUpdated ARUserAnchorUpdatedEvent;

        public delegate void ARUserAnchorRemoved(ARUserAnchor anchorData);
        public static event ARUserAnchorRemoved ARUserAnchorRemovedEvent;

        // Face Anchors
        public delegate void ARFaceAnchorAdded(ARFaceAnchor anchorData);
        public static event ARFaceAnchorAdded ARFaceAnchorAddedEvent;

        public delegate void ARFaceAnchorUpdated(ARFaceAnchor anchorData);
        public static event ARFaceAnchorUpdated ARFaceAnchorUpdatedEvent;

        public delegate void ARFaceAnchorRemoved(ARFaceAnchor anchorData);
        public static event ARFaceAnchorRemoved ARFaceAnchorRemovedEvent;

        public delegate void ARSessionFailed(string error);
        public static event ARSessionFailed ARSessionFailedEvent;

        public delegate void ARSessionCallback();
        public static event ARSessionCallback ARSessionInterruptedEvent;
        public static event ARSessionCallback ARSessioninterruptionEndedEvent;
        public delegate void ARSessionTrackingChanged(UnityARCamera camera);
        public static event ARSessionTrackingChanged ARSessionTrackingChangedEvent;

        delegate void internal_ARFrameUpdate(internal_UnityARCamera camera);
        public delegate void internal_ARAnchorAdded(UnityARAnchorData anchorData);
        public delegate void internal_ARAnchorUpdated(UnityARAnchorData anchorData);
        public delegate void internal_ARAnchorRemoved(UnityARAnchorData anchorData);
        public delegate void internal_ARUserAnchorAdded(UnityARUserAnchorData anchorData);
        public delegate void internal_ARUserAnchorUpdated(UnityARUserAnchorData anchorData);
        public delegate void internal_ARUserAnchorRemoved(UnityARUserAnchorData anchorData);
        public delegate void internal_ARFaceAnchorAdded(UnityARFaceAnchorData anchorData);
        public delegate void internal_ARFaceAnchorUpdated(UnityARFaceAnchorData anchorData);
        public delegate void internal_ARFaceAnchorRemoved(UnityARFaceAnchorData anchorData);
        delegate void internal_ARSessionTrackingChanged(internal_UnityARCamera camera);

        private static UnityARCamera s_Camera;

        [DllImport("__Internal")]
        private static extern IntPtr unity_CreateNativeARSession();

        [DllImport("__Internal")]
        private static extern void session_SetSessionCallbacks(IntPtr nativeSession, internal_ARFrameUpdate frameCallback,
                                            ARSessionFailed sessionFailed,
                                            ARSessionCallback sessionInterrupted,
                                            ARSessionCallback sessionInterruptionEnded,
                                            internal_ARSessionTrackingChanged trackingChanged);

        [DllImport("__Internal")]
        private static extern void session_SetPlaneAnchorCallbacks(IntPtr nativeSession, internal_ARAnchorAdded anchorAddedCallback, 
                                            internal_ARAnchorUpdated anchorUpdatedCallback, 
                                            internal_ARAnchorRemoved anchorRemovedCallback);

        [DllImport("__Internal")]
        private static extern void session_SetUserAnchorCallbacks(IntPtr nativeSession, internal_ARUserAnchorAdded userAnchorAddedCallback, 
                                            internal_ARUserAnchorUpdated userAnchorUpdatedCallback, 
                                            internal_ARUserAnchorRemoved userAnchorRemovedCallback);

        [DllImport("__Internal")]
        private static extern void session_SetFaceAnchorCallbacks(IntPtr nativeSession, internal_ARFaceAnchorAdded faceAnchorAddedCallback, 
                                            internal_ARFaceAnchorUpdated faceAnchorUpdatedCallback, 
                                            internal_ARFaceAnchorRemoved faceAnchorRemovedCallback);

        [DllImport("__Internal")]
        private static extern void StartWorldTrackingSession(IntPtr nativeSession, ARKitWorldTrackingSessionConfiguration configuration);

        [DllImport("__Internal")]
        private static extern void StartWorldTrackingSessionWithOptions(IntPtr nativeSession, ARKitWorldTrackingSessionConfiguration configuration, UnityARSessionRunOption runOptions);

        [DllImport("__Internal")]
        private static extern void StartSession(IntPtr nativeSession, ARKitSessionConfiguration configuration);

        [DllImport("__Internal")]
        private static extern void StartSessionWithOptions(IntPtr nativeSession, ARKitSessionConfiguration configuration, UnityARSessionRunOption runOptions);

        [DllImport("__Internal")]
        private static extern void StartFaceTrackingSession(IntPtr nativeSession, ARKitFaceTrackingConfiguration configuration);

        [DllImport("__Internal")]
        private static extern void StartFaceTrackingSessionWithOptions(IntPtr nativeSession, ARKitFaceTrackingConfiguration configuration, UnityARSessionRunOption runOptions);

        [DllImport("__Internal")]
        private static extern void PauseSession(IntPtr nativeSession);

        [DllImport("__Internal")]
        private static extern int HitTest(IntPtr nativeSession, ARPoint point, ARHitTestResultType types);

        [DllImport("__Internal")]
        private static extern UnityARHitTestResult GetLastHitTestResult(int index);

        [DllImport("__Internal")]
        private static extern ARTextureHandles GetVideoTextureHandles();

        [DllImport("__Internal")]
        private static extern float GetAmbientIntensity();

        [DllImport("__Internal")]
        private static extern int GetTrackingQuality();

        [DllImport("__Internal")]
        private static extern bool GetARPointCloud (ref IntPtr verts, ref uint vertLength);

        [DllImport("__Internal")]
        private static extern void SetCameraNearFar (float nearZ, float farZ);

        [DllImport("__Internal")]
        private static extern void CapturePixelData (int enable, IntPtr  pYPixelBytes, IntPtr pUVPixelBytes);

        [DllImport("__Internal")]
        private static extern UnityARUserAnchorData SessionAddUserAnchor (IntPtr nativeSession, UnityARUserAnchorData anchorData);

        [DllImport("__Internal")]
        private static extern void SessionRemoveUserAnchor (IntPtr nativeSession, [MarshalAs(UnmanagedType.LPStr)] string anchorIdentifier);

        public UnityARSessionNativeInterface();

        static UnityARSessionNativeInterface s_UnityARSessionNativeInterface = null;

        public static UnityARSessionNativeInterface GetARSessionNativeInterface();

#if UNITY_EDITOR
        public static void SetStaticCamera(UnityARCamera scamera);
        public static void RunFrameUpdateCallbacks();
        public static void RunAddAnchorCallbacks(ARPlaneAnchor arPlaneAnchor);
        public static void RunUpdateAnchorCallbacks(ARPlaneAnchor arPlaneAnchor);
        public static void RunRemoveAnchorCallbacks(ARPlaneAnchor arPlaneAnchor);

#endif

        public Matrix4x4 GetCameraPose();
        public Matrix4x4 GetCameraProjection();
        public void SetCameraClipPlanes(float nearZ, float farZ);
        public void SetCapturePixelData(bool enable, IntPtr pYByteArray, IntPtr pUVByteArray);

        [MonoPInvokeCallback(typeof(internal_ARFrameUpdate))]
        static void _frame_update(internal_UnityARCamera camera);

        [MonoPInvokeCallback(typeof(internal_ARSessionTrackingChanged))]
        static void _ar_tracking_changed(internal_UnityARCamera camera);


        static void UpdatePointCloudData(ref UnityARCamera camera);

        static ARPlaneAnchor GetPlaneAnchorFromAnchorData(UnityARAnchorData anchor);

        static ARUserAnchor GetUserAnchorFromAnchorData(UnityARUserAnchorData anchor);

        static ARHitTestResult GetHitTestResultFromResultData(UnityARHitTestResult resultData);

#region Plane Anchors
        [MonoPInvokeCallback(typeof(internal_ARAnchorAdded))]
        static void _anchor_added(UnityARAnchorData anchor);

        [MonoPInvokeCallback(typeof(internal_ARAnchorUpdated))]
        static void _anchor_updated(UnityARAnchorData anchor);

        [MonoPInvokeCallback(typeof(internal_ARAnchorRemoved))]
        static void _anchor_removed(UnityARAnchorData anchor);
#endregion

#region User Anchors
        [MonoPInvokeCallback(typeof(internal_ARUserAnchorAdded))]
        static void _user_anchor_added(UnityARUserAnchorData anchor);

        [MonoPInvokeCallback(typeof(internal_ARUserAnchorUpdated))]
        static void _user_anchor_updated(UnityARUserAnchorData anchor);

        [MonoPInvokeCallback(typeof(internal_ARUserAnchorRemoved))]
        static void _user_anchor_removed(UnityARUserAnchorData anchor);
#endregion

#region Face Anchors
        [MonoPInvokeCallback(typeof(internal_ARFaceAnchorAdded))]
        static void _face_anchor_added(UnityARFaceAnchorData anchor);

        [MonoPInvokeCallback(typeof(internal_ARFaceAnchorUpdated))]
        static void _face_anchor_updated(UnityARFaceAnchorData anchor);

        [MonoPInvokeCallback(typeof(internal_ARFaceAnchorRemoved))]
        static void _face_anchor_removed(UnityARFaceAnchorData anchor);
#endregion

        [MonoPInvokeCallback(typeof(ARSessionFailed))]
        static void _ar_session_failed(string error);

        [MonoPInvokeCallback(typeof(ARSessionCallback))]
        static void _ar_session_interrupted();

        [MonoPInvokeCallback(typeof(ARSessionCallback))]
        static void _ar_session_interruption_ended();

        public void RunWithConfigAndOptions(ARKitWorldTrackingSessionConfiguration config, UnityARSessionRunOption runOptions);

        public void RunWithConfig(ARKitWorldTrackingSessionConfiguration config);

        public void Run();

        public void RunWithConfigAndOptions(ARKitSessionConfiguration config, UnityARSessionRunOption runOptions);

        public void RunWithConfig(ARKitSessionConfiguration config);

        public void RunWithConfigAndOptions(ARKitFaceTrackingConfiguration config, UnityARSessionRunOption runOptions);
        public void RunWithConfig(ARKitFaceTrackingConfiguration config);
        public void Pause;

        public List<ARHitTestResult> HitTest(ARPoint point, ARHitTestResultType types);
        public ARTextureHandles GetARVideoTextureHandles();

        [Obsolete("Hook ARFrameUpdatedEvent instead and get UnityARCamera.ambientIntensity")]
        public float GetARAmbientIntensity();

        [Obsolete("Hook ARFrameUpdatedEvent instead and get UnityARCamera.trackingState")]
        public int GetARTrackingQuality();

        public UnityARUserAnchorData AddUserAnchor(UnityARUserAnchorData anchorData);
        public UnityARUserAnchorData AddUserAnchorFromGameObject(GameObject go);
        public void RemoveUserAnchor(string anchorIdentifier);
    }

Private

    struct internal_UnityARCamera
    {
        public UnityARMatrix4x4 worldTransform;
        public UnityARMatrix4x4 projectionMatrix;
        public ARTrackingState trackingState;
        public ARTrackingStateReason trackingReason;
        public UnityVideoParams videoParams;
        public UnityMarshalLightData lightData;
        public UnityARMatrix4x4 displayTransform;
        public uint getPointCloudData;
    };

#if !UNITY_EDITOR
    private IntPtr m_NativeARSession;
#endif

おわりに

本記事では、Unity ARKit Plugin のクラスを紹介していきました。

今回 Doxygen などのドキュメント自動生成ツールは特に使わず、あえて手作業でまとめていったのですが、
リファレンスをまとめるのに半日程度の時間を要しました。
Unity ARKit Plugin はそこまで大きな構成のアセットではありませんが、
改めてスクリプト、ツールによる省力化のありがたみを感じます。

年末年始は本記事とアセットストアを眺めながら、ちょっとした AR コンテンツを作りたいなと思っています。
KLab Advent Calendar 2017 24日目は yasu0000 さんです。お楽しみに。