Apply Kinect Script

Assets/Plugins.meta

+fileFormatVersion: 2
+guid: 370ceeb4338949c458d2c4831721adcc
+folderAsset: yes
+timeCreated: 1502957664
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Metro.meta

+fileFormatVersion: 2
+guid: 8563af7e17548df4db018f658370cf05
+folderAsset: yes
+timeCreated: 1502957664
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Metro/KinectUnityAddin.dll.meta

+fileFormatVersion: 2
+guid: 85bafbe9b14b18b45b445b304b1f3efc
+timeCreated: 18446744011573954816
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/Metro/KinectVisualGestureBuilderUnityAddin.dll.meta

+fileFormatVersion: 2
+guid: b51ad12a45add75438b0b8494a1b5bc0
+timeCreated: 18446744011573954816
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/x86.meta

+fileFormatVersion: 2
+guid: 82be2ecc1ba65e94f8d03335c7969a8d
+folderAsset: yes
+timeCreated: 1502957664
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/x86/Kinect20.VisualGestureBuilder.dll.meta

+fileFormatVersion: 2
+guid: 1db2dc2b011493340af3c486814773b6
+timeCreated: 18446744011573954816
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/x86/KinectUnityAddin.dll.meta

+fileFormatVersion: 2
+guid: b65facb0c9c68b647b8ca7435b5f35c4
+timeCreated: 18446744011573954816
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/x86/KinectVisualGestureBuilderUnityAddin.dll.meta

+fileFormatVersion: 2
+guid: 1c16b6c4f21217940a45b0a7980bbaa4
+timeCreated: 18446744011573954816
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/x86/vgbtechs.meta

+fileFormatVersion: 2
+guid: 3404b8810d8d9bd40a69b6ddb8d40ec0
+folderAsset: yes
+timeCreated: 1502958445
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/x86/vgbtechs/AdaBoostTech.dll.meta

+fileFormatVersion: 2
+guid: e64ddea403d2dab41a0b9e06194e24a8
+timeCreated: 18446744011573954816
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/x86/vgbtechs/RFRProgressTech.dll.meta

+fileFormatVersion: 2
+guid: 3b9258fe0bd5fa44fbb9b84edddc8a80
+timeCreated: 18446744011573954816
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/x86_64.meta

+fileFormatVersion: 2
+guid: dc48a865720f47745baa454faadba922
+folderAsset: yes
+timeCreated: 1502957664
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/x86_64/Kinect20.VisualGestureBuilder.dll.meta

+fileFormatVersion: 2
+guid: 56fe3b4f6cf934645b95af4f873f5dae
+timeCreated: 18446744011573954816
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/x86_64/KinectUnityAddin.dll.meta

+fileFormatVersion: 2
+guid: 82e143d16729051459ae6a54b37e9eab
+timeCreated: 18446744011573954816
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/x86_64/KinectVisualGestureBuilderUnityAddin.dll.meta

+fileFormatVersion: 2
+guid: bd1efe6facd8abe48967be99b7e8bb6e
+timeCreated: 18446744011573954816
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/x86_64/vgbtechs.meta

+fileFormatVersion: 2
+guid: dc8b7a4f52179304abb4308e1f5dc486
+folderAsset: yes
+timeCreated: 1502958445
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/x86_64/vgbtechs/AdaBoostTech.dll.meta

+fileFormatVersion: 2
+guid: 92bd007400232df44a5145238b2ee5f7
+timeCreated: 18446744011573954816
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Plugins/x86_64/vgbtechs/RFRProgressTech.dll.meta

+fileFormatVersion: 2
+guid: b23429c6264008d44b3e037dfa9712c4
+timeCreated: 18446744011573954816
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scene/InGame.unity

@@ -38,7 +38,7 @@ RenderSettings:
   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.45120573, g: 0.50094587, b: 0.5736755, a: 1}
+  m_IndirectSpecularColor: {r: 0.45120597, g: 0.5009464, b: 0.5736766, a: 1}
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
@@ -349,6 +349,7 @@ GameObject:
   - component: {fileID: 750753104}
   - component: {fileID: 750753105}
   - component: {fileID: 750753106}
+  - component: {fileID: 750753107}
   m_Layer: 5
   m_Name: Managers
   m_TagString: Untagged
@@ -396,6 +397,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 6e697643158480b4ba850d906eac1bc2, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
+  txt: {fileID: 0}
 --- !u!114 &750753106
 MonoBehaviour:
   m_ObjectHideFlags: 0
@@ -407,6 +409,17 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: a9d22e7eb4921ca47b18c68e43c0eb6e, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
+--- !u!114 &750753107
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 750753102}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: c957a7b7e1e0a87438d12097932a611d, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
 --- !u!1001 &754707498
 Prefab:
   m_ObjectHideFlags: 0

Assets/Script/InputManager.cs

 using System.Collections;
 using System.Collections.Generic;
 using UnityEngine;
+using System.IO;
+using UnityEngine.UI;
+
 
 public class InputManager : MonoBehaviour {
     private static InputManager instance;
+    KinectScript ks;
+    bool isUpdating = false;
+    public Text txt;
+
     public static InputManager Instance
     {
         get
@@ -20,6 +27,8 @@ public class InputManager : MonoBehaviour {
 
     private bool IsButtonDown { get; set; }
     
+    public Pair<float, MotionState> CurrentMotionState { get; set; }
+
     public bool IsButtonPressed
     {
         get
@@ -47,11 +56,25 @@ public class InputManager : MonoBehaviour {
     // Use this for initialization
     void Start()
     {
+        ks = GameObject.Find("Managers").GetComponent<KinectScript>();
     }
 
     // Update is called once per frame
     void Update()
     {
         IsButtonDown = Input.anyKey;
+
+        if(!isUpdating)
+        {
+            isUpdating = true;
+            ks.StartUpdating();
+        }
+        
+        CurrentMotionState = ks.GetState();
+
+        if(CurrentMotionState!=null)
+        Debug.Log(CurrentMotionState.second.ToString());
+
+        GameObject.Find("Wall").GetComponent<Renderer>().material.mainTexture = ks.GetImage();
     }
 }
\ No newline at end of file

Assets/Script/JudgeManager.cs

@@ -97,6 +97,19 @@ public class JudgeManager : MonoBehaviour
             }
         }
 
+        if (note is MotionNote)
+        {
+            ((MotionNote)note).Checkpoint();
+
+            if (note.Activated)
+            {
+                SetJudge(Judge.TestJudge(note, timing));
+                DeactivateNote(note);
+            }
+
+            return;
+        }
+
         Judge judge = Judge.TestJudge(note, timing);
 
         if (Judge.IsNonEmptyMiss(note, timing))

Assets/Script/KinectScript.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using Windows.Kinect;
+using System.IO;
+
+public class KinectScript : MonoBehaviour
+{
+
+    KinectSensor sensor;
+    MultiSourceFrameReader msfReader;
+
+    KinectImage image;
+    KinectMotion motion = new KinectMotion();
+
+    bool isUpdating = false;
+
+    // Use this for initialization
+    void Start()
+    {
+        sensor = KinectSensor.GetDefault();
+        if (sensor == null)
+            return;
+
+        msfReader = sensor.OpenMultiSourceFrameReader(FrameSourceTypes.Color |
+                                                      FrameSourceTypes.Depth |
+                                                      FrameSourceTypes.Body);
+
+        image = new KinectImage(
+            sensor.ColorFrameSource.CreateFrameDescription(
+                ColorImageFormat.Rgba));
+
+        if (!sensor.IsOpen)
+            sensor.Open();
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        if (isUpdating)
+            Update(image);
+    }
+
+    void AccurateUpdate()
+    {
+        if (isUpdating)
+            Update(motion);
+    }
+
+    void Update(KinectData data)
+    {
+        if (msfReader == null)
+            return;
+
+        var frame = msfReader.AcquireLatestFrame();
+        if (frame == null)
+            return;
+
+        data.Update(frame);
+    }
+
+    public void StartUpdating()
+    {
+        isUpdating = true;
+
+        InvokeRepeating("AccurateUpdate", 0, 0.001f);
+    }
+
+    public void StopUpdating()
+    {
+        isUpdating = false;
+
+        CancelInvoke("AccurateUpdate");
+    }
+
+    private void OnApplicationQuit()
+    {
+        StopUpdating();
+
+        if (msfReader == null)
+            return;
+        msfReader.Dispose();
+        msfReader = null;
+
+        if (sensor == null)
+            return;
+        if (sensor.IsOpen)
+            sensor.Close();
+        sensor = null;
+    }
+
+    public Texture2D GetImage()
+    {
+        return image.GetImage();
+    }
+
+    public Pair<float, MotionState> GetState()
+    {
+        return motion.GetState();
+    }
+}
+
+public abstract class KinectSource
+{
+    public abstract void Update(MultiSourceFrame frame);
+}
+
+public class KinectBody : KinectSource
+{
+    Body[] body = null;
+    public Dictionary<JointType, Windows.Kinect.Joint> joints
+    {
+        get;
+        private set;
+    }
+
+    public KinectBody()
+    {
+        joints = null;
+    }
+
+    public override void Update(MultiSourceFrame frame)
+    {
+        BodyFrame bFrame = frame.BodyFrameReference.AcquireFrame();
+        if (body == null)
+            body = new Body[bFrame.BodyCount];
+        bFrame.GetAndRefreshBodyData(body);
+
+        bFrame.Dispose();
+        bFrame = null;
+
+        UpdateBodyData();
+    }
+
+    private void UpdateBodyData()
+    {
+        int idx;
+        for (idx = 0; idx < body.Length; ++idx)
+            if (body[idx].IsTracked)
+                break;
+
+        if (idx >= body.Length)
+            return;
+
+        joints = body[idx].Joints;
+    }
+}
+
+public class KinectColor : KinectSource
+{
+    public byte[] texel
+    { get; private set; }
+
+    public KinectColor(FrameDescription frameDesc)
+    {
+        texel = new byte[frameDesc.BytesPerPixel * frameDesc.LengthInPixels];
+    }
+
+    public override void Update(MultiSourceFrame frame)
+    {
+        ColorFrame cFrame = frame.ColorFrameReference.AcquireFrame();
+        cFrame.CopyConvertedFrameDataToArray(texel, ColorImageFormat.Rgba);
+        cFrame.Dispose();
+        cFrame = null;
+    }
+}
+
+[System.Flags]
+public enum MotionState : uint
+{
+    UNKNOWN = 0,
+    CLAP_PREPARE = 1,
+    CLAP_DONE = 2,
+    HURRAY = 4
+}
+
+public abstract class KinectData
+{
+    public abstract void Update(MultiSourceFrame frame);
+}
+
+public class KinectImage : KinectData
+{
+    Texture2D image;
+    KinectColor color;
+
+    public KinectImage(FrameDescription frameDesc)
+    {
+        image = new Texture2D(frameDesc.Width,
+                              frameDesc.Height,
+                              TextureFormat.RGBA32,
+                              false);
+        color = new KinectColor(frameDesc);
+    }
+
+    public override void Update(MultiSourceFrame frame)
+    {
+        color.Update(frame);
+
+        image.LoadRawTextureData(color.texel);
+        image.Apply();
+    }
+
+    public Texture2D GetImage()
+    {
+        return image;
+    }
+}
+
+public class Pair<T1, T2>
+{
+    public T1 first;
+    public T2 second;
+}
+
+public class KinectMotion : KinectData
+{
+    Queue<Pair<float, MotionState>> motions
+    = new Queue<Pair<float, MotionState>>();
+    KinectBody body = new KinectBody();
+    float timeRecent = 0;
+
+    public override void Update(MultiSourceFrame frame)
+    {
+        body.Update(frame);
+
+        const float UNIT_TIME = 0.001f;
+        timeRecent += UNIT_TIME;
+
+        motions.Enqueue(new Pair<float, MotionState>
+        {
+            first = timeRecent,
+            second = DetermineState()
+        });
+    }
+
+    MotionState DetermineState()
+    {
+        MotionState s = MotionState.UNKNOWN;
+
+        if (body.joints == null || body.joints.Count == 0)
+            return s;
+
+        CameraSpacePoint head = body.joints[JointType.Head].Position,
+                         leftHand = body.joints[JointType.HandLeft].Position,
+                         rightHand = body.joints[JointType.HandRight].Position;
+        if (head.Y < leftHand.Y && head.Y < rightHand.Y)
+            s |= MotionState.HURRAY;
+        if (Distance(leftHand, rightHand) > 0.3f)
+            s |= MotionState.CLAP_PREPARE;
+        if (Distance(leftHand, rightHand) > 0.1f)
+            s |= MotionState.CLAP_DONE;
+
+        return s;
+    }
+
+    float Distance(CameraSpacePoint a, CameraSpacePoint b)
+    {
+        return Mathf.Sqrt(Mathf.Pow(a.X - b.X, 2.0f) +
+                          Mathf.Pow(a.Y - b.Y, 2.0f) +
+                          Mathf.Pow(a.Z - b.Z, 2.0f));
+    }
+
+    public Pair<float, MotionState> GetState()
+    {
+        return motions.Dequeue();
+    }
+}

Assets/Script/KinectScript.cs.meta

+fileFormatVersion: 2
+guid: c957a7b7e1e0a87438d12097932a611d
+timeCreated: 1502957708
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/MotionNote.cs

+using System;
+using System.Collections.Generic;
+
+public abstract class MotionNote : Note
+{
+    public MotionNote(float start, float end = 0f) : base(start, end) {}
+
+    public abstract IEnumerable<bool> Checkpoint();
+}
\ No newline at end of file

Assets/Script/MotionNote.cs.meta

+fileFormatVersion: 2
+guid: eeba9051af8880f41a239955c5efcbba
+timeCreated: 1502962272
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/MotionNotes.meta

+fileFormatVersion: 2
+guid: 4efccb64927c7ca42b4e8f01d7d25773
+folderAsset: yes
+timeCreated: 1502962628
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/MotionNotes/ClapNote.cs

+using System;
+using System.Collections.Generic;
+
+public class ClapNote : MotionNote
+{
+    public ClapNote(float timing) : base(timing) {
+
+    }
+
+    public override IEnumerable<bool> Checkpoint()
+    {
+        var motionState = InputManager.Instance.CurrentMotionState;
+        var motion = motionState.second;
+
+        while (motion != MotionState.CLAP_PREPARE)
+            yield return false;
+
+        Activated = true;
+
+        yield break;
+    }
+}

Assets/Script/MotionNotes/ClapNote.cs.meta

+fileFormatVersion: 2
+guid: 1a97249d2381dcc4492c416a96fde813
+timeCreated: 1502962628
+licenseType: Free
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Script/TrackInfo.cs

@@ -108,7 +108,11 @@ public class TrackInfo
 
                     float timing = (measure + (float)i / seq) * ms;
 
-                    if (channel[0] == 'S')
+                    if (channel == "SMO")
+                    {
+                        notes.Add(new ClapNote(timing));
+                    }
+                    else if (channel[0] == 'S')
                     {
                         notes.Add(new Note(key, channel, timing));
                     }

Assets/Sprites.meta

+fileFormatVersion: 2
+guid: 97b13591a96f8174d980197f404dcf8d
+folderAsset: yes
+timeCreated: 1502088321
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets.meta

+fileFormatVersion: 2
+guid: 5cf2eeaeb5141e545923973c7d827d6f
+folderAsset: yes
+timeCreated: 1502957664
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/CameraIntrinsics.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.CameraIntrinsics
+    //
+    [RootSystem.Runtime.InteropServices.StructLayout(RootSystem.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct CameraIntrinsics
+    {
+        public float FocalLengthX { get; set; }
+        public float FocalLengthY { get; set; }
+        public float PrincipalPointX { get; set; }
+        public float PrincipalPointY { get; set; }
+        public float RadialDistortionSecondOrder { get; set; }
+        public float RadialDistortionFourthOrder { get; set; }
+        public float RadialDistortionSixthOrder { get; set; }
+
+        public override int GetHashCode()
+        {
+            return FocalLengthX.GetHashCode() ^ FocalLengthY.GetHashCode() ^
+                PrincipalPointX.GetHashCode() ^ PrincipalPointY.GetHashCode() ^
+                RadialDistortionSecondOrder.GetHashCode() ^ RadialDistortionFourthOrder.GetHashCode() ^
+                RadialDistortionSixthOrder.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (!(obj is CameraIntrinsics))
+            {
+                return false;
+            }
+
+            return this.Equals((CameraIntrinsics)obj);
+        }
+
+        public bool Equals(CameraIntrinsics obj)
+        {
+            return FocalLengthX.Equals(obj.FocalLengthX) && FocalLengthY.Equals(obj.FocalLengthY) &&
+                PrincipalPointX.Equals(obj.PrincipalPointX) && PrincipalPointY.Equals(obj.PrincipalPointY) &&
+                RadialDistortionSecondOrder.Equals(obj.RadialDistortionSecondOrder) &&
+                RadialDistortionFourthOrder.Equals(obj.RadialDistortionFourthOrder) &&
+                RadialDistortionSixthOrder.Equals(obj.RadialDistortionSixthOrder);
+        }
+
+        public static bool operator ==(CameraIntrinsics a, CameraIntrinsics b)
+        {
+            return a.Equals(b);
+        }
+
+        public static bool operator !=(CameraIntrinsics a, CameraIntrinsics b)
+        {
+            return !(a.Equals(b));
+        }
+    }
+
+}

Assets/Standard Assets/CameraIntrinsics.cs.meta

+fileFormatVersion: 2
+guid: 1d7502d8680f38344a822b04f6589097
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/CollectionMap.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+namespace Helper
+{
+    class CollectionMap<TKey, TValue> : Helper.ThreadSafeDictionary<TKey, TValue> where TValue : new()
+    {
+        public bool TryAddDefault(TKey key)
+        {
+            lock (_impl)
+            {
+                if (!_impl.ContainsKey(key))
+                {
+                    _impl.Add(key, new TValue());
+                    return true;
+                }
+                else
+                {
+                    return false;
+                }
+            }
+        }
+    }
+}

Assets/Standard Assets/CollectionMap.cs.meta

+fileFormatVersion: 2
+guid: 5af24ef31b79af248965e672735626a3
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Editor.meta

+fileFormatVersion: 2
+guid: e11228902f41cb242bd8b1f16b364e24
+folderAsset: yes
+timeCreated: 1502957664
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Editor/KinectCopyPluginDataHelper.cs

+using UnityEngine;
+using UnityEditor;
+using System;
+using System.Collections.Generic;
+using System.IO;
+
+public static class KinectCopyPluginDataHelper
+{
+    private const string DataDirSuffix = "_Data";
+    private const string PluginsDirName = "Plugins";
+
+    private static Dictionary<BuildTarget, string> TargetToDirName = new Dictionary<BuildTarget, string>()
+        {
+            {BuildTarget.StandaloneWindows, "x86"},
+            {BuildTarget.StandaloneWindows64, "x86_64"}
+        };
+
+    public static void CopyPluginData(BuildTarget target, string buildTargetPath, string subDirToCopy)
+    {
+        string subDirName;
+        if (!TargetToDirName.TryGetValue (target, out subDirName))
+        {
+            // No work to do
+            return;
+        }
+
+        // Get Required Paths
+        var buildName = Path.GetFileNameWithoutExtension(buildTargetPath);
+        var targetDir = Directory.GetParent(buildTargetPath);
+        var separator = Path.DirectorySeparatorChar;
+
+        var buildDataDir = targetDir.FullName + separator + buildName + DataDirSuffix + separator;
+        var tgtPluginsDir = buildDataDir + separator + PluginsDirName + separator + subDirToCopy + separator;
+        var srcPluginsDir = Application.dataPath + separator + PluginsDirName + separator + subDirName + separator + subDirToCopy + separator;
+
+        CopyAll (new DirectoryInfo (srcPluginsDir), new DirectoryInfo(tgtPluginsDir));
+    }
+
+    /// <summary>
+    /// Recursive Copy Directory Method
+    /// </summary>
+    private static void CopyAll(DirectoryInfo source, DirectoryInfo target)
+    {
+        // Check if the source directory exists, if not, don't do any work.
+        if (!Directory.Exists(source.FullName))
+        {
+            return;
+        }
+
+        // Check if the target directory exists, if not, create it.
+        if (!Directory.Exists(target.FullName))
+        {
+            Directory.CreateDirectory(target.FullName);
+        }
+
+        // Copy each file into it’s new directory.
+        foreach (var fileInfo in source.GetFiles())
+        {
+            fileInfo.CopyTo (Path.Combine (target.ToString (), fileInfo.Name), true);
+        }
+        
+        // Copy each subdirectory using recursion.
+        foreach (var subDirInfo in source.GetDirectories())
+        {
+            DirectoryInfo nextTargetSubDir = target.CreateSubdirectory(subDirInfo.Name);
+            CopyAll(subDirInfo, nextTargetSubDir);
+        }
+    }
+
+}

Assets/Standard Assets/Editor/KinectCopyPluginDataHelper.cs.meta

+fileFormatVersion: 2
+guid: 992490f149d571a4bb003838d2ac33c5
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Editor/KinectVisualGestureBuilderPostBuildCopyPluginData.cs

+using UnityEditor;
+using UnityEditor.Callbacks;
+using System;
+
+public static class KinectVisualGestureBuilderPostBuildCopyPluginData
+{
+    [PostProcessBuild]
+    public static void OnPostProcessBuild(BuildTarget target, string path)
+    {
+        KinectCopyPluginDataHelper.CopyPluginData (target, path, "vgbtechs");
+    }
+}

Assets/Standard Assets/Editor/KinectVisualGestureBuilderPostBuildCopyPluginData.cs.meta

+fileFormatVersion: 2
+guid: b57003b3c57eec84685a31008f2876e4
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/EventPump.cs

+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Linq;
+
+namespace Helper
+{
+    internal class EventPump : UnityEngine.MonoBehaviour
+    {
+        private static object s_Lock = new object();
+        private Queue<Action> m_Queue = new Queue<Action>();
+
+        public static EventPump Instance
+        {
+            get;
+            private set;
+        }
+
+        public static void EnsureInitialized()
+        {
+            try
+            {
+                if (EventPump.Instance == null)
+                {
+                    lock (s_Lock)
+                    {
+                        if (EventPump.Instance == null)
+                        {
+                            UnityEngine.GameObject parent = new UnityEngine.GameObject("Kinect Desktop Event Pump");
+                            EventPump.Instance = parent.AddComponent<Helper.EventPump>();
+                            DontDestroyOnLoad(parent);
+                        }
+                    }
+                }
+            }
+            catch
+            {
+                UnityEngine.Debug.LogError("Events must be registered on the main thread.");
+                return;
+            }
+        }
+
+        private void Update()
+        {
+            lock (m_Queue)
+            {
+                while (m_Queue.Count > 0)
+                {
+                    var action = m_Queue.Dequeue();
+                    try
+                    {
+                        action.Invoke();
+                    }
+                    catch { }
+                }
+            }
+        }
+
+        private void OnApplicationQuit()
+        {
+            var sensor = Windows.Kinect.KinectSensor.GetDefault();
+            if (sensor != null && sensor.IsOpen)
+            {
+                sensor.Close();
+            }
+
+            NativeObjectCache.Flush();
+        }
+
+        public void Enqueue(Action action)
+        {
+            lock (m_Queue)
+            {
+                m_Queue.Enqueue(action);
+            }
+        }
+    }
+}
\ No newline at end of file

Assets/Standard Assets/EventPump.cs.meta

+fileFormatVersion: 2
+guid: eb47e8e15bc900141b610bf206931fd3
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/ExceptionHelper.cs

+using System;
+using System.Runtime.InteropServices;
+
+namespace Helper
+{
+    public static class ExceptionHelper
+    {
+        private const int E_NOTIMPL = unchecked((int)0x80004001);
+        private const int E_OUTOFMEMORY = unchecked((int)0x8007000E);
+        private const int E_INVALIDARG = unchecked((int)0x80070057);
+        private const int E_POINTER = unchecked((int) 0x80004003);
+        private const int E_PENDING = unchecked((int)0x8000000A);
+        private const int E_FAIL = unchecked((int)0x80004005);
+
+        public static void CheckLastError()
+        {
+            int hr = Marshal.GetLastWin32Error();
+
+            if ((hr == E_PENDING) || (hr == E_FAIL))
+            {
+                // Ignore E_PENDING/E_FAIL - We use this to indicate no pending or missed frames
+                return;
+            }
+
+            if (hr < 0)
+            {
+                Exception exception = Marshal.GetExceptionForHR(hr);
+                string message = string.Format("This API has returned an exception from an HRESULT: 0x{0:X}", hr);
+
+                switch (hr)
+                {
+                    case E_NOTIMPL:
+                        throw new NotImplementedException(message, exception);
+
+                    case E_OUTOFMEMORY:
+                        throw new OutOfMemoryException(message, exception);
+
+                    case E_INVALIDARG:
+                        throw new ArgumentException(message, exception);
+
+                    case E_POINTER:
+                        throw new ArgumentNullException(message, exception);
+
+                    default:
+                        throw new InvalidOperationException(message, exception);
+                }
+            }
+        }
+    }
+}
\ No newline at end of file

Assets/Standard Assets/ExceptionHelper.cs.meta

+fileFormatVersion: 2
+guid: 2c60ec64b7307604bba5b0cae3bfbdb7
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/INativeWrapper.cs

+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Linq;
+
+namespace Helper
+{
+    internal interface INativeWrapper
+    {
+        System.IntPtr nativePtr { get; }
+    }
+}
\ No newline at end of file

Assets/Standard Assets/INativeWrapper.cs.meta

+fileFormatVersion: 2
+guid: 3c63fb408f75ea84a914dde0bedf5db6
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/KinectBuffer.cs

+using RootSystem = System;
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace Windows.Kinect
+{
+    // NOTE: This uses an IBuffer under the covers, it is renamed here to give parity to our managed APIs.
+    public class KinectBuffer : Helper.INativeWrapper, IDisposable
+    {
+        internal RootSystem.IntPtr _pNative;
+
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal KinectBuffer(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Storage_Streams_IBuffer_AddRefObject(ref _pNative);
+        }
+
+        ~KinectBuffer()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private static extern void Windows_Storage_Streams_IBuffer_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private static extern void Windows_Storage_Streams_IBuffer_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Helper.NativeObjectCache.RemoveObject<KinectBuffer>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Storage_Streams_IBuffer_Dispose(_pNative);
+            }
+
+            Windows_Storage_Streams_IBuffer_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern uint Windows_Storage_Streams_IBuffer_get_Capacity(RootSystem.IntPtr pNative);
+        public uint Capacity
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectBuffer");
+                }
+
+                uint capacity = Windows_Storage_Streams_IBuffer_get_Capacity(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                return capacity;
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern uint Windows_Storage_Streams_IBuffer_get_Length(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern void Windows_Storage_Streams_IBuffer_put_Length(RootSystem.IntPtr pNative, uint value);
+        public uint Length
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectBuffer");
+                }
+
+                uint length = Windows_Storage_Streams_IBuffer_get_Length(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                return length;
+            }
+            set
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectBuffer");
+                }
+
+                Windows_Storage_Streams_IBuffer_put_Length(_pNative, value);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private static extern void Windows_Storage_Streams_IBuffer_Dispose(RootSystem.IntPtr pNative);
+        // Constructors and Finalizers
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("KinectBuffer");
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern RootSystem.IntPtr Windows_Storage_Streams_IBuffer_get_UnderlyingBuffer(RootSystem.IntPtr pNative);
+        public IntPtr UnderlyingBuffer
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectBuffer");
+                }
+
+                RootSystem.IntPtr value = Windows_Storage_Streams_IBuffer_get_UnderlyingBuffer(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                return value;
+            }
+        }
+    }
+}
\ No newline at end of file

Assets/Standard Assets/KinectBuffer.cs.meta

+fileFormatVersion: 2
+guid: 041b09b5123e8c04d82d9fadf4e38ea9
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/KinectSpecialCases.cs

+using RootSystem = System;
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace Windows.Kinect
+{
+    [RootSystem.Runtime.InteropServices.StructLayout(RootSystem.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct PointF
+    {
+        public float X { get; set; }
+        public float Y { get; set; }
+
+        public override int GetHashCode()
+        {
+            return X.GetHashCode() ^ Y.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (!(obj is PointF))
+            {
+                return false;
+            }
+
+            return this.Equals((ColorSpacePoint)obj);
+        }
+
+        public bool Equals(ColorSpacePoint obj)
+        {
+            return (X == obj.X) && (Y == obj.Y);
+        }
+
+        public static bool operator ==(PointF a, PointF b)
+        {
+            return a.Equals(b);
+        }
+
+        public static bool operator !=(PointF a, PointF b)
+        {
+            return !(a.Equals(b));
+        }
+    }
+
+    public sealed partial class AudioBeamSubFrame
+    {
+        [RootSystem.Runtime.InteropServices.DllImport(
+            "KinectUnityAddin",
+            EntryPoint = "Windows_Kinect_AudioBeamSubFrame_CopyFrameDataToArray",
+            CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl,
+            SetLastError = true)]
+        private static extern void Windows_Kinect_AudioBeamSubFrame_CopyFrameDataToIntPtr(RootSystem.IntPtr pNative, RootSystem.IntPtr frameData, uint frameDataSize);
+        public void CopyFrameDataToIntPtr(RootSystem.IntPtr frameData, uint size)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("AudioBeamSubFrame");
+            }
+
+            Windows_Kinect_AudioBeamSubFrame_CopyFrameDataToIntPtr(_pNative, frameData, size);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_AudioBeamSubFrame_LockAudioBuffer(RootSystem.IntPtr pNative);
+        public Windows.Kinect.KinectBuffer LockAudioBuffer()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("AudioBeamSubFrame");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_AudioBeamSubFrame_LockAudioBuffer(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectBuffer>(objectPointer, n => new Windows.Kinect.KinectBuffer(n));
+        }
+    }
+
+    public sealed partial class AudioBeamFrame
+    {
+        private Windows.Kinect.AudioBeamSubFrame[] _subFrames = null;
+
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            if (_subFrames != null)
+            {
+                foreach (var subFrame in _subFrames)
+                {
+                    subFrame.Dispose();
+                }
+
+                _subFrames = null;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<AudioBeamFrame>(_pNative);
+            Windows_Kinect_AudioBeamFrame_ReleaseObject(ref _pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_AudioBeamFrame_Dispose(_pNative);
+            }
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private static extern void Windows_Kinect_AudioBeamFrame_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern int Windows_Kinect_AudioBeamFrame_get_SubFrames(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] RootSystem.IntPtr[] outCollection, int outCollectionSize);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private static extern int Windows_Kinect_AudioBeamFrame_get_SubFrames_Length(RootSystem.IntPtr pNative);
+        public RootSystem.Collections.Generic.IList<Windows.Kinect.AudioBeamSubFrame> SubFrames
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamFrame");
+                }
+
+                if (_subFrames == null)
+                {
+                    int collectionSize = Windows_Kinect_AudioBeamFrame_get_SubFrames_Length(_pNative);
+                    var outCollection = new RootSystem.IntPtr[collectionSize];
+                    _subFrames = new Windows.Kinect.AudioBeamSubFrame[collectionSize];
+
+                    collectionSize = Windows_Kinect_AudioBeamFrame_get_SubFrames(_pNative, outCollection, collectionSize);
+                    Helper.ExceptionHelper.CheckLastError();
+
+                    for (int i = 0; i < collectionSize; i++)
+                    {
+                        if (outCollection[i] == RootSystem.IntPtr.Zero)
+                        {
+                            continue;
+                        }
+
+                        var obj = Helper.NativeObjectCache.GetObject<Windows.Kinect.AudioBeamSubFrame>(outCollection[i]);
+                        if (obj == null)
+                        {
+                            obj = new Windows.Kinect.AudioBeamSubFrame(outCollection[i]);
+                            Helper.NativeObjectCache.AddObject<Windows.Kinect.AudioBeamSubFrame>(outCollection[i], obj);
+                        }
+
+                        _subFrames[i] = obj;
+                    }
+                }
+
+                return _subFrames;
+            }
+        }
+    }
+
+    public sealed partial class BodyFrame
+    {
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern void Windows_Kinect_BodyFrame_GetAndRefreshBodyData(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] RootSystem.IntPtr[] bodies, int bodiesSize);
+        public void GetAndRefreshBodyData(RootSystem.Collections.Generic.IList<Windows.Kinect.Body> bodies)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("BodyFrame");
+            }
+
+            int _bodies_idx = 0;
+            var _bodies = new RootSystem.IntPtr[bodies.Count];
+            for (int i = 0; i < bodies.Count; i++)
+            {
+                if (bodies[i] == null)
+                {
+                    bodies[i] = new Body();
+                }
+
+                _bodies[_bodies_idx] = bodies[i].GetIntPtr();
+                _bodies_idx++;
+            }
+
+            Windows_Kinect_BodyFrame_GetAndRefreshBodyData(_pNative, _bodies, bodies.Count);
+            Helper.ExceptionHelper.CheckLastError();
+
+            for (int i = 0; i < bodies.Count; i++)
+            {
+                bodies[i].SetIntPtr(_bodies[i]);
+            }
+        }
+    }
+
+    public sealed partial class Body
+    {
+        internal void SetIntPtr(RootSystem.IntPtr value) { _pNative = value; }
+        internal RootSystem.IntPtr GetIntPtr() { return _pNative; }
+
+        internal Body() { }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_Body_get_Lean(RootSystem.IntPtr pNative);
+        public Windows.Kinect.PointF Lean
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                var objectPointer = Windows_Kinect_Body_get_Lean(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+
+                var obj = (Windows.Kinect.PointF)RootSystem.Runtime.InteropServices.Marshal.PtrToStructure(objectPointer, typeof(Windows.Kinect.PointF));
+                RootSystem.Runtime.InteropServices.Marshal.FreeHGlobal(objectPointer);
+                return obj;
+            }
+        }
+    }
+
+    public sealed partial class ColorFrame
+    {
+        [RootSystem.Runtime.InteropServices.DllImport(
+            "KinectUnityAddin",
+            EntryPoint = "Windows_Kinect_ColorFrame_CopyRawFrameDataToArray",
+            CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl,
+            SetLastError = true)]
+        private static extern void Windows_Kinect_ColorFrame_CopyRawFrameDataToIntPtr(RootSystem.IntPtr pNative, IntPtr frameData, uint frameDataSize);
+        public void CopyRawFrameDataToIntPtr(RootSystem.IntPtr frameData, uint size)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("ColorFrame");
+            }
+
+            Windows_Kinect_ColorFrame_CopyRawFrameDataToIntPtr(_pNative, frameData, size);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport(
+            "KinectUnityAddin",
+            EntryPoint = "Windows_Kinect_ColorFrame_CopyConvertedFrameDataToArray",
+            CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl,
+            SetLastError = true)]
+        private static extern void Windows_Kinect_ColorFrame_CopyConvertedFrameDataToIntPtr(RootSystem.IntPtr pNative, IntPtr frameData, uint frameDataSize, Windows.Kinect.ColorImageFormat colorFormat);
+        public void CopyConvertedFrameDataToIntPtr(RootSystem.IntPtr frameData, uint size, Windows.Kinect.ColorImageFormat colorFormat)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("ColorFrame");
+            }
+
+            Windows_Kinect_ColorFrame_CopyConvertedFrameDataToIntPtr(_pNative, frameData, size, colorFormat);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_ColorFrame_LockRawImageBuffer(RootSystem.IntPtr pNative);
+        public Windows.Kinect.KinectBuffer LockRawImageBuffer()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("ColorFrame");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_ColorFrame_LockRawImageBuffer(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectBuffer>(objectPointer, n => new Windows.Kinect.KinectBuffer(n));
+        }
+
+    }
+
+    public sealed partial class DepthFrame
+    {
+        [RootSystem.Runtime.InteropServices.DllImport(
+            "KinectUnityAddin",
+            EntryPoint = "Windows_Kinect_DepthFrame_CopyFrameDataToArray",
+            CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl,
+            SetLastError = true)]
+        private static extern void Windows_Kinect_DepthFrame_CopyFrameDataToIntPtr(RootSystem.IntPtr pNative, IntPtr frameData, uint frameDataSize);
+        public void CopyFrameDataToIntPtr(RootSystem.IntPtr frameData, uint size)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("DepthFrame");
+            }
+
+            Windows_Kinect_DepthFrame_CopyFrameDataToIntPtr(_pNative, frameData, size / sizeof(ushort));
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_DepthFrame_LockImageBuffer(RootSystem.IntPtr pNative);
+        public Windows.Kinect.KinectBuffer LockImageBuffer()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("DepthFrame");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_DepthFrame_LockImageBuffer(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectBuffer>(objectPointer, n => new Windows.Kinect.KinectBuffer(n));
+        }
+    }
+
+    public sealed partial class BodyIndexFrame
+    {
+        [RootSystem.Runtime.InteropServices.DllImport(
+            "KinectUnityAddin",
+            EntryPoint = "Windows_Kinect_BodyIndexFrame_CopyFrameDataToArray",
+            CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl,
+            SetLastError = true)]
+        private static extern void Windows_Kinect_BodyIndexFrame_CopyFrameDataToIntPtr(RootSystem.IntPtr pNative, IntPtr frameData, uint frameDataSize);
+        public void CopyFrameDataToIntPtr(RootSystem.IntPtr frameData, uint size)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("BodyIndexFrame");
+            }
+
+            Windows_Kinect_BodyIndexFrame_CopyFrameDataToIntPtr(_pNative, frameData, size);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyIndexFrame_LockImageBuffer(RootSystem.IntPtr pNative);
+        public Windows.Kinect.KinectBuffer LockImageBuffer()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("BodyIndexFrame");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_BodyIndexFrame_LockImageBuffer(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectBuffer>(objectPointer, n => new Windows.Kinect.KinectBuffer(n));
+        }
+
+    }
+
+    public sealed partial class InfraredFrame
+    {
+        [RootSystem.Runtime.InteropServices.DllImport(
+            "KinectUnityAddin",
+            EntryPoint = "Windows_Kinect_InfraredFrame_CopyFrameDataToArray",
+            CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl,
+            SetLastError = true)]
+        private static extern void Windows_Kinect_InfraredFrame_CopyFrameDataToIntPtr(RootSystem.IntPtr pNative, IntPtr frameData, uint frameDataSize);
+        public void CopyFrameDataToIntPtr(RootSystem.IntPtr frameData, uint size)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("InfraredFrame");
+            }
+
+            Windows_Kinect_InfraredFrame_CopyFrameDataToIntPtr(_pNative, frameData, size / sizeof(ushort));
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_InfraredFrame_LockImageBuffer(RootSystem.IntPtr pNative);
+        public Windows.Kinect.KinectBuffer LockImageBuffer()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("InfraredFrame");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_InfraredFrame_LockImageBuffer(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectBuffer>(objectPointer, n => new Windows.Kinect.KinectBuffer(n));
+        }
+
+    }
+
+    public sealed partial class KinectSensor
+    {
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            if (IsOpen)
+            {
+                Close();
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<KinectSensor>(_pNative);
+            Windows_Kinect_KinectSensor_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+    }
+
+    public sealed partial class LongExposureInfraredFrame
+    {
+        [RootSystem.Runtime.InteropServices.DllImport(
+            "KinectUnityAddin",
+            EntryPoint = "Windows_Kinect_LongExposureInfraredFrame_CopyFrameDataToArray",
+            CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl,
+            SetLastError = true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrame_CopyFrameDataToIntPtr(RootSystem.IntPtr pNative, IntPtr frameData, uint frameDataSize);
+        public void CopyFrameDataToIntPtr(RootSystem.IntPtr frameData, uint size)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrame");
+            }
+
+            Windows_Kinect_LongExposureInfraredFrame_CopyFrameDataToIntPtr(_pNative, frameData, size / sizeof(ushort));
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_LongExposureInfraredFrame_LockImageBuffer(RootSystem.IntPtr pNative);
+        public Windows.Kinect.KinectBuffer LockImageBuffer()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrame");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_LongExposureInfraredFrame_LockImageBuffer(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectBuffer>(objectPointer, n => new Windows.Kinect.KinectBuffer(n));
+        }
+
+    }
+
+    public sealed partial class CoordinateMapper
+    {
+        private PointF[] _DepthFrameToCameraSpaceTable = null;
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_CoordinateMapper_GetDepthCameraIntrinsics(RootSystem.IntPtr pNative);
+        public Windows.Kinect.CameraIntrinsics GetDepthCameraIntrinsics()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            var objectPointer = Windows_Kinect_CoordinateMapper_GetDepthCameraIntrinsics(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+
+            var obj = (Windows.Kinect.CameraIntrinsics)RootSystem.Runtime.InteropServices.Marshal.PtrToStructure(objectPointer, typeof(Windows.Kinect.CameraIntrinsics));
+            RootSystem.Runtime.InteropServices.Marshal.FreeHGlobal(objectPointer);
+            return obj;
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern int Windows_Kinect_CoordinateMapper_GetDepthFrameToCameraSpaceTable(RootSystem.IntPtr pNative, RootSystem.IntPtr outCollection, uint outCollectionSize);
+        public Windows.Kinect.PointF[] GetDepthFrameToCameraSpaceTable()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            if (_DepthFrameToCameraSpaceTable == null)
+            {
+                var desc = KinectSensor.GetDefault().DepthFrameSource.FrameDescription;
+                _DepthFrameToCameraSpaceTable = new PointF[desc.Width * desc.Height];
+
+                var pointsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(_DepthFrameToCameraSpaceTable, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+                var _points = pointsSmartGCHandle.AddrOfPinnedObject();
+                Windows_Kinect_CoordinateMapper_GetDepthFrameToCameraSpaceTable(_pNative, _points, (uint)_DepthFrameToCameraSpaceTable.Length);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+
+            return _DepthFrameToCameraSpaceTable;
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern void Windows_Kinect_CoordinateMapper_MapColorFrameToDepthSpace(
+            RootSystem.IntPtr pNative,
+            RootSystem.IntPtr depthFrameData,
+            uint depthFrameDataSize,
+            RootSystem.IntPtr depthSpacePoints,
+            uint depthSpacePointsSize);
+        public void MapColorFrameToDepthSpaceUsingIntPtr(RootSystem.IntPtr depthFrameData, uint depthFrameSize, RootSystem.IntPtr depthSpacePoints, uint depthSpacePointsSize)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            uint length = depthFrameSize / sizeof(UInt16);
+            Windows_Kinect_CoordinateMapper_MapColorFrameToDepthSpace(_pNative, depthFrameData, length, depthSpacePoints, depthSpacePointsSize);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern void Windows_Kinect_CoordinateMapper_MapColorFrameToCameraSpace(
+            RootSystem.IntPtr pNative,
+            RootSystem.IntPtr depthFrameData,
+            uint depthFrameDataSize,
+            RootSystem.IntPtr cameraSpacePoints,
+            uint cameraSpacePointsSize);
+        public void MapColorFrameToCameraSpaceUsingIntPtr(RootSystem.IntPtr depthFrameData, int depthFrameSize, RootSystem.IntPtr cameraSpacePoints, uint cameraSpacePointsSize)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            uint length = (uint)depthFrameSize / sizeof(UInt16);
+            Windows_Kinect_CoordinateMapper_MapColorFrameToCameraSpace(_pNative, depthFrameData, length, cameraSpacePoints, cameraSpacePointsSize);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern void Windows_Kinect_CoordinateMapper_MapDepthFrameToColorSpace(
+            RootSystem.IntPtr pNative,
+            RootSystem.IntPtr depthFrameData,
+            uint depthFrameDataSize,
+            RootSystem.IntPtr colorSpacePoints,
+            uint colorSpacePointsSize);
+        public void MapDepthFrameToColorSpaceUsingIntPtr(RootSystem.IntPtr depthFrameData, int depthFrameSize, RootSystem.IntPtr colorSpacePoints, uint colorSpacePointsSize)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            uint length = (uint)depthFrameSize / sizeof(UInt16);
+            Windows_Kinect_CoordinateMapper_MapDepthFrameToColorSpace(_pNative, depthFrameData, length, colorSpacePoints, colorSpacePointsSize);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError = true)]
+        private static extern void Windows_Kinect_CoordinateMapper_MapDepthFrameToCameraSpace(
+            RootSystem.IntPtr pNative,
+            IntPtr depthFrameData,
+            uint depthFrameDataSize,
+            RootSystem.IntPtr cameraSpacePoints,
+            uint cameraSpacePointsSize);
+        public void MapDepthFrameToCameraSpaceUsingIntPtr(RootSystem.IntPtr depthFrameData, int depthFrameSize, RootSystem.IntPtr cameraSpacePoints, uint cameraSpacePointsSize)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            uint length = (uint)depthFrameSize / sizeof(UInt16);
+            Windows_Kinect_CoordinateMapper_MapDepthFrameToCameraSpace(_pNative, depthFrameData, length, cameraSpacePoints, cameraSpacePointsSize);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+    }
+}

Assets/Standard Assets/KinectSpecialCases.cs.meta

+fileFormatVersion: 2
+guid: c59b79770236fae42a76e291570f2447
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/KinectVisualGestureBuilderSpecialCases.cs

+using RootSystem = System;
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace Microsoft.Kinect.VisualGestureBuilder
+{
+    public sealed partial class VisualGestureBuilderDatabase
+    {
+        [RootSystem.Runtime.InteropServices.DllImport(
+            "KinectVisualGestureBuilderUnityAddin",
+            EntryPoint = "Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderDatabase_ctor",
+            CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private static extern RootSystem.IntPtr Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderDatabase_ctor([MarshalAs(UnmanagedType.LPWStr)]string path);
+        public static VisualGestureBuilderDatabase Create(string path)
+        {
+            RootSystem.IntPtr objectPointer = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderDatabase_ctor(path);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderDatabase>(
+                objectPointer, n => new Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderDatabase(n));
+        }
+    }
+
+    public sealed partial class VisualGestureBuilderFrameSource
+    {
+        [RootSystem.Runtime.InteropServices.DllImport(
+            "KinectVisualGestureBuilderUnityAddin",
+            EntryPoint = "Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_ctor",
+            CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private static extern RootSystem.IntPtr Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_ctor(RootSystem.IntPtr sensorPtr, ulong initialTrackingId);
+        public static VisualGestureBuilderFrameSource Create(Windows.Kinect.KinectSensor sensor, ulong initialTrackingId)
+        {
+            RootSystem.IntPtr objectPointer = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_ctor(Helper.NativeWrapper.GetNativePtr(sensor), initialTrackingId);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameSource>(
+                objectPointer, n => new Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameSource(n));
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport(
+            "KinectVisualGestureBuilderUnityAddin",
+            EntryPoint = "Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_GetIsEnabled",
+            CallingConvention = RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private static extern bool Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_GetIsEnabled(RootSystem.IntPtr pNative, RootSystem.IntPtr gesturePtr);
+        public bool GetIsEnabled(Microsoft.Kinect.VisualGestureBuilder.Gesture gesture)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameSource");
+            }
+
+            var result = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_GetIsEnabled(_pNative, Helper.NativeWrapper.GetNativePtr(gesture));
+            Helper.ExceptionHelper.CheckLastError();
+            return result;
+        }
+    }
+}
\ No newline at end of file

Assets/Standard Assets/KinectVisualGestureBuilderSpecialCases.cs.meta

+fileFormatVersion: 2
+guid: 485600beef8b3194a94d471e24181020
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft.meta

+fileFormatVersion: 2
+guid: 1205289338cc2a04785ba3d26477b300
+folderAsset: yes
+timeCreated: 1502958445
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft/Kinect.meta

+fileFormatVersion: 2
+guid: 46e2a41736f788a478d357ee5e6ec601
+folderAsset: yes
+timeCreated: 1502958445
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder.meta

+fileFormatVersion: 2
+guid: 0ef9aefeeafdaac429ef13524278f572
+folderAsset: yes
+timeCreated: 1502958445
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/ContinuousGestureResult.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Microsoft.Kinect.VisualGestureBuilder
+{
+    //
+    // Microsoft.Kinect.VisualGestureBuilder.ContinuousGestureResult
+    //
+    public sealed partial class ContinuousGestureResult : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal ContinuousGestureResult(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Microsoft_Kinect_VisualGestureBuilder_ContinuousGestureResult_AddRefObject(ref _pNative);
+        }
+
+        ~ContinuousGestureResult()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_ContinuousGestureResult_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_ContinuousGestureResult_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<ContinuousGestureResult>(_pNative);
+                Microsoft_Kinect_VisualGestureBuilder_ContinuousGestureResult_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern float Microsoft_Kinect_VisualGestureBuilder_ContinuousGestureResult_get_Progress(RootSystem.IntPtr pNative);
+        public  float Progress
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ContinuousGestureResult");
+                }
+
+                return Microsoft_Kinect_VisualGestureBuilder_ContinuousGestureResult_get_Progress(_pNative);
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/ContinuousGestureResult.cs.meta

+fileFormatVersion: 2
+guid: 39ba8f678e5073b44804c65fbbaf302c
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/DiscreteGestureResult.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Microsoft.Kinect.VisualGestureBuilder
+{
+    //
+    // Microsoft.Kinect.VisualGestureBuilder.DiscreteGestureResult
+    //
+    public sealed partial class DiscreteGestureResult : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal DiscreteGestureResult(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Microsoft_Kinect_VisualGestureBuilder_DiscreteGestureResult_AddRefObject(ref _pNative);
+        }
+
+        ~DiscreteGestureResult()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_DiscreteGestureResult_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_DiscreteGestureResult_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<DiscreteGestureResult>(_pNative);
+                Microsoft_Kinect_VisualGestureBuilder_DiscreteGestureResult_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern float Microsoft_Kinect_VisualGestureBuilder_DiscreteGestureResult_get_Confidence(RootSystem.IntPtr pNative);
+        public  float Confidence
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DiscreteGestureResult");
+                }
+
+                return Microsoft_Kinect_VisualGestureBuilder_DiscreteGestureResult_get_Confidence(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Microsoft_Kinect_VisualGestureBuilder_DiscreteGestureResult_get_Detected(RootSystem.IntPtr pNative);
+        public  bool Detected
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DiscreteGestureResult");
+                }
+
+                return Microsoft_Kinect_VisualGestureBuilder_DiscreteGestureResult_get_Detected(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Microsoft_Kinect_VisualGestureBuilder_DiscreteGestureResult_get_FirstFrameDetected(RootSystem.IntPtr pNative);
+        public  bool FirstFrameDetected
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DiscreteGestureResult");
+                }
+
+                return Microsoft_Kinect_VisualGestureBuilder_DiscreteGestureResult_get_FirstFrameDetected(_pNative);
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/DiscreteGestureResult.cs.meta

+fileFormatVersion: 2
+guid: 348b878afc4a938499c34b47772438f3
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/Gesture.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Microsoft.Kinect.VisualGestureBuilder
+{
+    //
+    // Microsoft.Kinect.VisualGestureBuilder.Gesture
+    //
+    public sealed partial class Gesture : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal Gesture(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Microsoft_Kinect_VisualGestureBuilder_Gesture_AddRefObject(ref _pNative);
+        }
+
+        ~Gesture()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_Gesture_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_Gesture_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<Gesture>(_pNative);
+                Microsoft_Kinect_VisualGestureBuilder_Gesture_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Microsoft.Kinect.VisualGestureBuilder.GestureType Microsoft_Kinect_VisualGestureBuilder_Gesture_get_GestureType(RootSystem.IntPtr pNative);
+        public  Microsoft.Kinect.VisualGestureBuilder.GestureType GestureType
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Gesture");
+                }
+
+                return Microsoft_Kinect_VisualGestureBuilder_Gesture_get_GestureType(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Microsoft_Kinect_VisualGestureBuilder_Gesture_get_Name(RootSystem.IntPtr pNative);
+        public  string Name
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Gesture");
+                }
+
+                RootSystem.IntPtr objectPointer = Microsoft_Kinect_VisualGestureBuilder_Gesture_get_Name(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+
+                var managedString = RootSystem.Runtime.InteropServices.Marshal.PtrToStringUni(objectPointer);
+                RootSystem.Runtime.InteropServices.Marshal.FreeCoTaskMem(objectPointer);
+                return managedString;
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/Gesture.cs.meta

+fileFormatVersion: 2
+guid: a84b2c069de62a14c94940154ec6f7da
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/GestureType.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Microsoft.Kinect.VisualGestureBuilder
+{
+    //
+    // Microsoft.Kinect.VisualGestureBuilder.GestureType
+    //
+    public enum GestureType : int
+    {
+        None                                     =0,
+        Discrete                                 =1,
+        Continuous                               =2,
+    }
+
+}

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/GestureType.cs.meta

+fileFormatVersion: 2
+guid: 75c13895e20797f4fadf7ce99a885eb9
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/KinectVisualGestureBuilderUnityAddinUtils.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Microsoft.Kinect.VisualGestureBuilder
+{
+    //
+    // Microsoft.Kinect.VisualGestureBuilder.KinectVisualGestureBuilderUnityAddinUtils
+    //
+    public sealed partial class KinectVisualGestureBuilderUnityAddinUtils
+    {
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void KinectVisualGestureBuilderUnityAddin_FreeMemory(RootSystem.IntPtr pToDealloc);
+        public static void FreeMemory(RootSystem.IntPtr pToDealloc)
+        {
+            KinectVisualGestureBuilderUnityAddin_FreeMemory(pToDealloc);
+        }
+    }
+
+}

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/KinectVisualGestureBuilderUnityAddinUtils.cs.meta

+fileFormatVersion: 2
+guid: 2d5a0b5ff72c39a4e95865b317bd147d
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/TrackingIdLostEventArgs.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Microsoft.Kinect.VisualGestureBuilder
+{
+    //
+    // Microsoft.Kinect.VisualGestureBuilder.TrackingIdLostEventArgs
+    //
+    public sealed partial class TrackingIdLostEventArgs : RootSystem.EventArgs, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal TrackingIdLostEventArgs(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_AddRefObject(ref _pNative);
+        }
+
+        ~TrackingIdLostEventArgs()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<TrackingIdLostEventArgs>(_pNative);
+                Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern ulong Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_get_TrackingId(RootSystem.IntPtr pNative);
+        public  ulong TrackingId
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("TrackingIdLostEventArgs");
+                }
+
+                return Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_get_TrackingId(_pNative);
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/TrackingIdLostEventArgs.cs.meta

+fileFormatVersion: 2
+guid: fa8002d3a67f41f48bfaa702a83320ae
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/VisualGestureBuilderDatabase.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Microsoft.Kinect.VisualGestureBuilder
+{
+    //
+    // Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderDatabase
+    //
+    public sealed partial class VisualGestureBuilderDatabase : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal VisualGestureBuilderDatabase(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderDatabase_AddRefObject(ref _pNative);
+        }
+
+        ~VisualGestureBuilderDatabase()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderDatabase_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderDatabase_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<VisualGestureBuilderDatabase>(_pNative);
+
+            if (disposing)
+            {
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderDatabase_Dispose(_pNative);
+            }
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderDatabase_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderDatabase_get_AvailableGestures(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] RootSystem.IntPtr[] outCollection, int outCollectionSize);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderDatabase_get_AvailableGestures_Length(RootSystem.IntPtr pNative);
+        public  RootSystem.Collections.Generic.IList<Microsoft.Kinect.VisualGestureBuilder.Gesture> AvailableGestures
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderDatabase");
+                }
+
+                int outCollectionSize = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderDatabase_get_AvailableGestures_Length(_pNative);
+                var outCollection = new RootSystem.IntPtr[outCollectionSize];
+                var managedCollection = new Microsoft.Kinect.VisualGestureBuilder.Gesture[outCollectionSize];
+
+                outCollectionSize = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderDatabase_get_AvailableGestures(_pNative, outCollection, outCollectionSize);
+                Helper.ExceptionHelper.CheckLastError();
+                for(int i=0;i<outCollectionSize;i++)
+                {
+                    if(outCollection[i] == RootSystem.IntPtr.Zero)
+                    {
+                        continue;
+                    }
+
+                    var obj = Helper.NativeObjectCache.CreateOrGetObject<Microsoft.Kinect.VisualGestureBuilder.Gesture>(outCollection[i], n => new Microsoft.Kinect.VisualGestureBuilder.Gesture(n));
+
+                    managedCollection[i] = obj;
+                }
+                return managedCollection;
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderDatabase_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/VisualGestureBuilderDatabase.cs.meta

+fileFormatVersion: 2
+guid: 9f131b0b4bd823f408e9f36fa0f4b620
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/VisualGestureBuilderFrame.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Microsoft.Kinect.VisualGestureBuilder
+{
+    //
+    // Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrame
+    //
+    public sealed partial class VisualGestureBuilderFrame : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal VisualGestureBuilderFrame(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_AddRefObject(ref _pNative);
+        }
+
+        ~VisualGestureBuilderFrame()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<VisualGestureBuilderFrame>(_pNative);
+
+            if (disposing)
+            {
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_Dispose(_pNative);
+            }
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_ContinuousGestureResults(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] RootSystem.IntPtr[] outKeys, [RootSystem.Runtime.InteropServices.Out] RootSystem.IntPtr[] outValues, int outCollectionSize);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_ContinuousGestureResults_Length(RootSystem.IntPtr pNative);
+        public  RootSystem.Collections.Generic.Dictionary<Microsoft.Kinect.VisualGestureBuilder.Gesture, Microsoft.Kinect.VisualGestureBuilder.ContinuousGestureResult> ContinuousGestureResults
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrame");
+                }
+
+                int outCollectionSize = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_ContinuousGestureResults_Length(_pNative);
+                var outKeys = new RootSystem.IntPtr[outCollectionSize];
+                var outValues = new RootSystem.IntPtr[outCollectionSize];
+                var managedDictionary = new RootSystem.Collections.Generic.Dictionary<Microsoft.Kinect.VisualGestureBuilder.Gesture, Microsoft.Kinect.VisualGestureBuilder.ContinuousGestureResult>();
+
+                outCollectionSize = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_ContinuousGestureResults(_pNative, outKeys, outValues, outCollectionSize);
+                Helper.ExceptionHelper.CheckLastError();
+                for(int i=0;i<outCollectionSize;i++)
+                {
+                    if(outKeys[i] == RootSystem.IntPtr.Zero || outValues[i] == RootSystem.IntPtr.Zero)
+                    {
+                        continue;
+                    }
+
+                    var keyObj = Helper.NativeObjectCache.CreateOrGetObject<Microsoft.Kinect.VisualGestureBuilder.Gesture>(outKeys[i], n => new Microsoft.Kinect.VisualGestureBuilder.Gesture(n));
+
+                    var valueObj = Helper.NativeObjectCache.CreateOrGetObject<Microsoft.Kinect.VisualGestureBuilder.ContinuousGestureResult>(outValues[i], n => new Microsoft.Kinect.VisualGestureBuilder.ContinuousGestureResult(n));
+
+                    managedDictionary.Add(keyObj, valueObj);
+                }
+                return managedDictionary;
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_DiscreteGestureResults(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] RootSystem.IntPtr[] outKeys, [RootSystem.Runtime.InteropServices.Out] RootSystem.IntPtr[] outValues, int outCollectionSize);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_DiscreteGestureResults_Length(RootSystem.IntPtr pNative);
+        public  RootSystem.Collections.Generic.Dictionary<Microsoft.Kinect.VisualGestureBuilder.Gesture, Microsoft.Kinect.VisualGestureBuilder.DiscreteGestureResult> DiscreteGestureResults
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrame");
+                }
+
+                int outCollectionSize = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_DiscreteGestureResults_Length(_pNative);
+                var outKeys = new RootSystem.IntPtr[outCollectionSize];
+                var outValues = new RootSystem.IntPtr[outCollectionSize];
+                var managedDictionary = new RootSystem.Collections.Generic.Dictionary<Microsoft.Kinect.VisualGestureBuilder.Gesture, Microsoft.Kinect.VisualGestureBuilder.DiscreteGestureResult>();
+
+                outCollectionSize = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_DiscreteGestureResults(_pNative, outKeys, outValues, outCollectionSize);
+                Helper.ExceptionHelper.CheckLastError();
+                for(int i=0;i<outCollectionSize;i++)
+                {
+                    if(outKeys[i] == RootSystem.IntPtr.Zero || outValues[i] == RootSystem.IntPtr.Zero)
+                    {
+                        continue;
+                    }
+
+                    var keyObj = Helper.NativeObjectCache.CreateOrGetObject<Microsoft.Kinect.VisualGestureBuilder.Gesture>(outKeys[i], n => new Microsoft.Kinect.VisualGestureBuilder.Gesture(n));
+
+                    var valueObj = Helper.NativeObjectCache.CreateOrGetObject<Microsoft.Kinect.VisualGestureBuilder.DiscreteGestureResult>(outValues[i], n => new Microsoft.Kinect.VisualGestureBuilder.DiscreteGestureResult(n));
+
+                    managedDictionary.Add(keyObj, valueObj);
+                }
+                return managedDictionary;
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_IsTrackingIdValid(RootSystem.IntPtr pNative);
+        public  bool IsTrackingIdValid
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrame");
+                }
+
+                return Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_IsTrackingIdValid(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrame");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_RelativeTime(_pNative));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern ulong Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_TrackingId(RootSystem.IntPtr pNative);
+        public  ulong TrackingId
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrame");
+                }
+
+                return Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_TrackingId(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_VisualGestureBuilderFrameSource(RootSystem.IntPtr pNative);
+        public  Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameSource VisualGestureBuilderFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_get_VisualGestureBuilderFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameSource>(objectPointer, n => new Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameSource(n));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrame_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/VisualGestureBuilderFrame.cs.meta

+fileFormatVersion: 2
+guid: 47c323266c46b964493ab406ea288659
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/VisualGestureBuilderFrameArrivedEventArgs.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Microsoft.Kinect.VisualGestureBuilder
+{
+    //
+    // Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameArrivedEventArgs
+    //
+    public sealed partial class VisualGestureBuilderFrameArrivedEventArgs : RootSystem.EventArgs, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal VisualGestureBuilderFrameArrivedEventArgs(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_AddRefObject(ref _pNative);
+        }
+
+        ~VisualGestureBuilderFrameArrivedEventArgs()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<VisualGestureBuilderFrameArrivedEventArgs>(_pNative);
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_get_FrameReference(RootSystem.IntPtr pNative);
+        public  Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameReference FrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameArrivedEventArgs");
+                }
+
+                RootSystem.IntPtr objectPointer = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_get_FrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameReference>(objectPointer, n => new Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameReference(n));
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/VisualGestureBuilderFrameArrivedEventArgs.cs.meta

+fileFormatVersion: 2
+guid: 487a1dbae6735f34695213eaf0e7486b
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/VisualGestureBuilderFrameReader.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Microsoft.Kinect.VisualGestureBuilder
+{
+    //
+    // Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameReader
+    //
+    public sealed partial class VisualGestureBuilderFrameReader : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal VisualGestureBuilderFrameReader(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_AddRefObject(ref _pNative);
+        }
+
+        ~VisualGestureBuilderFrameReader()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<VisualGestureBuilderFrameReader>(_pNative);
+
+            if (disposing)
+            {
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_Dispose(_pNative);
+            }
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_get_IsPaused(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_put_IsPaused(RootSystem.IntPtr pNative, bool isPaused);
+        public  bool IsPaused
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameReader");
+                }
+
+                return Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_get_IsPaused(_pNative);
+            }
+            set
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameReader");
+                }
+
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_put_IsPaused(_pNative, value);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_get_VisualGestureBuilderFrameSource(RootSystem.IntPtr pNative);
+        public  Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameSource VisualGestureBuilderFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameReader");
+                }
+
+                RootSystem.IntPtr objectPointer = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_get_VisualGestureBuilderFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameSource>(objectPointer, n => new Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameSource(n));
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameArrivedEventArgs>>> Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameArrivedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate))]
+        private static void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameArrivedEventArgs>> callbackList = null;
+            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<VisualGestureBuilderFrameReader>(pNative);
+                var args = new Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameArrivedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_add_FrameArrived(RootSystem.IntPtr pNative, _Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameArrivedEventArgs> FrameArrived
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate(Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_Handler);
+                        _Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_add_FrameArrived(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_add_FrameArrived(_pNative, Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_Handler, true);
+                        _Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<VisualGestureBuilderFrameReader>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_CalculateAndAcquireLatestFrame(RootSystem.IntPtr pNative);
+        public Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrame CalculateAndAcquireLatestFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameReader");
+            }
+
+            RootSystem.IntPtr objectPointer = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_CalculateAndAcquireLatestFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrame>(objectPointer, n => new Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrame(n));
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_add_FrameArrived(_pNative, Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_Handler, true);
+                        }
+                        _Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/VisualGestureBuilderFrameReader.cs.meta

+fileFormatVersion: 2
+guid: 92b159bf1aed2df4986d0398eda39fe7
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/VisualGestureBuilderFrameReference.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Microsoft.Kinect.VisualGestureBuilder
+{
+    //
+    // Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameReference
+    //
+    public sealed partial class VisualGestureBuilderFrameReference : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal VisualGestureBuilderFrameReference(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReference_AddRefObject(ref _pNative);
+        }
+
+        ~VisualGestureBuilderFrameReference()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReference_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReference_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<VisualGestureBuilderFrameReference>(_pNative);
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReference_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReference_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameReference");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReference_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReference_AcquireFrame(RootSystem.IntPtr pNative);
+        public Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrame AcquireFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameReference");
+            }
+
+            RootSystem.IntPtr objectPointer = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameReference_AcquireFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrame>(objectPointer, n => new Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrame(n));
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/VisualGestureBuilderFrameReference.cs.meta

+fileFormatVersion: 2
+guid: ba8bac3cd7bf2b841ad9dd3acb0b34e1
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/VisualGestureBuilderFrameSource.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Microsoft.Kinect.VisualGestureBuilder
+{
+    //
+    // Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameSource
+    //
+    public sealed partial class VisualGestureBuilderFrameSource : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal VisualGestureBuilderFrameSource(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_AddRefObject(ref _pNative);
+        }
+
+        ~VisualGestureBuilderFrameSource()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<VisualGestureBuilderFrameSource>(_pNative);
+
+            if (disposing)
+            {
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_Dispose(_pNative);
+            }
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern ulong Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_get_TrackingId(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_put_TrackingId(RootSystem.IntPtr pNative, ulong trackingId);
+        public  ulong TrackingId
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameSource");
+                }
+
+                return Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_get_TrackingId(_pNative);
+            }
+            set
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameSource");
+                }
+
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_put_TrackingId(_pNative, value);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_get_HorizontalMirror(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_put_HorizontalMirror(RootSystem.IntPtr pNative, bool horizontalMirror);
+        public  bool HorizontalMirror
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameSource");
+                }
+
+                return Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_get_HorizontalMirror(_pNative);
+            }
+            set
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameSource");
+                }
+
+                Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_put_HorizontalMirror(_pNative, value);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_get_Gestures(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] RootSystem.IntPtr[] outCollection, int outCollectionSize);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_get_Gestures_Length(RootSystem.IntPtr pNative);
+        public  RootSystem.Collections.Generic.IList<Microsoft.Kinect.VisualGestureBuilder.Gesture> Gestures
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameSource");
+                }
+
+                int outCollectionSize = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_get_Gestures_Length(_pNative);
+                var outCollection = new RootSystem.IntPtr[outCollectionSize];
+                var managedCollection = new Microsoft.Kinect.VisualGestureBuilder.Gesture[outCollectionSize];
+
+                outCollectionSize = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_get_Gestures(_pNative, outCollection, outCollectionSize);
+                Helper.ExceptionHelper.CheckLastError();
+                for(int i=0;i<outCollectionSize;i++)
+                {
+                    if(outCollection[i] == RootSystem.IntPtr.Zero)
+                    {
+                        continue;
+                    }
+
+                    var obj = Helper.NativeObjectCache.CreateOrGetObject<Microsoft.Kinect.VisualGestureBuilder.Gesture>(outCollection[i], n => new Microsoft.Kinect.VisualGestureBuilder.Gesture(n));
+
+                    managedCollection[i] = obj;
+                }
+                return managedCollection;
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_get_IsActive(RootSystem.IntPtr pNative);
+        public  bool IsActive
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameSource");
+                }
+
+                return Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_get_IsActive(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_get_IsTrackingIdValid(RootSystem.IntPtr pNative);
+        public  bool IsTrackingIdValid
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameSource");
+                }
+
+                return Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_get_IsTrackingIdValid(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_get_KinectSensor(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.KinectSensor KinectSensor
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameSource");
+                }
+
+                RootSystem.IntPtr objectPointer = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_get_KinectSensor(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectSensor>(objectPointer, n => new Windows.Kinect.KinectSensor(n));
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Microsoft.Kinect.VisualGestureBuilder.TrackingIdLostEventArgs>>> Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Microsoft.Kinect.VisualGestureBuilder.TrackingIdLostEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate))]
+        private static void Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Microsoft.Kinect.VisualGestureBuilder.TrackingIdLostEventArgs>> callbackList = null;
+            Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<VisualGestureBuilderFrameSource>(pNative);
+                var args = new Microsoft.Kinect.VisualGestureBuilder.TrackingIdLostEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_add_TrackingIdLost(RootSystem.IntPtr pNative, _Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Microsoft.Kinect.VisualGestureBuilder.TrackingIdLostEventArgs> TrackingIdLost
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate(Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_Handler);
+                        _Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_add_TrackingIdLost(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_add_TrackingIdLost(_pNative, Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_Handler, true);
+                        _Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<VisualGestureBuilderFrameSource>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_AddGesture(RootSystem.IntPtr pNative, RootSystem.IntPtr gesture);
+        public void AddGesture(Microsoft.Kinect.VisualGestureBuilder.Gesture gesture)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameSource");
+            }
+
+            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_AddGesture(_pNative, Helper.NativeWrapper.GetNativePtr(gesture));
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_AddGestures(RootSystem.IntPtr pNative, RootSystem.IntPtr gestures, int gesturesSize);
+        public void AddGestures(Microsoft.Kinect.VisualGestureBuilder.Gesture[] gestures)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameSource");
+            }
+
+            int _gestures_idx=0;
+            var _gestures_array = new RootSystem.IntPtr[gestures.Count()];
+            foreach(var value in gestures)
+            {
+                _gestures_array[_gestures_idx] = Helper.NativeWrapper.GetNativePtr(value);
+                _gestures_idx++;
+            }
+            var gesturesSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(_gestures_array, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _gestures = gesturesSmartGCHandle.AddrOfPinnedObject();
+            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_AddGestures(_pNative, _gestures, gestures.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_RemoveGesture(RootSystem.IntPtr pNative, RootSystem.IntPtr gesture);
+        public void RemoveGesture(Microsoft.Kinect.VisualGestureBuilder.Gesture gesture)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameSource");
+            }
+
+            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_RemoveGesture(_pNative, Helper.NativeWrapper.GetNativePtr(gesture));
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_SetIsEnabled(RootSystem.IntPtr pNative, RootSystem.IntPtr gesture, bool isEnabled);
+        public void SetIsEnabled(Microsoft.Kinect.VisualGestureBuilder.Gesture gesture, bool isEnabled)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameSource");
+            }
+
+            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_SetIsEnabled(_pNative, Helper.NativeWrapper.GetNativePtr(gesture), isEnabled);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_OpenReader(RootSystem.IntPtr pNative);
+        public Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameReader OpenReader()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("VisualGestureBuilderFrameSource");
+            }
+
+            RootSystem.IntPtr objectPointer = Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_OpenReader(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameReader>(objectPointer, n => new Microsoft.Kinect.VisualGestureBuilder.VisualGestureBuilderFrameReader(n));
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectVisualGestureBuilderUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_add_TrackingIdLost(_pNative, Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_Handler, true);
+                        }
+                        _Microsoft_Kinect_VisualGestureBuilder_TrackingIdLostEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Microsoft_Kinect_VisualGestureBuilder_VisualGestureBuilderFrameSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Microsoft/Kinect/VisualGestureBuilder/VisualGestureBuilderFrameSource.cs.meta

+fileFormatVersion: 2
+guid: 641d13669aad591478663a1e1aecf37d
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/NativeObjectCache.cs

+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Linq;
+
+namespace Helper
+{
+    public static class NativeObjectCache
+    {
+        private static object _lock = new object();
+        private static Dictionary<Type, Dictionary<IntPtr, WeakReference>> _objectCache = new Dictionary<Type, Dictionary<IntPtr, WeakReference>>();
+        public static void AddObject<T>(IntPtr nativePtr, T obj) where T : class
+        {
+            lock (_lock)
+            {
+                Dictionary<IntPtr, WeakReference> objCache = null;
+
+                if (!_objectCache.TryGetValue(typeof(T), out objCache) || objCache == null)
+                {
+                    objCache = new Dictionary<IntPtr, WeakReference>();
+                    _objectCache[typeof(T)] = objCache;
+                }
+
+                objCache[nativePtr] = new WeakReference(obj);
+            }
+        }
+
+        public static void Flush()
+        {
+            lock(_lock)
+            {
+                foreach (var byType in _objectCache.ToArray())
+                {
+                    foreach(var kvp in byType.Value.ToArray())
+                    {
+                        IDisposable disp = kvp.Value.Target as IDisposable;
+                        if(disp != null)
+                        {
+                            disp.Dispose();
+                        }
+
+                    }
+                }
+            }
+        }
+
+        public static void RemoveObject<T>(IntPtr nativePtr)
+        {
+            lock (_lock)
+            {
+                Dictionary<IntPtr, WeakReference> objCache = null;
+
+                if (!_objectCache.TryGetValue(typeof(T), out objCache) || objCache == null)
+                {
+                    objCache = new Dictionary<IntPtr, WeakReference>();
+                    _objectCache[typeof(T)] = objCache;
+                }
+
+                if (objCache.ContainsKey(nativePtr))
+                {
+                    objCache.Remove(nativePtr);
+                }
+            }
+        }
+
+        public static T GetObject<T>(IntPtr nativePtr) where T : class
+        {
+            lock (_lock)
+            {
+                Dictionary<IntPtr, WeakReference> objCache = null;
+
+                if (!_objectCache.TryGetValue(typeof(T), out objCache) || objCache == null)
+                {
+                    objCache = new Dictionary<IntPtr, WeakReference>();
+                    _objectCache[typeof(T)] = objCache;
+                }
+
+                WeakReference reference = null;
+                if (objCache.TryGetValue(nativePtr, out reference))
+                {
+                    if (reference != null)
+                    {
+                        T obj = reference.Target as T;
+                        if (obj != null)
+                        {
+                            return (T)obj;
+                        }
+                    }
+                }
+
+                return null;
+            }
+        }
+
+        public static T CreateOrGetObject<T>(IntPtr nativePtr, Func<System.IntPtr,T> create) where T : class
+        {
+            T outputValue = null;
+
+            lock (_lock)
+            {
+                Dictionary<IntPtr, WeakReference> objCache = null;
+
+                if (!_objectCache.TryGetValue(typeof(T), out objCache) || objCache == null)
+                {
+                    objCache = new Dictionary<IntPtr, WeakReference>();
+                    _objectCache[typeof(T)] = objCache;
+                }
+
+                WeakReference reference = null;
+                if (objCache.TryGetValue(nativePtr, out reference))
+                {
+                    if ((reference != null) && reference.IsAlive)
+                    {
+                        outputValue = reference.Target as T;
+                    }
+                }
+
+                if (outputValue == null)
+                { 
+                    if (create != null)
+                    {
+                        outputValue = create(nativePtr);
+                        objCache[nativePtr] = new WeakReference(outputValue);
+                    }
+                    else if(typeof(T) == typeof(System.Object)) 
+                    {
+                        //T is an object, so lets just pass back our IntPtr, which is an object.
+                        outputValue = (T)(System.Object)nativePtr;
+                    }
+                }
+            }
+
+            return outputValue;
+        }
+    }
+}
\ No newline at end of file

Assets/Standard Assets/NativeObjectCache.cs.meta

+fileFormatVersion: 2
+guid: d03d0f1305bee2541b8bf6b6aad5ae66
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/NativeWrapper.cs

+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Linq;
+
+namespace Helper
+{
+    public static class NativeWrapper
+    {
+        public static System.IntPtr GetNativePtr(Object obj)
+        {
+        	if(obj == null)
+        	{
+        		return System.IntPtr.Zero;
+        	}
+
+            var nativeWrapperIface = obj as INativeWrapper;
+            if(nativeWrapperIface != null)
+            {
+                return nativeWrapperIface.nativePtr;
+            }
+            else
+            {
+                throw new ArgumentException("Object must wrap native type");
+            }
+        }
+    }
+}
\ No newline at end of file

Assets/Standard Assets/NativeWrapper.cs.meta

+fileFormatVersion: 2
+guid: 6a5563074073a2746adeab572f9254f2
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/SmartGCHandle.cs

+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Linq;
+
+namespace Helper
+{
+    public class SmartGCHandle : IDisposable
+    {
+        private GCHandle handle;
+        public SmartGCHandle(GCHandle handle)
+        {
+            this.handle = handle;
+        }
+
+        ~SmartGCHandle()
+        {
+            Dispose(false);
+        }
+
+        public System.IntPtr AddrOfPinnedObject()
+        {
+            return handle.AddrOfPinnedObject();
+        }
+
+        public virtual void Dispose()
+        {
+            Dispose(true);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            this.handle.Free();
+        }
+
+        public static implicit operator GCHandle(SmartGCHandle other)
+        {
+
+            return other.handle;
+        }
+    }
+}
\ No newline at end of file

Assets/Standard Assets/SmartGCHandle.cs.meta

+fileFormatVersion: 2
+guid: b8692c711ef8ca04b8cbc62b7aea656c
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/ThreadSafeDictionary.cs

+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Linq;
+
+namespace Helper
+{
+    public class ThreadSafeDictionary<TKey, TValue>
+    {
+        protected readonly Dictionary<TKey, TValue> _impl = new Dictionary<TKey, TValue>();
+        public TValue this[TKey key]
+        {
+            get
+            {
+                lock (_impl)
+                {
+                    return _impl[key];
+                }
+            }
+            set
+            {
+                lock (_impl)
+                {
+                    _impl[key] = value;
+                }
+            }
+        }
+
+        public void Add(TKey key, TValue value)
+        {
+            lock (_impl)
+            {
+                _impl.Add(key, value);
+            }
+        }
+
+        public bool TryGetValue(TKey key, out TValue value)
+        {
+            lock (_impl)
+            {
+                return _impl.TryGetValue(key, out value);
+            }
+        }
+
+        public bool Remove(TKey key)
+        {
+            lock (_impl)
+            {
+                return _impl.Remove(key);
+            }
+        }
+
+        public void Clear()
+        {
+            lock (_impl)
+            {
+                _impl.Clear();
+            }
+        }
+    }
+}
\ No newline at end of file

Assets/Standard Assets/ThreadSafeDictionary.cs.meta

+fileFormatVersion: 2
+guid: 9e4d8029771f44e45ac2b95f1172e12b
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows.meta

+fileFormatVersion: 2
+guid: 2723e673de8807e43ad17c3ba3135b72
+folderAsset: yes
+timeCreated: 1502957664
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Data.meta

+fileFormatVersion: 2
+guid: 04e90123037305243906258ff07b4736
+folderAsset: yes
+timeCreated: 1502957664
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Data/PropertyChangedEventArgs.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Data
+{
+    //
+    // Windows.Data.PropertyChangedEventArgs
+    //
+    public sealed partial class PropertyChangedEventArgs : RootSystem.EventArgs, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal PropertyChangedEventArgs(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Data_PropertyChangedEventArgs_AddRefObject(ref _pNative);
+        }
+
+        ~PropertyChangedEventArgs()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Data_PropertyChangedEventArgs_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Data_PropertyChangedEventArgs_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<PropertyChangedEventArgs>(_pNative);
+                Windows_Data_PropertyChangedEventArgs_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Data_PropertyChangedEventArgs_get_PropertyName(RootSystem.IntPtr pNative);
+        public  string PropertyName
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("PropertyChangedEventArgs");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Data_PropertyChangedEventArgs_get_PropertyName(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+
+                var managedString = RootSystem.Runtime.InteropServices.Marshal.PtrToStringUni(objectPointer);
+                RootSystem.Runtime.InteropServices.Marshal.FreeCoTaskMem(objectPointer);
+                return managedString;
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Data/PropertyChangedEventArgs.cs.meta

+fileFormatVersion: 2
+guid: 0f717bd2a5c39cc43a49fc8904889932
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect.meta

+fileFormatVersion: 2
+guid: 7eaeb51706298234982d58b7d8469461
+folderAsset: yes
+timeCreated: 1502957664
+licenseType: Free
+DefaultImporter:
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/Activity.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.Activity
+    //
+    public enum Activity : int
+    {
+        EyeLeftClosed                            =0,
+        EyeRightClosed                           =1,
+        MouthOpen                                =2,
+        MouthMoved                               =3,
+        LookingAway                              =4,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/Activity.cs.meta

+fileFormatVersion: 2
+guid: ec6785f19ac6c494a9957fa63f49fcf5
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/Appearance.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.Appearance
+    //
+    public enum Appearance : int
+    {
+        WearingGlasses                           =0,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/Appearance.cs.meta

+fileFormatVersion: 2
+guid: 00eb0d9c4964c0b4f9e3090704ff7201
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/AudioBeam.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.AudioBeam
+    //
+    public sealed partial class AudioBeam : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal AudioBeam(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_AudioBeam_AddRefObject(ref _pNative);
+        }
+
+        ~AudioBeam()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeam_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeam_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<AudioBeam>(_pNative);
+                Windows_Kinect_AudioBeam_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.AudioBeamMode Windows_Kinect_AudioBeam_get_AudioBeamMode(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeam_put_AudioBeamMode(RootSystem.IntPtr pNative, Windows.Kinect.AudioBeamMode audioBeamMode);
+        public  Windows.Kinect.AudioBeamMode AudioBeamMode
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeam");
+                }
+
+                return Windows_Kinect_AudioBeam_get_AudioBeamMode(_pNative);
+            }
+            set
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeam");
+                }
+
+                Windows_Kinect_AudioBeam_put_AudioBeamMode(_pNative, value);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_AudioBeam_get_AudioSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.AudioSource AudioSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeam");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_AudioBeam_get_AudioSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.AudioSource>(objectPointer, n => new Windows.Kinect.AudioSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern float Windows_Kinect_AudioBeam_get_BeamAngle(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeam_put_BeamAngle(RootSystem.IntPtr pNative, float beamAngle);
+        public  float BeamAngle
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeam");
+                }
+
+                return Windows_Kinect_AudioBeam_get_BeamAngle(_pNative);
+            }
+            set
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeam");
+                }
+
+                Windows_Kinect_AudioBeam_put_BeamAngle(_pNative, value);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern float Windows_Kinect_AudioBeam_get_BeamAngleConfidence(RootSystem.IntPtr pNative);
+        public  float BeamAngleConfidence
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeam");
+                }
+
+                return Windows_Kinect_AudioBeam_get_BeamAngleConfidence(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_AudioBeam_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeam");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_AudioBeam_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<AudioBeam>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeam_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_AudioBeam_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_AudioBeam_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        private void __EventCleanup()
+        {
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_AudioBeam_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/AudioBeam.cs.meta

+fileFormatVersion: 2
+guid: e64f7eb8de6f72e42874eb2ea7c01be5
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/AudioBeamFrame.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.AudioBeamFrame
+    //
+    public sealed partial class AudioBeamFrame : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal AudioBeamFrame(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_AudioBeamFrame_AddRefObject(ref _pNative);
+        }
+
+        ~AudioBeamFrame()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrame_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrame_AddRefObject(ref RootSystem.IntPtr pNative);
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_AudioBeamFrame_get_AudioBeam(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.AudioBeam AudioBeam
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_AudioBeamFrame_get_AudioBeam(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.AudioBeam>(objectPointer, n => new Windows.Kinect.AudioBeam(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_AudioBeamFrame_get_AudioSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.AudioSource AudioSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_AudioBeamFrame_get_AudioSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.AudioSource>(objectPointer, n => new Windows.Kinect.AudioSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_AudioBeamFrame_get_Duration(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan Duration
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamFrame");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_AudioBeamFrame_get_Duration(_pNative));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_AudioBeamFrame_get_RelativeTimeStart(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTimeStart
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamFrame");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_AudioBeamFrame_get_RelativeTimeStart(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/AudioBeamFrame.cs.meta

+fileFormatVersion: 2
+guid: 8ff93fd69396b944ea1e0d067cf5b091
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/AudioBeamFrameArrivedEventArgs.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.AudioBeamFrameArrivedEventArgs
+    //
+    public sealed partial class AudioBeamFrameArrivedEventArgs : RootSystem.EventArgs, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal AudioBeamFrameArrivedEventArgs(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_AudioBeamFrameArrivedEventArgs_AddRefObject(ref _pNative);
+        }
+
+        ~AudioBeamFrameArrivedEventArgs()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrameArrivedEventArgs_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrameArrivedEventArgs_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<AudioBeamFrameArrivedEventArgs>(_pNative);
+                Windows_Kinect_AudioBeamFrameArrivedEventArgs_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_AudioBeamFrameArrivedEventArgs_get_FrameReference(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.AudioBeamFrameReference FrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamFrameArrivedEventArgs");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_AudioBeamFrameArrivedEventArgs_get_FrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.AudioBeamFrameReference>(objectPointer, n => new Windows.Kinect.AudioBeamFrameReference(n));
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/AudioBeamFrameArrivedEventArgs.cs.meta

+fileFormatVersion: 2
+guid: bb78a9668fb2c694881a216e349cb1e9
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/AudioBeamFrameList.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.AudioBeamFrameList
+    //
+    public sealed partial class AudioBeamFrameList : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal AudioBeamFrameList(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_AudioBeamFrameList_AddRefObject(ref _pNative);
+        }
+
+        ~AudioBeamFrameList()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrameList_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrameList_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<AudioBeamFrameList>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_AudioBeamFrameList_Dispose(_pNative);
+            }
+                Windows_Kinect_AudioBeamFrameList_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrameList_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/AudioBeamFrameList.cs.meta

+fileFormatVersion: 2
+guid: fe7ef6722da9a6d42b589d3f8b35b6f9
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/AudioBeamFrameReader.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.AudioBeamFrameReader
+    //
+    public sealed partial class AudioBeamFrameReader : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal AudioBeamFrameReader(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_AudioBeamFrameReader_AddRefObject(ref _pNative);
+        }
+
+        ~AudioBeamFrameReader()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrameReader_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrameReader_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<AudioBeamFrameReader>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_AudioBeamFrameReader_Dispose(_pNative);
+            }
+                Windows_Kinect_AudioBeamFrameReader_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_AudioBeamFrameReader_get_AudioSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.AudioSource AudioSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamFrameReader");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_AudioBeamFrameReader_get_AudioSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.AudioSource>(objectPointer, n => new Windows.Kinect.AudioSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_AudioBeamFrameReader_get_IsPaused(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrameReader_put_IsPaused(RootSystem.IntPtr pNative, bool isPaused);
+        public  bool IsPaused
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamFrameReader");
+                }
+
+                return Windows_Kinect_AudioBeamFrameReader_get_IsPaused(_pNative);
+            }
+            set
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamFrameReader");
+                }
+
+                Windows_Kinect_AudioBeamFrameReader_put_IsPaused(_pNative, value);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.AudioBeamFrameArrivedEventArgs>>> Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.AudioBeamFrameArrivedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate))]
+        private static void Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.AudioBeamFrameArrivedEventArgs>> callbackList = null;
+            Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<AudioBeamFrameReader>(pNative);
+                var args = new Windows.Kinect.AudioBeamFrameArrivedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrameReader_add_FrameArrived(RootSystem.IntPtr pNative, _Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.AudioBeamFrameArrivedEventArgs> FrameArrived
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate(Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_AudioBeamFrameReader_add_FrameArrived(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_AudioBeamFrameReader_add_FrameArrived(_pNative, Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<AudioBeamFrameReader>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrameReader_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_AudioBeamFrameReader_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_AudioBeamFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_AudioBeamFrameReader_AcquireLatestBeamFrames_Length(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_AudioBeamFrameReader_AcquireLatestBeamFrames(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] RootSystem.IntPtr[] outCollection, int outCollectionSize);
+        public RootSystem.Collections.Generic.IList<Windows.Kinect.AudioBeamFrame> AcquireLatestBeamFrames()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("AudioBeamFrameReader");
+            }
+
+            int outCollectionSize = Windows_Kinect_AudioBeamFrameReader_AcquireLatestBeamFrames_Length(_pNative);
+            var outCollection = new RootSystem.IntPtr[outCollectionSize];
+            var managedCollection = new Windows.Kinect.AudioBeamFrame[outCollectionSize];
+
+            outCollectionSize = Windows_Kinect_AudioBeamFrameReader_AcquireLatestBeamFrames(_pNative, outCollection, outCollectionSize);
+            Helper.ExceptionHelper.CheckLastError();
+            for(int i=0;i<outCollectionSize;i++)
+            {
+                if(outCollection[i] == RootSystem.IntPtr.Zero)
+                {
+                    continue;
+                }
+
+                var obj = Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.AudioBeamFrame>(outCollection[i], n => new Windows.Kinect.AudioBeamFrame(n));
+
+                managedCollection[i] = obj;
+            }
+            return managedCollection;
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrameReader_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_AudioBeamFrameReader_add_FrameArrived(_pNative, Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_AudioBeamFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_AudioBeamFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/AudioBeamFrameReader.cs.meta

+fileFormatVersion: 2
+guid: df51c172437a76942a0ec4a4f1438a8f
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/AudioBeamFrameReference.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.AudioBeamFrameReference
+    //
+    public sealed partial class AudioBeamFrameReference : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal AudioBeamFrameReference(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_AudioBeamFrameReference_AddRefObject(ref _pNative);
+        }
+
+        ~AudioBeamFrameReference()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrameReference_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamFrameReference_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<AudioBeamFrameReference>(_pNative);
+                Windows_Kinect_AudioBeamFrameReference_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_AudioBeamFrameReference_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamFrameReference");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_AudioBeamFrameReference_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_AudioBeamFrameReference_AcquireBeamFrames_Length(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_AudioBeamFrameReference_AcquireBeamFrames(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] RootSystem.IntPtr[] outCollection, int outCollectionSize);
+        public RootSystem.Collections.Generic.IList<Windows.Kinect.AudioBeamFrame> AcquireBeamFrames()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("AudioBeamFrameReference");
+            }
+
+            int outCollectionSize = Windows_Kinect_AudioBeamFrameReference_AcquireBeamFrames_Length(_pNative);
+            var outCollection = new RootSystem.IntPtr[outCollectionSize];
+            var managedCollection = new Windows.Kinect.AudioBeamFrame[outCollectionSize];
+
+            outCollectionSize = Windows_Kinect_AudioBeamFrameReference_AcquireBeamFrames(_pNative, outCollection, outCollectionSize);
+            Helper.ExceptionHelper.CheckLastError();
+            for(int i=0;i<outCollectionSize;i++)
+            {
+                if(outCollection[i] == RootSystem.IntPtr.Zero)
+                {
+                    continue;
+                }
+
+                var obj = Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.AudioBeamFrame>(outCollection[i], n => new Windows.Kinect.AudioBeamFrame(n));
+
+                managedCollection[i] = obj;
+            }
+            return managedCollection;
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/AudioBeamFrameReference.cs.meta

+fileFormatVersion: 2
+guid: 0fe91384e0a914a4985b0cc2f1026a72
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/AudioBeamMode.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.AudioBeamMode
+    //
+    public enum AudioBeamMode : int
+    {
+        Automatic                                =0,
+        Manual                                   =1,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/AudioBeamMode.cs.meta

+fileFormatVersion: 2
+guid: 1f287bc065b7e7a4faa7cf96c175eabb
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/AudioBeamSubFrame.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.AudioBeamSubFrame
+    //
+    public sealed partial class AudioBeamSubFrame : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal AudioBeamSubFrame(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_AudioBeamSubFrame_AddRefObject(ref _pNative);
+        }
+
+        ~AudioBeamSubFrame()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamSubFrame_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamSubFrame_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<AudioBeamSubFrame>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_AudioBeamSubFrame_Dispose(_pNative);
+            }
+                Windows_Kinect_AudioBeamSubFrame_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.AudioBeamMode Windows_Kinect_AudioBeamSubFrame_get_AudioBeamMode(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.AudioBeamMode AudioBeamMode
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamSubFrame");
+                }
+
+                return Windows_Kinect_AudioBeamSubFrame_get_AudioBeamMode(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_AudioBeamSubFrame_get_AudioBodyCorrelations(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] RootSystem.IntPtr[] outCollection, int outCollectionSize);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_AudioBeamSubFrame_get_AudioBodyCorrelations_Length(RootSystem.IntPtr pNative);
+        public  RootSystem.Collections.Generic.IList<Windows.Kinect.AudioBodyCorrelation> AudioBodyCorrelations
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamSubFrame");
+                }
+
+                int outCollectionSize = Windows_Kinect_AudioBeamSubFrame_get_AudioBodyCorrelations_Length(_pNative);
+                var outCollection = new RootSystem.IntPtr[outCollectionSize];
+                var managedCollection = new Windows.Kinect.AudioBodyCorrelation[outCollectionSize];
+
+                outCollectionSize = Windows_Kinect_AudioBeamSubFrame_get_AudioBodyCorrelations(_pNative, outCollection, outCollectionSize);
+                Helper.ExceptionHelper.CheckLastError();
+                for(int i=0;i<outCollectionSize;i++)
+                {
+                    if(outCollection[i] == RootSystem.IntPtr.Zero)
+                    {
+                        continue;
+                    }
+
+                    var obj = Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.AudioBodyCorrelation>(outCollection[i], n => new Windows.Kinect.AudioBodyCorrelation(n));
+
+                    managedCollection[i] = obj;
+                }
+                return managedCollection;
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern float Windows_Kinect_AudioBeamSubFrame_get_BeamAngle(RootSystem.IntPtr pNative);
+        public  float BeamAngle
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamSubFrame");
+                }
+
+                return Windows_Kinect_AudioBeamSubFrame_get_BeamAngle(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern float Windows_Kinect_AudioBeamSubFrame_get_BeamAngleConfidence(RootSystem.IntPtr pNative);
+        public  float BeamAngleConfidence
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamSubFrame");
+                }
+
+                return Windows_Kinect_AudioBeamSubFrame_get_BeamAngleConfidence(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_AudioBeamSubFrame_get_Duration(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan Duration
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamSubFrame");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_AudioBeamSubFrame_get_Duration(_pNative));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern uint Windows_Kinect_AudioBeamSubFrame_get_FrameLengthInBytes(RootSystem.IntPtr pNative);
+        public  uint FrameLengthInBytes
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamSubFrame");
+                }
+
+                return Windows_Kinect_AudioBeamSubFrame_get_FrameLengthInBytes(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_AudioBeamSubFrame_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBeamSubFrame");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_AudioBeamSubFrame_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamSubFrame_CopyFrameDataToArray(RootSystem.IntPtr pNative, RootSystem.IntPtr frameData, int frameDataSize);
+        public void CopyFrameDataToArray(byte[] frameData)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("AudioBeamSubFrame");
+            }
+
+            var frameDataSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(frameData, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _frameData = frameDataSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_AudioBeamSubFrame_CopyFrameDataToArray(_pNative, _frameData, frameData.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBeamSubFrame_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/AudioBeamSubFrame.cs.meta

+fileFormatVersion: 2
+guid: e3bf3859145801247a7f6d4dcd90b2be
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/AudioBodyCorrelation.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.AudioBodyCorrelation
+    //
+    public sealed partial class AudioBodyCorrelation : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal AudioBodyCorrelation(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_AudioBodyCorrelation_AddRefObject(ref _pNative);
+        }
+
+        ~AudioBodyCorrelation()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBodyCorrelation_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioBodyCorrelation_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<AudioBodyCorrelation>(_pNative);
+                Windows_Kinect_AudioBodyCorrelation_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern ulong Windows_Kinect_AudioBodyCorrelation_get_BodyTrackingId(RootSystem.IntPtr pNative);
+        public  ulong BodyTrackingId
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioBodyCorrelation");
+                }
+
+                return Windows_Kinect_AudioBodyCorrelation_get_BodyTrackingId(_pNative);
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/AudioBodyCorrelation.cs.meta

+fileFormatVersion: 2
+guid: f12e3715b57390a47aeecc0046c6d6ff
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/AudioSource.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.AudioSource
+    //
+    public sealed partial class AudioSource : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal AudioSource(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_AudioSource_AddRefObject(ref _pNative);
+        }
+
+        ~AudioSource()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioSource_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioSource_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<AudioSource>(_pNative);
+                Windows_Kinect_AudioSource_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_AudioSource_get_AudioBeams(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] RootSystem.IntPtr[] outCollection, int outCollectionSize);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_AudioSource_get_AudioBeams_Length(RootSystem.IntPtr pNative);
+        public  RootSystem.Collections.Generic.IList<Windows.Kinect.AudioBeam> AudioBeams
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioSource");
+                }
+
+                int outCollectionSize = Windows_Kinect_AudioSource_get_AudioBeams_Length(_pNative);
+                var outCollection = new RootSystem.IntPtr[outCollectionSize];
+                var managedCollection = new Windows.Kinect.AudioBeam[outCollectionSize];
+
+                outCollectionSize = Windows_Kinect_AudioSource_get_AudioBeams(_pNative, outCollection, outCollectionSize);
+                Helper.ExceptionHelper.CheckLastError();
+                for(int i=0;i<outCollectionSize;i++)
+                {
+                    if(outCollection[i] == RootSystem.IntPtr.Zero)
+                    {
+                        continue;
+                    }
+
+                    var obj = Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.AudioBeam>(outCollection[i], n => new Windows.Kinect.AudioBeam(n));
+
+                    managedCollection[i] = obj;
+                }
+                return managedCollection;
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_AudioSource_get_IsActive(RootSystem.IntPtr pNative);
+        public  bool IsActive
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioSource");
+                }
+
+                return Windows_Kinect_AudioSource_get_IsActive(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_AudioSource_get_KinectSensor(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.KinectSensor KinectSensor
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioSource");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_AudioSource_get_KinectSensor(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectSensor>(objectPointer, n => new Windows.Kinect.KinectSensor(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern uint Windows_Kinect_AudioSource_get_MaxSubFrameCount(RootSystem.IntPtr pNative);
+        public  uint MaxSubFrameCount
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioSource");
+                }
+
+                return Windows_Kinect_AudioSource_get_MaxSubFrameCount(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_AudioSource_get_SubFrameDuration(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan SubFrameDuration
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioSource");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_AudioSource_get_SubFrameDuration(_pNative));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern uint Windows_Kinect_AudioSource_get_SubFrameLengthInBytes(RootSystem.IntPtr pNative);
+        public  uint SubFrameLengthInBytes
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioSource");
+                }
+
+                return Windows_Kinect_AudioSource_get_SubFrameLengthInBytes(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.KinectAudioCalibrationState Windows_Kinect_AudioSource_get_AudioCalibrationState(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.KinectAudioCalibrationState AudioCalibrationState
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("AudioSource");
+                }
+
+                return Windows_Kinect_AudioSource_get_AudioCalibrationState(_pNative);
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_FrameCapturedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>>> Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_FrameCapturedEventArgs_Delegate))]
+        private static void Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>> callbackList = null;
+            Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<AudioSource>(pNative);
+                var args = new Windows.Kinect.FrameCapturedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioSource_add_FrameCaptured(RootSystem.IntPtr pNative, _Windows_Kinect_FrameCapturedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs> FrameCaptured
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_FrameCapturedEventArgs_Delegate(Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_AudioSource_add_FrameCaptured(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_AudioSource_add_FrameCaptured(_pNative, Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<AudioSource>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_AudioSource_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_AudioSource_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_AudioSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_AudioSource_OpenReader(RootSystem.IntPtr pNative);
+        public Windows.Kinect.AudioBeamFrameReader OpenReader()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("AudioSource");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_AudioSource_OpenReader(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.AudioBeamFrameReader>(objectPointer, n => new Windows.Kinect.AudioBeamFrameReader(n));
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_AudioSource_add_FrameCaptured(_pNative, Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_AudioSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/AudioSource.cs.meta

+fileFormatVersion: 2
+guid: cb60632e999b8d44cb5cfd848e264abf
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/Body.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.Body
+    //
+    public sealed partial class Body : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal Body(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_Body_AddRefObject(ref _pNative);
+        }
+
+        ~Body()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_Body_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_Body_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<Body>(_pNative);
+                Windows_Kinect_Body_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_Body_get_Activities(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] Windows.Kinect.Activity[] outKeys, [RootSystem.Runtime.InteropServices.Out] Windows.Kinect.DetectionResult[] outValues, int outCollectionSize);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_Body_get_Activities_Length(RootSystem.IntPtr pNative);
+        public  RootSystem.Collections.Generic.Dictionary<Windows.Kinect.Activity, Windows.Kinect.DetectionResult> Activities
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                int outCollectionSize = Windows_Kinect_Body_get_Activities_Length(_pNative);
+                var outKeys = new Windows.Kinect.Activity[outCollectionSize];
+                var outValues = new Windows.Kinect.DetectionResult[outCollectionSize];
+                var managedDictionary = new RootSystem.Collections.Generic.Dictionary<Windows.Kinect.Activity, Windows.Kinect.DetectionResult>();
+
+                outCollectionSize = Windows_Kinect_Body_get_Activities(_pNative, outKeys, outValues, outCollectionSize);
+                Helper.ExceptionHelper.CheckLastError();
+                for(int i=0;i<outCollectionSize;i++)
+                {
+                    managedDictionary.Add(outKeys[i], outValues[i]);
+                }
+                return managedDictionary;
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_Body_get_Appearance(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] Windows.Kinect.Appearance[] outKeys, [RootSystem.Runtime.InteropServices.Out] Windows.Kinect.DetectionResult[] outValues, int outCollectionSize);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_Body_get_Appearance_Length(RootSystem.IntPtr pNative);
+        public  RootSystem.Collections.Generic.Dictionary<Windows.Kinect.Appearance, Windows.Kinect.DetectionResult> Appearance
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                int outCollectionSize = Windows_Kinect_Body_get_Appearance_Length(_pNative);
+                var outKeys = new Windows.Kinect.Appearance[outCollectionSize];
+                var outValues = new Windows.Kinect.DetectionResult[outCollectionSize];
+                var managedDictionary = new RootSystem.Collections.Generic.Dictionary<Windows.Kinect.Appearance, Windows.Kinect.DetectionResult>();
+
+                outCollectionSize = Windows_Kinect_Body_get_Appearance(_pNative, outKeys, outValues, outCollectionSize);
+                Helper.ExceptionHelper.CheckLastError();
+                for(int i=0;i<outCollectionSize;i++)
+                {
+                    managedDictionary.Add(outKeys[i], outValues[i]);
+                }
+                return managedDictionary;
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.FrameEdges Windows_Kinect_Body_get_ClippedEdges(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.FrameEdges ClippedEdges
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                return Windows_Kinect_Body_get_ClippedEdges(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.DetectionResult Windows_Kinect_Body_get_Engaged(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.DetectionResult Engaged
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                return Windows_Kinect_Body_get_Engaged(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_Body_get_Expressions(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] Windows.Kinect.Expression[] outKeys, [RootSystem.Runtime.InteropServices.Out] Windows.Kinect.DetectionResult[] outValues, int outCollectionSize);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_Body_get_Expressions_Length(RootSystem.IntPtr pNative);
+        public  RootSystem.Collections.Generic.Dictionary<Windows.Kinect.Expression, Windows.Kinect.DetectionResult> Expressions
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                int outCollectionSize = Windows_Kinect_Body_get_Expressions_Length(_pNative);
+                var outKeys = new Windows.Kinect.Expression[outCollectionSize];
+                var outValues = new Windows.Kinect.DetectionResult[outCollectionSize];
+                var managedDictionary = new RootSystem.Collections.Generic.Dictionary<Windows.Kinect.Expression, Windows.Kinect.DetectionResult>();
+
+                outCollectionSize = Windows_Kinect_Body_get_Expressions(_pNative, outKeys, outValues, outCollectionSize);
+                Helper.ExceptionHelper.CheckLastError();
+                for(int i=0;i<outCollectionSize;i++)
+                {
+                    managedDictionary.Add(outKeys[i], outValues[i]);
+                }
+                return managedDictionary;
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.TrackingConfidence Windows_Kinect_Body_get_HandLeftConfidence(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.TrackingConfidence HandLeftConfidence
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                return Windows_Kinect_Body_get_HandLeftConfidence(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.HandState Windows_Kinect_Body_get_HandLeftState(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.HandState HandLeftState
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                return Windows_Kinect_Body_get_HandLeftState(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.TrackingConfidence Windows_Kinect_Body_get_HandRightConfidence(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.TrackingConfidence HandRightConfidence
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                return Windows_Kinect_Body_get_HandRightConfidence(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.HandState Windows_Kinect_Body_get_HandRightState(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.HandState HandRightState
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                return Windows_Kinect_Body_get_HandRightState(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_Body_get_IsRestricted(RootSystem.IntPtr pNative);
+        public  bool IsRestricted
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                return Windows_Kinect_Body_get_IsRestricted(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_Body_get_IsTracked(RootSystem.IntPtr pNative);
+        public  bool IsTracked
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                return Windows_Kinect_Body_get_IsTracked(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_Body_get_JointOrientations(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] Windows.Kinect.JointType[] outKeys, [RootSystem.Runtime.InteropServices.Out] Windows.Kinect.JointOrientation[] outValues, int outCollectionSize);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_Body_get_JointOrientations_Length(RootSystem.IntPtr pNative);
+        public  RootSystem.Collections.Generic.Dictionary<Windows.Kinect.JointType, Windows.Kinect.JointOrientation> JointOrientations
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                int outCollectionSize = Windows_Kinect_Body_get_JointOrientations_Length(_pNative);
+                var outKeys = new Windows.Kinect.JointType[outCollectionSize];
+                var outValues = new Windows.Kinect.JointOrientation[outCollectionSize];
+                var managedDictionary = new RootSystem.Collections.Generic.Dictionary<Windows.Kinect.JointType, Windows.Kinect.JointOrientation>();
+
+                outCollectionSize = Windows_Kinect_Body_get_JointOrientations(_pNative, outKeys, outValues, outCollectionSize);
+                Helper.ExceptionHelper.CheckLastError();
+                for(int i=0;i<outCollectionSize;i++)
+                {
+                    managedDictionary.Add(outKeys[i], outValues[i]);
+                }
+                return managedDictionary;
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_Body_get_Joints(RootSystem.IntPtr pNative, [RootSystem.Runtime.InteropServices.Out] Windows.Kinect.JointType[] outKeys, [RootSystem.Runtime.InteropServices.Out] Windows.Kinect.Joint[] outValues, int outCollectionSize);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_Body_get_Joints_Length(RootSystem.IntPtr pNative);
+        public  RootSystem.Collections.Generic.Dictionary<Windows.Kinect.JointType, Windows.Kinect.Joint> Joints
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                int outCollectionSize = Windows_Kinect_Body_get_Joints_Length(_pNative);
+                var outKeys = new Windows.Kinect.JointType[outCollectionSize];
+                var outValues = new Windows.Kinect.Joint[outCollectionSize];
+                var managedDictionary = new RootSystem.Collections.Generic.Dictionary<Windows.Kinect.JointType, Windows.Kinect.Joint>();
+
+                outCollectionSize = Windows_Kinect_Body_get_Joints(_pNative, outKeys, outValues, outCollectionSize);
+                Helper.ExceptionHelper.CheckLastError();
+                for(int i=0;i<outCollectionSize;i++)
+                {
+                    managedDictionary.Add(outKeys[i], outValues[i]);
+                }
+                return managedDictionary;
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.TrackingState Windows_Kinect_Body_get_LeanTrackingState(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.TrackingState LeanTrackingState
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                return Windows_Kinect_Body_get_LeanTrackingState(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern ulong Windows_Kinect_Body_get_TrackingId(RootSystem.IntPtr pNative);
+        public  ulong TrackingId
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("Body");
+                }
+
+                return Windows_Kinect_Body_get_TrackingId(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_Body_get_JointCount();
+        public static int JointCount
+        {
+            get
+            {
+                return Windows_Kinect_Body_get_JointCount();
+            }
+        }
+
+
+        // Public Methods
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/Body.cs.meta

+fileFormatVersion: 2
+guid: 2de6a71b01a15e740a2fb488ab8a1b07
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/BodyFrame.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.BodyFrame
+    //
+    public sealed partial class BodyFrame : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal BodyFrame(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_BodyFrame_AddRefObject(ref _pNative);
+        }
+
+        ~BodyFrame()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrame_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrame_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<BodyFrame>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_BodyFrame_Dispose(_pNative);
+            }
+                Windows_Kinect_BodyFrame_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_BodyFrame_get_BodyCount(RootSystem.IntPtr pNative);
+        public  int BodyCount
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyFrame");
+                }
+
+                return Windows_Kinect_BodyFrame_get_BodyCount(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyFrame_get_BodyFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.BodyFrameSource BodyFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_BodyFrame_get_BodyFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyFrameSource>(objectPointer, n => new Windows.Kinect.BodyFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyFrame_get_FloorClipPlane(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.Vector4 FloorClipPlane
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyFrame");
+                }
+
+                var objectPointer = Windows_Kinect_BodyFrame_get_FloorClipPlane(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                var obj = (Windows.Kinect.Vector4)RootSystem.Runtime.InteropServices.Marshal.PtrToStructure(objectPointer, typeof(Windows.Kinect.Vector4));
+                Windows.Kinect.KinectUnityAddinUtils.FreeMemory(objectPointer);
+                return obj;
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_BodyFrame_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyFrame");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_BodyFrame_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrame_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/BodyFrame.cs.meta

+fileFormatVersion: 2
+guid: 19d23b65a55461b4c8fcfc815e9a8be5
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/BodyFrameArrivedEventArgs.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.BodyFrameArrivedEventArgs
+    //
+    public sealed partial class BodyFrameArrivedEventArgs : RootSystem.EventArgs, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal BodyFrameArrivedEventArgs(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_BodyFrameArrivedEventArgs_AddRefObject(ref _pNative);
+        }
+
+        ~BodyFrameArrivedEventArgs()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameArrivedEventArgs_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameArrivedEventArgs_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<BodyFrameArrivedEventArgs>(_pNative);
+                Windows_Kinect_BodyFrameArrivedEventArgs_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyFrameArrivedEventArgs_get_FrameReference(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.BodyFrameReference FrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyFrameArrivedEventArgs");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_BodyFrameArrivedEventArgs_get_FrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyFrameReference>(objectPointer, n => new Windows.Kinect.BodyFrameReference(n));
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/BodyFrameArrivedEventArgs.cs.meta

+fileFormatVersion: 2
+guid: 676ce9850965f6d4fad5e20fa2a8da30
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/BodyFrameReader.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.BodyFrameReader
+    //
+    public sealed partial class BodyFrameReader : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal BodyFrameReader(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_BodyFrameReader_AddRefObject(ref _pNative);
+        }
+
+        ~BodyFrameReader()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameReader_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameReader_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<BodyFrameReader>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_BodyFrameReader_Dispose(_pNative);
+            }
+                Windows_Kinect_BodyFrameReader_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyFrameReader_get_BodyFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.BodyFrameSource BodyFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyFrameReader");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_BodyFrameReader_get_BodyFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyFrameSource>(objectPointer, n => new Windows.Kinect.BodyFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_BodyFrameReader_get_IsPaused(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameReader_put_IsPaused(RootSystem.IntPtr pNative, bool isPaused);
+        public  bool IsPaused
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyFrameReader");
+                }
+
+                return Windows_Kinect_BodyFrameReader_get_IsPaused(_pNative);
+            }
+            set
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyFrameReader");
+                }
+
+                Windows_Kinect_BodyFrameReader_put_IsPaused(_pNative, value);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_BodyFrameArrivedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.BodyFrameArrivedEventArgs>>> Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.BodyFrameArrivedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_BodyFrameArrivedEventArgs_Delegate))]
+        private static void Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.BodyFrameArrivedEventArgs>> callbackList = null;
+            Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<BodyFrameReader>(pNative);
+                var args = new Windows.Kinect.BodyFrameArrivedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameReader_add_FrameArrived(RootSystem.IntPtr pNative, _Windows_Kinect_BodyFrameArrivedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.BodyFrameArrivedEventArgs> FrameArrived
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_BodyFrameArrivedEventArgs_Delegate(Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_BodyFrameReader_add_FrameArrived(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_BodyFrameReader_add_FrameArrived(_pNative, Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<BodyFrameReader>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameReader_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_BodyFrameReader_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_BodyFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyFrameReader_AcquireLatestFrame(RootSystem.IntPtr pNative);
+        public Windows.Kinect.BodyFrame AcquireLatestFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("BodyFrameReader");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_BodyFrameReader_AcquireLatestFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyFrame>(objectPointer, n => new Windows.Kinect.BodyFrame(n));
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameReader_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_BodyFrameReader_add_FrameArrived(_pNative, Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_BodyFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_BodyFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/BodyFrameReader.cs.meta

+fileFormatVersion: 2
+guid: 3af2f300d248d614eb0f026c16be6e51
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/BodyFrameReference.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.BodyFrameReference
+    //
+    public sealed partial class BodyFrameReference : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal BodyFrameReference(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_BodyFrameReference_AddRefObject(ref _pNative);
+        }
+
+        ~BodyFrameReference()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameReference_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameReference_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<BodyFrameReference>(_pNative);
+                Windows_Kinect_BodyFrameReference_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_BodyFrameReference_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyFrameReference");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_BodyFrameReference_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyFrameReference_AcquireFrame(RootSystem.IntPtr pNative);
+        public Windows.Kinect.BodyFrame AcquireFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("BodyFrameReference");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_BodyFrameReference_AcquireFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyFrame>(objectPointer, n => new Windows.Kinect.BodyFrame(n));
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/BodyFrameReference.cs.meta

+fileFormatVersion: 2
+guid: 083a7736def5ad3429a51cc96a6c4564
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/BodyFrameSource.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.BodyFrameSource
+    //
+    public sealed partial class BodyFrameSource : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal BodyFrameSource(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_BodyFrameSource_AddRefObject(ref _pNative);
+        }
+
+        ~BodyFrameSource()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameSource_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameSource_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<BodyFrameSource>(_pNative);
+                Windows_Kinect_BodyFrameSource_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_BodyFrameSource_get_BodyCount(RootSystem.IntPtr pNative);
+        public  int BodyCount
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyFrameSource");
+                }
+
+                return Windows_Kinect_BodyFrameSource_get_BodyCount(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_BodyFrameSource_get_IsActive(RootSystem.IntPtr pNative);
+        public  bool IsActive
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyFrameSource");
+                }
+
+                return Windows_Kinect_BodyFrameSource_get_IsActive(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyFrameSource_get_KinectSensor(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.KinectSensor KinectSensor
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyFrameSource");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_BodyFrameSource_get_KinectSensor(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectSensor>(objectPointer, n => new Windows.Kinect.KinectSensor(n));
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_FrameCapturedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>>> Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_FrameCapturedEventArgs_Delegate))]
+        private static void Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>> callbackList = null;
+            Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<BodyFrameSource>(pNative);
+                var args = new Windows.Kinect.FrameCapturedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameSource_add_FrameCaptured(RootSystem.IntPtr pNative, _Windows_Kinect_FrameCapturedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs> FrameCaptured
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_FrameCapturedEventArgs_Delegate(Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_BodyFrameSource_add_FrameCaptured(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_BodyFrameSource_add_FrameCaptured(_pNative, Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<BodyFrameSource>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameSource_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_BodyFrameSource_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_BodyFrameSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyFrameSource_OpenReader(RootSystem.IntPtr pNative);
+        public Windows.Kinect.BodyFrameReader OpenReader()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("BodyFrameSource");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_BodyFrameSource_OpenReader(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyFrameReader>(objectPointer, n => new Windows.Kinect.BodyFrameReader(n));
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameSource_OverrideHandTracking(RootSystem.IntPtr pNative, ulong trackingId);
+        public void OverrideHandTracking(ulong trackingId)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("BodyFrameSource");
+            }
+
+            Windows_Kinect_BodyFrameSource_OverrideHandTracking(_pNative, trackingId);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyFrameSource_OverrideHandTracking_1(RootSystem.IntPtr pNative, ulong oldTrackingId, ulong newTrackingId);
+        public void OverrideHandTracking(ulong oldTrackingId, ulong newTrackingId)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("BodyFrameSource");
+            }
+
+            Windows_Kinect_BodyFrameSource_OverrideHandTracking_1(_pNative, oldTrackingId, newTrackingId);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_BodyFrameSource_add_FrameCaptured(_pNative, Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_BodyFrameSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/BodyFrameSource.cs.meta

+fileFormatVersion: 2
+guid: 3679e372811a218438e365b6da52873c
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/BodyIndexFrame.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.BodyIndexFrame
+    //
+    public sealed partial class BodyIndexFrame : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal BodyIndexFrame(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_BodyIndexFrame_AddRefObject(ref _pNative);
+        }
+
+        ~BodyIndexFrame()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrame_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrame_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<BodyIndexFrame>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_BodyIndexFrame_Dispose(_pNative);
+            }
+                Windows_Kinect_BodyIndexFrame_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyIndexFrame_get_BodyIndexFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.BodyIndexFrameSource BodyIndexFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyIndexFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_BodyIndexFrame_get_BodyIndexFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyIndexFrameSource>(objectPointer, n => new Windows.Kinect.BodyIndexFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyIndexFrame_get_FrameDescription(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.FrameDescription FrameDescription
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyIndexFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_BodyIndexFrame_get_FrameDescription(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.FrameDescription>(objectPointer, n => new Windows.Kinect.FrameDescription(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_BodyIndexFrame_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyIndexFrame");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_BodyIndexFrame_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrame_CopyFrameDataToArray(RootSystem.IntPtr pNative, RootSystem.IntPtr frameData, int frameDataSize);
+        public void CopyFrameDataToArray(byte[] frameData)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("BodyIndexFrame");
+            }
+
+            var frameDataSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(frameData, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _frameData = frameDataSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_BodyIndexFrame_CopyFrameDataToArray(_pNative, _frameData, frameData.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrame_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/BodyIndexFrame.cs.meta

+fileFormatVersion: 2
+guid: 31029a9c200fe984790d50a6d2875e32
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/BodyIndexFrameArrivedEventArgs.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.BodyIndexFrameArrivedEventArgs
+    //
+    public sealed partial class BodyIndexFrameArrivedEventArgs : RootSystem.EventArgs, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal BodyIndexFrameArrivedEventArgs(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_BodyIndexFrameArrivedEventArgs_AddRefObject(ref _pNative);
+        }
+
+        ~BodyIndexFrameArrivedEventArgs()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrameArrivedEventArgs_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrameArrivedEventArgs_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<BodyIndexFrameArrivedEventArgs>(_pNative);
+                Windows_Kinect_BodyIndexFrameArrivedEventArgs_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyIndexFrameArrivedEventArgs_get_FrameReference(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.BodyIndexFrameReference FrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyIndexFrameArrivedEventArgs");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_BodyIndexFrameArrivedEventArgs_get_FrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyIndexFrameReference>(objectPointer, n => new Windows.Kinect.BodyIndexFrameReference(n));
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/BodyIndexFrameArrivedEventArgs.cs.meta

+fileFormatVersion: 2
+guid: 673826e3a38138946b030da95a1d0f95
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/BodyIndexFrameReader.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.BodyIndexFrameReader
+    //
+    public sealed partial class BodyIndexFrameReader : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal BodyIndexFrameReader(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_BodyIndexFrameReader_AddRefObject(ref _pNative);
+        }
+
+        ~BodyIndexFrameReader()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrameReader_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrameReader_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<BodyIndexFrameReader>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_BodyIndexFrameReader_Dispose(_pNative);
+            }
+                Windows_Kinect_BodyIndexFrameReader_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyIndexFrameReader_get_BodyIndexFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.BodyIndexFrameSource BodyIndexFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyIndexFrameReader");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_BodyIndexFrameReader_get_BodyIndexFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyIndexFrameSource>(objectPointer, n => new Windows.Kinect.BodyIndexFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_BodyIndexFrameReader_get_IsPaused(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrameReader_put_IsPaused(RootSystem.IntPtr pNative, bool isPaused);
+        public  bool IsPaused
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyIndexFrameReader");
+                }
+
+                return Windows_Kinect_BodyIndexFrameReader_get_IsPaused(_pNative);
+            }
+            set
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyIndexFrameReader");
+                }
+
+                Windows_Kinect_BodyIndexFrameReader_put_IsPaused(_pNative, value);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.BodyIndexFrameArrivedEventArgs>>> Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.BodyIndexFrameArrivedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate))]
+        private static void Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.BodyIndexFrameArrivedEventArgs>> callbackList = null;
+            Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<BodyIndexFrameReader>(pNative);
+                var args = new Windows.Kinect.BodyIndexFrameArrivedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrameReader_add_FrameArrived(RootSystem.IntPtr pNative, _Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.BodyIndexFrameArrivedEventArgs> FrameArrived
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate(Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_BodyIndexFrameReader_add_FrameArrived(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_BodyIndexFrameReader_add_FrameArrived(_pNative, Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<BodyIndexFrameReader>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrameReader_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_BodyIndexFrameReader_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_BodyIndexFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyIndexFrameReader_AcquireLatestFrame(RootSystem.IntPtr pNative);
+        public Windows.Kinect.BodyIndexFrame AcquireLatestFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("BodyIndexFrameReader");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_BodyIndexFrameReader_AcquireLatestFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyIndexFrame>(objectPointer, n => new Windows.Kinect.BodyIndexFrame(n));
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrameReader_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_BodyIndexFrameReader_add_FrameArrived(_pNative, Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_BodyIndexFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_BodyIndexFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/BodyIndexFrameReader.cs.meta

+fileFormatVersion: 2
+guid: 0a9ba9eb393e51241bb15db5d3bf3390
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/BodyIndexFrameReference.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.BodyIndexFrameReference
+    //
+    public sealed partial class BodyIndexFrameReference : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal BodyIndexFrameReference(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_BodyIndexFrameReference_AddRefObject(ref _pNative);
+        }
+
+        ~BodyIndexFrameReference()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrameReference_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrameReference_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<BodyIndexFrameReference>(_pNative);
+                Windows_Kinect_BodyIndexFrameReference_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_BodyIndexFrameReference_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyIndexFrameReference");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_BodyIndexFrameReference_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyIndexFrameReference_AcquireFrame(RootSystem.IntPtr pNative);
+        public Windows.Kinect.BodyIndexFrame AcquireFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("BodyIndexFrameReference");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_BodyIndexFrameReference_AcquireFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyIndexFrame>(objectPointer, n => new Windows.Kinect.BodyIndexFrame(n));
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/BodyIndexFrameReference.cs.meta

+fileFormatVersion: 2
+guid: 3ee08767e1297454a93a5759b975860d
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/BodyIndexFrameSource.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.BodyIndexFrameSource
+    //
+    public sealed partial class BodyIndexFrameSource : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal BodyIndexFrameSource(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_BodyIndexFrameSource_AddRefObject(ref _pNative);
+        }
+
+        ~BodyIndexFrameSource()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrameSource_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrameSource_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<BodyIndexFrameSource>(_pNative);
+                Windows_Kinect_BodyIndexFrameSource_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyIndexFrameSource_get_FrameDescription(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.FrameDescription FrameDescription
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyIndexFrameSource");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_BodyIndexFrameSource_get_FrameDescription(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.FrameDescription>(objectPointer, n => new Windows.Kinect.FrameDescription(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_BodyIndexFrameSource_get_IsActive(RootSystem.IntPtr pNative);
+        public  bool IsActive
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyIndexFrameSource");
+                }
+
+                return Windows_Kinect_BodyIndexFrameSource_get_IsActive(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyIndexFrameSource_get_KinectSensor(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.KinectSensor KinectSensor
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("BodyIndexFrameSource");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_BodyIndexFrameSource_get_KinectSensor(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectSensor>(objectPointer, n => new Windows.Kinect.KinectSensor(n));
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_FrameCapturedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>>> Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_FrameCapturedEventArgs_Delegate))]
+        private static void Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>> callbackList = null;
+            Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<BodyIndexFrameSource>(pNative);
+                var args = new Windows.Kinect.FrameCapturedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrameSource_add_FrameCaptured(RootSystem.IntPtr pNative, _Windows_Kinect_FrameCapturedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs> FrameCaptured
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_FrameCapturedEventArgs_Delegate(Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_BodyIndexFrameSource_add_FrameCaptured(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_BodyIndexFrameSource_add_FrameCaptured(_pNative, Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<BodyIndexFrameSource>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_BodyIndexFrameSource_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_BodyIndexFrameSource_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_BodyIndexFrameSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_BodyIndexFrameSource_OpenReader(RootSystem.IntPtr pNative);
+        public Windows.Kinect.BodyIndexFrameReader OpenReader()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("BodyIndexFrameSource");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_BodyIndexFrameSource_OpenReader(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyIndexFrameReader>(objectPointer, n => new Windows.Kinect.BodyIndexFrameReader(n));
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_BodyIndexFrameSource_add_FrameCaptured(_pNative, Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_BodyIndexFrameSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/BodyIndexFrameSource.cs.meta

+fileFormatVersion: 2
+guid: 7568d115ed2fcca4ba26af8d7e3252c6
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/CameraSpacePoint.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.CameraSpacePoint
+    //
+    [RootSystem.Runtime.InteropServices.StructLayout(RootSystem.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct CameraSpacePoint
+    {
+        public float X { get; set; }
+        public float Y { get; set; }
+        public float Z { get; set; }
+
+        public override int GetHashCode()
+        {
+            return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (!(obj is CameraSpacePoint))
+            {
+                return false;
+            }
+
+            return this.Equals((CameraSpacePoint)obj);
+        }
+
+        public bool Equals(CameraSpacePoint obj)
+        {
+            return X.Equals(obj.X) && Y.Equals(obj.Y) && Z.Equals(obj.Z);
+        }
+
+        public static bool operator ==(CameraSpacePoint a, CameraSpacePoint b)
+        {
+            return a.Equals(b);
+        }
+
+        public static bool operator !=(CameraSpacePoint a, CameraSpacePoint b)
+        {
+            return !(a.Equals(b));
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/CameraSpacePoint.cs.meta

+fileFormatVersion: 2
+guid: ef37675a811881f44be680e69695e9e3
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/ColorCameraSettings.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.ColorCameraSettings
+    //
+    public sealed partial class ColorCameraSettings : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal ColorCameraSettings(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_ColorCameraSettings_AddRefObject(ref _pNative);
+        }
+
+        ~ColorCameraSettings()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorCameraSettings_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorCameraSettings_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<ColorCameraSettings>(_pNative);
+                Windows_Kinect_ColorCameraSettings_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_ColorCameraSettings_get_ExposureTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan ExposureTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorCameraSettings");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_ColorCameraSettings_get_ExposureTime(_pNative));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_ColorCameraSettings_get_FrameInterval(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan FrameInterval
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorCameraSettings");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_ColorCameraSettings_get_FrameInterval(_pNative));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern float Windows_Kinect_ColorCameraSettings_get_Gain(RootSystem.IntPtr pNative);
+        public  float Gain
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorCameraSettings");
+                }
+
+                return Windows_Kinect_ColorCameraSettings_get_Gain(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern float Windows_Kinect_ColorCameraSettings_get_Gamma(RootSystem.IntPtr pNative);
+        public  float Gamma
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorCameraSettings");
+                }
+
+                return Windows_Kinect_ColorCameraSettings_get_Gamma(_pNative);
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/ColorCameraSettings.cs.meta

+fileFormatVersion: 2
+guid: 1f199f6bb5e11b941b4c707a6783daaa
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/ColorFrame.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.ColorFrame
+    //
+    public sealed partial class ColorFrame : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal ColorFrame(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_ColorFrame_AddRefObject(ref _pNative);
+        }
+
+        ~ColorFrame()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrame_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrame_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<ColorFrame>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_ColorFrame_Dispose(_pNative);
+            }
+                Windows_Kinect_ColorFrame_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_ColorFrame_get_ColorCameraSettings(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.ColorCameraSettings ColorCameraSettings
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_ColorFrame_get_ColorCameraSettings(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.ColorCameraSettings>(objectPointer, n => new Windows.Kinect.ColorCameraSettings(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_ColorFrame_get_ColorFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.ColorFrameSource ColorFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_ColorFrame_get_ColorFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.ColorFrameSource>(objectPointer, n => new Windows.Kinect.ColorFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_ColorFrame_get_FrameDescription(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.FrameDescription FrameDescription
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_ColorFrame_get_FrameDescription(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.FrameDescription>(objectPointer, n => new Windows.Kinect.FrameDescription(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.ColorImageFormat Windows_Kinect_ColorFrame_get_RawColorImageFormat(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.ColorImageFormat RawColorImageFormat
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorFrame");
+                }
+
+                return Windows_Kinect_ColorFrame_get_RawColorImageFormat(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_ColorFrame_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorFrame");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_ColorFrame_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrame_CopyRawFrameDataToArray(RootSystem.IntPtr pNative, RootSystem.IntPtr frameData, int frameDataSize);
+        public void CopyRawFrameDataToArray(byte[] frameData)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("ColorFrame");
+            }
+
+            var frameDataSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(frameData, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _frameData = frameDataSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_ColorFrame_CopyRawFrameDataToArray(_pNative, _frameData, frameData.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrame_CopyConvertedFrameDataToArray(RootSystem.IntPtr pNative, RootSystem.IntPtr frameData, int frameDataSize, Windows.Kinect.ColorImageFormat colorFormat);
+        public void CopyConvertedFrameDataToArray(byte[] frameData, Windows.Kinect.ColorImageFormat colorFormat)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("ColorFrame");
+            }
+
+            var frameDataSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(frameData, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _frameData = frameDataSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_ColorFrame_CopyConvertedFrameDataToArray(_pNative, _frameData, frameData.Length, colorFormat);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_ColorFrame_CreateFrameDescription(RootSystem.IntPtr pNative, Windows.Kinect.ColorImageFormat format);
+        public Windows.Kinect.FrameDescription CreateFrameDescription(Windows.Kinect.ColorImageFormat format)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("ColorFrame");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_ColorFrame_CreateFrameDescription(_pNative, format);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.FrameDescription>(objectPointer, n => new Windows.Kinect.FrameDescription(n));
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrame_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/ColorFrame.cs.meta

+fileFormatVersion: 2
+guid: 4e3ef938a829c1d4385d938971be0b73
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/ColorFrameArrivedEventArgs.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.ColorFrameArrivedEventArgs
+    //
+    public sealed partial class ColorFrameArrivedEventArgs : RootSystem.EventArgs, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal ColorFrameArrivedEventArgs(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_ColorFrameArrivedEventArgs_AddRefObject(ref _pNative);
+        }
+
+        ~ColorFrameArrivedEventArgs()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrameArrivedEventArgs_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrameArrivedEventArgs_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<ColorFrameArrivedEventArgs>(_pNative);
+                Windows_Kinect_ColorFrameArrivedEventArgs_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_ColorFrameArrivedEventArgs_get_FrameReference(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.ColorFrameReference FrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorFrameArrivedEventArgs");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_ColorFrameArrivedEventArgs_get_FrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.ColorFrameReference>(objectPointer, n => new Windows.Kinect.ColorFrameReference(n));
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/ColorFrameArrivedEventArgs.cs.meta

+fileFormatVersion: 2
+guid: 383ab6b5e32edbc4ca3eca80db481330
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/ColorFrameReader.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.ColorFrameReader
+    //
+    public sealed partial class ColorFrameReader : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal ColorFrameReader(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_ColorFrameReader_AddRefObject(ref _pNative);
+        }
+
+        ~ColorFrameReader()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrameReader_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrameReader_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<ColorFrameReader>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_ColorFrameReader_Dispose(_pNative);
+            }
+                Windows_Kinect_ColorFrameReader_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_ColorFrameReader_get_ColorFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.ColorFrameSource ColorFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorFrameReader");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_ColorFrameReader_get_ColorFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.ColorFrameSource>(objectPointer, n => new Windows.Kinect.ColorFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_ColorFrameReader_get_IsPaused(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrameReader_put_IsPaused(RootSystem.IntPtr pNative, bool isPaused);
+        public  bool IsPaused
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorFrameReader");
+                }
+
+                return Windows_Kinect_ColorFrameReader_get_IsPaused(_pNative);
+            }
+            set
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorFrameReader");
+                }
+
+                Windows_Kinect_ColorFrameReader_put_IsPaused(_pNative, value);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_ColorFrameArrivedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.ColorFrameArrivedEventArgs>>> Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.ColorFrameArrivedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_ColorFrameArrivedEventArgs_Delegate))]
+        private static void Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.ColorFrameArrivedEventArgs>> callbackList = null;
+            Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<ColorFrameReader>(pNative);
+                var args = new Windows.Kinect.ColorFrameArrivedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrameReader_add_FrameArrived(RootSystem.IntPtr pNative, _Windows_Kinect_ColorFrameArrivedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.ColorFrameArrivedEventArgs> FrameArrived
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_ColorFrameArrivedEventArgs_Delegate(Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_ColorFrameReader_add_FrameArrived(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_ColorFrameReader_add_FrameArrived(_pNative, Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<ColorFrameReader>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrameReader_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_ColorFrameReader_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_ColorFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_ColorFrameReader_AcquireLatestFrame(RootSystem.IntPtr pNative);
+        public Windows.Kinect.ColorFrame AcquireLatestFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("ColorFrameReader");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_ColorFrameReader_AcquireLatestFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.ColorFrame>(objectPointer, n => new Windows.Kinect.ColorFrame(n));
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrameReader_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_ColorFrameReader_add_FrameArrived(_pNative, Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_ColorFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_ColorFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/ColorFrameReader.cs.meta

+fileFormatVersion: 2
+guid: 6c8a043d45b0ce641bfe872c2654ec00
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/ColorFrameReference.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.ColorFrameReference
+    //
+    public sealed partial class ColorFrameReference : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal ColorFrameReference(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_ColorFrameReference_AddRefObject(ref _pNative);
+        }
+
+        ~ColorFrameReference()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrameReference_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrameReference_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<ColorFrameReference>(_pNative);
+                Windows_Kinect_ColorFrameReference_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_ColorFrameReference_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorFrameReference");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_ColorFrameReference_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_ColorFrameReference_AcquireFrame(RootSystem.IntPtr pNative);
+        public Windows.Kinect.ColorFrame AcquireFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("ColorFrameReference");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_ColorFrameReference_AcquireFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.ColorFrame>(objectPointer, n => new Windows.Kinect.ColorFrame(n));
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/ColorFrameReference.cs.meta

+fileFormatVersion: 2
+guid: 05fb49d39d96f5a4ea512141fab5cff6
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/ColorFrameSource.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.ColorFrameSource
+    //
+    public sealed partial class ColorFrameSource : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal ColorFrameSource(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_ColorFrameSource_AddRefObject(ref _pNative);
+        }
+
+        ~ColorFrameSource()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrameSource_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrameSource_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<ColorFrameSource>(_pNative);
+                Windows_Kinect_ColorFrameSource_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_ColorFrameSource_get_FrameDescription(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.FrameDescription FrameDescription
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorFrameSource");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_ColorFrameSource_get_FrameDescription(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.FrameDescription>(objectPointer, n => new Windows.Kinect.FrameDescription(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_ColorFrameSource_get_IsActive(RootSystem.IntPtr pNative);
+        public  bool IsActive
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorFrameSource");
+                }
+
+                return Windows_Kinect_ColorFrameSource_get_IsActive(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_ColorFrameSource_get_KinectSensor(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.KinectSensor KinectSensor
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("ColorFrameSource");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_ColorFrameSource_get_KinectSensor(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectSensor>(objectPointer, n => new Windows.Kinect.KinectSensor(n));
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_FrameCapturedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>>> Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_FrameCapturedEventArgs_Delegate))]
+        private static void Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>> callbackList = null;
+            Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<ColorFrameSource>(pNative);
+                var args = new Windows.Kinect.FrameCapturedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrameSource_add_FrameCaptured(RootSystem.IntPtr pNative, _Windows_Kinect_FrameCapturedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs> FrameCaptured
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_FrameCapturedEventArgs_Delegate(Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_ColorFrameSource_add_FrameCaptured(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_ColorFrameSource_add_FrameCaptured(_pNative, Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<ColorFrameSource>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_ColorFrameSource_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_ColorFrameSource_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_ColorFrameSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_ColorFrameSource_OpenReader(RootSystem.IntPtr pNative);
+        public Windows.Kinect.ColorFrameReader OpenReader()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("ColorFrameSource");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_ColorFrameSource_OpenReader(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.ColorFrameReader>(objectPointer, n => new Windows.Kinect.ColorFrameReader(n));
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_ColorFrameSource_CreateFrameDescription(RootSystem.IntPtr pNative, Windows.Kinect.ColorImageFormat format);
+        public Windows.Kinect.FrameDescription CreateFrameDescription(Windows.Kinect.ColorImageFormat format)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("ColorFrameSource");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_ColorFrameSource_CreateFrameDescription(_pNative, format);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.FrameDescription>(objectPointer, n => new Windows.Kinect.FrameDescription(n));
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_ColorFrameSource_add_FrameCaptured(_pNative, Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_ColorFrameSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/ColorFrameSource.cs.meta

+fileFormatVersion: 2
+guid: 31be1a3a8cdc0d1408a7eada947fe966
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/ColorImageFormat.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.ColorImageFormat
+    //
+    public enum ColorImageFormat : int
+    {
+        None                                     =0,
+        Rgba                                     =1,
+        Yuv                                      =2,
+        Bgra                                     =3,
+        Bayer                                    =4,
+        Yuy2                                     =5,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/ColorImageFormat.cs.meta

+fileFormatVersion: 2
+guid: a203492c798220244927d338800eec2f
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/ColorSpacePoint.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.ColorSpacePoint
+    //
+    [RootSystem.Runtime.InteropServices.StructLayout(RootSystem.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct ColorSpacePoint
+    {
+        public float X { get; set; }
+        public float Y { get; set; }
+
+        public override int GetHashCode()
+        {
+            return X.GetHashCode() ^ Y.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (!(obj is ColorSpacePoint))
+            {
+                return false;
+            }
+
+            return this.Equals((ColorSpacePoint)obj);
+        }
+
+        public bool Equals(ColorSpacePoint obj)
+        {
+            return X.Equals(obj.X) && Y.Equals(obj.Y);
+        }
+
+        public static bool operator ==(ColorSpacePoint a, ColorSpacePoint b)
+        {
+            return a.Equals(b);
+        }
+
+        public static bool operator !=(ColorSpacePoint a, ColorSpacePoint b)
+        {
+            return !(a.Equals(b));
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/ColorSpacePoint.cs.meta

+fileFormatVersion: 2
+guid: 9eb5711cb5d886b45883ead06f286283
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/CoordinateMapper.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.CoordinateMapper
+    //
+    public sealed partial class CoordinateMapper : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal CoordinateMapper(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_CoordinateMapper_AddRefObject(ref _pNative);
+        }
+
+        ~CoordinateMapper()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_CoordinateMapper_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_CoordinateMapper_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<CoordinateMapper>(_pNative);
+                Windows_Kinect_CoordinateMapper_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.CoordinateMappingChangedEventArgs>>> Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.CoordinateMappingChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate))]
+        private static void Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.CoordinateMappingChangedEventArgs>> callbackList = null;
+            Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<CoordinateMapper>(pNative);
+                var args = new Windows.Kinect.CoordinateMappingChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_CoordinateMapper_add_CoordinateMappingChanged(RootSystem.IntPtr pNative, _Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.CoordinateMappingChangedEventArgs> CoordinateMappingChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate(Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_CoordinateMapper_add_CoordinateMappingChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_CoordinateMapper_add_CoordinateMappingChanged(_pNative, Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_CoordinateMapper_MapCameraPointToDepthSpace(RootSystem.IntPtr pNative, Windows.Kinect.CameraSpacePoint cameraPoint);
+        public Windows.Kinect.DepthSpacePoint MapCameraPointToDepthSpace(Windows.Kinect.CameraSpacePoint cameraPoint)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            var objectPointer = Windows_Kinect_CoordinateMapper_MapCameraPointToDepthSpace(_pNative, cameraPoint);
+            Helper.ExceptionHelper.CheckLastError();
+            var obj = (Windows.Kinect.DepthSpacePoint)RootSystem.Runtime.InteropServices.Marshal.PtrToStructure(objectPointer, typeof(Windows.Kinect.DepthSpacePoint));
+            RootSystem.Runtime.InteropServices.Marshal.FreeHGlobal(objectPointer);
+            return obj;
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_CoordinateMapper_MapCameraPointToColorSpace(RootSystem.IntPtr pNative, Windows.Kinect.CameraSpacePoint cameraPoint);
+        public Windows.Kinect.ColorSpacePoint MapCameraPointToColorSpace(Windows.Kinect.CameraSpacePoint cameraPoint)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            var objectPointer = Windows_Kinect_CoordinateMapper_MapCameraPointToColorSpace(_pNative, cameraPoint);
+            Helper.ExceptionHelper.CheckLastError();
+            var obj = (Windows.Kinect.ColorSpacePoint)RootSystem.Runtime.InteropServices.Marshal.PtrToStructure(objectPointer, typeof(Windows.Kinect.ColorSpacePoint));
+            RootSystem.Runtime.InteropServices.Marshal.FreeHGlobal(objectPointer);
+            return obj;
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_CoordinateMapper_MapDepthPointToCameraSpace(RootSystem.IntPtr pNative, Windows.Kinect.DepthSpacePoint depthPoint, ushort depth);
+        public Windows.Kinect.CameraSpacePoint MapDepthPointToCameraSpace(Windows.Kinect.DepthSpacePoint depthPoint, ushort depth)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            var objectPointer = Windows_Kinect_CoordinateMapper_MapDepthPointToCameraSpace(_pNative, depthPoint, depth);
+            Helper.ExceptionHelper.CheckLastError();
+            var obj = (Windows.Kinect.CameraSpacePoint)RootSystem.Runtime.InteropServices.Marshal.PtrToStructure(objectPointer, typeof(Windows.Kinect.CameraSpacePoint));
+            RootSystem.Runtime.InteropServices.Marshal.FreeHGlobal(objectPointer);
+            return obj;
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_CoordinateMapper_MapDepthPointToColorSpace(RootSystem.IntPtr pNative, Windows.Kinect.DepthSpacePoint depthPoint, ushort depth);
+        public Windows.Kinect.ColorSpacePoint MapDepthPointToColorSpace(Windows.Kinect.DepthSpacePoint depthPoint, ushort depth)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            var objectPointer = Windows_Kinect_CoordinateMapper_MapDepthPointToColorSpace(_pNative, depthPoint, depth);
+            Helper.ExceptionHelper.CheckLastError();
+            var obj = (Windows.Kinect.ColorSpacePoint)RootSystem.Runtime.InteropServices.Marshal.PtrToStructure(objectPointer, typeof(Windows.Kinect.ColorSpacePoint));
+            RootSystem.Runtime.InteropServices.Marshal.FreeHGlobal(objectPointer);
+            return obj;
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_CoordinateMapper_MapCameraPointsToDepthSpace(RootSystem.IntPtr pNative, RootSystem.IntPtr cameraPoints, int cameraPointsSize, RootSystem.IntPtr depthPoints, int depthPointsSize);
+        public void MapCameraPointsToDepthSpace(Windows.Kinect.CameraSpacePoint[] cameraPoints, Windows.Kinect.DepthSpacePoint[] depthPoints)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            var cameraPointsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(cameraPoints, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _cameraPoints = cameraPointsSmartGCHandle.AddrOfPinnedObject();
+            var depthPointsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(depthPoints, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _depthPoints = depthPointsSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_CoordinateMapper_MapCameraPointsToDepthSpace(_pNative, _cameraPoints, cameraPoints.Length, _depthPoints, depthPoints.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_CoordinateMapper_MapCameraPointsToColorSpace(RootSystem.IntPtr pNative, RootSystem.IntPtr cameraPoints, int cameraPointsSize, RootSystem.IntPtr colorPoints, int colorPointsSize);
+        public void MapCameraPointsToColorSpace(Windows.Kinect.CameraSpacePoint[] cameraPoints, Windows.Kinect.ColorSpacePoint[] colorPoints)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            var cameraPointsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(cameraPoints, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _cameraPoints = cameraPointsSmartGCHandle.AddrOfPinnedObject();
+            var colorPointsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(colorPoints, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _colorPoints = colorPointsSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_CoordinateMapper_MapCameraPointsToColorSpace(_pNative, _cameraPoints, cameraPoints.Length, _colorPoints, colorPoints.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_CoordinateMapper_MapDepthPointsToCameraSpace(RootSystem.IntPtr pNative, RootSystem.IntPtr depthPoints, int depthPointsSize, RootSystem.IntPtr depths, int depthsSize, RootSystem.IntPtr cameraPoints, int cameraPointsSize);
+        public void MapDepthPointsToCameraSpace(Windows.Kinect.DepthSpacePoint[] depthPoints, ushort[] depths, Windows.Kinect.CameraSpacePoint[] cameraPoints)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            var depthPointsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(depthPoints, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _depthPoints = depthPointsSmartGCHandle.AddrOfPinnedObject();
+            var depthsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(depths, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _depths = depthsSmartGCHandle.AddrOfPinnedObject();
+            var cameraPointsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(cameraPoints, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _cameraPoints = cameraPointsSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_CoordinateMapper_MapDepthPointsToCameraSpace(_pNative, _depthPoints, depthPoints.Length, _depths, depths.Length, _cameraPoints, cameraPoints.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_CoordinateMapper_MapDepthPointsToColorSpace(RootSystem.IntPtr pNative, RootSystem.IntPtr depthPoints, int depthPointsSize, RootSystem.IntPtr depths, int depthsSize, RootSystem.IntPtr colorPoints, int colorPointsSize);
+        public void MapDepthPointsToColorSpace(Windows.Kinect.DepthSpacePoint[] depthPoints, ushort[] depths, Windows.Kinect.ColorSpacePoint[] colorPoints)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            var depthPointsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(depthPoints, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _depthPoints = depthPointsSmartGCHandle.AddrOfPinnedObject();
+            var depthsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(depths, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _depths = depthsSmartGCHandle.AddrOfPinnedObject();
+            var colorPointsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(colorPoints, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _colorPoints = colorPointsSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_CoordinateMapper_MapDepthPointsToColorSpace(_pNative, _depthPoints, depthPoints.Length, _depths, depths.Length, _colorPoints, colorPoints.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_CoordinateMapper_MapDepthFrameToCameraSpace(RootSystem.IntPtr pNative, RootSystem.IntPtr depthFrameData, int depthFrameDataSize, RootSystem.IntPtr cameraSpacePoints, int cameraSpacePointsSize);
+        public void MapDepthFrameToCameraSpace(ushort[] depthFrameData, Windows.Kinect.CameraSpacePoint[] cameraSpacePoints)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            var depthFrameDataSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(depthFrameData, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _depthFrameData = depthFrameDataSmartGCHandle.AddrOfPinnedObject();
+            var cameraSpacePointsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(cameraSpacePoints, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _cameraSpacePoints = cameraSpacePointsSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_CoordinateMapper_MapDepthFrameToCameraSpace(_pNative, _depthFrameData, depthFrameData.Length, _cameraSpacePoints, cameraSpacePoints.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_CoordinateMapper_MapDepthFrameToColorSpace(RootSystem.IntPtr pNative, RootSystem.IntPtr depthFrameData, int depthFrameDataSize, RootSystem.IntPtr colorSpacePoints, int colorSpacePointsSize);
+        public void MapDepthFrameToColorSpace(ushort[] depthFrameData, Windows.Kinect.ColorSpacePoint[] colorSpacePoints)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            var depthFrameDataSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(depthFrameData, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _depthFrameData = depthFrameDataSmartGCHandle.AddrOfPinnedObject();
+            var colorSpacePointsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(colorSpacePoints, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _colorSpacePoints = colorSpacePointsSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_CoordinateMapper_MapDepthFrameToColorSpace(_pNative, _depthFrameData, depthFrameData.Length, _colorSpacePoints, colorSpacePoints.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_CoordinateMapper_MapColorFrameToDepthSpace(RootSystem.IntPtr pNative, RootSystem.IntPtr depthFrameData, int depthFrameDataSize, RootSystem.IntPtr depthSpacePoints, int depthSpacePointsSize);
+        public void MapColorFrameToDepthSpace(ushort[] depthFrameData, Windows.Kinect.DepthSpacePoint[] depthSpacePoints)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            var depthFrameDataSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(depthFrameData, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _depthFrameData = depthFrameDataSmartGCHandle.AddrOfPinnedObject();
+            var depthSpacePointsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(depthSpacePoints, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _depthSpacePoints = depthSpacePointsSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_CoordinateMapper_MapColorFrameToDepthSpace(_pNative, _depthFrameData, depthFrameData.Length, _depthSpacePoints, depthSpacePoints.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_CoordinateMapper_MapColorFrameToCameraSpace(RootSystem.IntPtr pNative, RootSystem.IntPtr depthFrameData, int depthFrameDataSize, RootSystem.IntPtr cameraSpacePoints, int cameraSpacePointsSize);
+        public void MapColorFrameToCameraSpace(ushort[] depthFrameData, Windows.Kinect.CameraSpacePoint[] cameraSpacePoints)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("CoordinateMapper");
+            }
+
+            var depthFrameDataSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(depthFrameData, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _depthFrameData = depthFrameDataSmartGCHandle.AddrOfPinnedObject();
+            var cameraSpacePointsSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(cameraSpacePoints, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _cameraSpacePoints = cameraSpacePointsSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_CoordinateMapper_MapColorFrameToCameraSpace(_pNative, _depthFrameData, depthFrameData.Length, _cameraSpacePoints, cameraSpacePoints.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_CoordinateMapper_add_CoordinateMappingChanged(_pNative, Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_CoordinateMappingChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/CoordinateMapper.cs.meta

+fileFormatVersion: 2
+guid: 452370c006443bb40bc44aa5d4bd8def
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/CoordinateMappingChangedEventArgs.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.CoordinateMappingChangedEventArgs
+    //
+    public sealed partial class CoordinateMappingChangedEventArgs : RootSystem.EventArgs, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal CoordinateMappingChangedEventArgs(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_CoordinateMappingChangedEventArgs_AddRefObject(ref _pNative);
+        }
+
+        ~CoordinateMappingChangedEventArgs()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_CoordinateMappingChangedEventArgs_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_CoordinateMappingChangedEventArgs_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<CoordinateMappingChangedEventArgs>(_pNative);
+                Windows_Kinect_CoordinateMappingChangedEventArgs_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/CoordinateMappingChangedEventArgs.cs.meta

+fileFormatVersion: 2
+guid: 82cb5d8afd91cba43a5380999e22e2cb
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/DepthFrame.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.DepthFrame
+    //
+    public sealed partial class DepthFrame : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal DepthFrame(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_DepthFrame_AddRefObject(ref _pNative);
+        }
+
+        ~DepthFrame()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrame_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrame_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<DepthFrame>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_DepthFrame_Dispose(_pNative);
+            }
+                Windows_Kinect_DepthFrame_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_DepthFrame_get_DepthFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.DepthFrameSource DepthFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_DepthFrame_get_DepthFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.DepthFrameSource>(objectPointer, n => new Windows.Kinect.DepthFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern ushort Windows_Kinect_DepthFrame_get_DepthMaxReliableDistance(RootSystem.IntPtr pNative);
+        public  ushort DepthMaxReliableDistance
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrame");
+                }
+
+                return Windows_Kinect_DepthFrame_get_DepthMaxReliableDistance(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern ushort Windows_Kinect_DepthFrame_get_DepthMinReliableDistance(RootSystem.IntPtr pNative);
+        public  ushort DepthMinReliableDistance
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrame");
+                }
+
+                return Windows_Kinect_DepthFrame_get_DepthMinReliableDistance(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_DepthFrame_get_FrameDescription(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.FrameDescription FrameDescription
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_DepthFrame_get_FrameDescription(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.FrameDescription>(objectPointer, n => new Windows.Kinect.FrameDescription(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_DepthFrame_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrame");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_DepthFrame_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrame_CopyFrameDataToArray(RootSystem.IntPtr pNative, RootSystem.IntPtr frameData, int frameDataSize);
+        public void CopyFrameDataToArray(ushort[] frameData)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("DepthFrame");
+            }
+
+            var frameDataSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(frameData, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _frameData = frameDataSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_DepthFrame_CopyFrameDataToArray(_pNative, _frameData, frameData.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrame_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/DepthFrame.cs.meta

+fileFormatVersion: 2
+guid: 1cc3d786ee7037e40b806839fdca184a
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/DepthFrameArrivedEventArgs.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.DepthFrameArrivedEventArgs
+    //
+    public sealed partial class DepthFrameArrivedEventArgs : RootSystem.EventArgs, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal DepthFrameArrivedEventArgs(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_DepthFrameArrivedEventArgs_AddRefObject(ref _pNative);
+        }
+
+        ~DepthFrameArrivedEventArgs()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrameArrivedEventArgs_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrameArrivedEventArgs_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<DepthFrameArrivedEventArgs>(_pNative);
+                Windows_Kinect_DepthFrameArrivedEventArgs_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_DepthFrameArrivedEventArgs_get_FrameReference(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.DepthFrameReference FrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrameArrivedEventArgs");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_DepthFrameArrivedEventArgs_get_FrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.DepthFrameReference>(objectPointer, n => new Windows.Kinect.DepthFrameReference(n));
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/DepthFrameArrivedEventArgs.cs.meta

+fileFormatVersion: 2
+guid: c09496fb04e3d9c43b5fbf4ac998ff6e
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/DepthFrameReader.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.DepthFrameReader
+    //
+    public sealed partial class DepthFrameReader : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal DepthFrameReader(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_DepthFrameReader_AddRefObject(ref _pNative);
+        }
+
+        ~DepthFrameReader()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrameReader_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrameReader_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<DepthFrameReader>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_DepthFrameReader_Dispose(_pNative);
+            }
+                Windows_Kinect_DepthFrameReader_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_DepthFrameReader_get_DepthFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.DepthFrameSource DepthFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrameReader");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_DepthFrameReader_get_DepthFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.DepthFrameSource>(objectPointer, n => new Windows.Kinect.DepthFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_DepthFrameReader_get_IsPaused(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrameReader_put_IsPaused(RootSystem.IntPtr pNative, bool isPaused);
+        public  bool IsPaused
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrameReader");
+                }
+
+                return Windows_Kinect_DepthFrameReader_get_IsPaused(_pNative);
+            }
+            set
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrameReader");
+                }
+
+                Windows_Kinect_DepthFrameReader_put_IsPaused(_pNative, value);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_DepthFrameArrivedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.DepthFrameArrivedEventArgs>>> Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.DepthFrameArrivedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_DepthFrameArrivedEventArgs_Delegate))]
+        private static void Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.DepthFrameArrivedEventArgs>> callbackList = null;
+            Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<DepthFrameReader>(pNative);
+                var args = new Windows.Kinect.DepthFrameArrivedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrameReader_add_FrameArrived(RootSystem.IntPtr pNative, _Windows_Kinect_DepthFrameArrivedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.DepthFrameArrivedEventArgs> FrameArrived
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_DepthFrameArrivedEventArgs_Delegate(Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_DepthFrameReader_add_FrameArrived(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_DepthFrameReader_add_FrameArrived(_pNative, Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<DepthFrameReader>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrameReader_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_DepthFrameReader_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_DepthFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_DepthFrameReader_AcquireLatestFrame(RootSystem.IntPtr pNative);
+        public Windows.Kinect.DepthFrame AcquireLatestFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("DepthFrameReader");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_DepthFrameReader_AcquireLatestFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.DepthFrame>(objectPointer, n => new Windows.Kinect.DepthFrame(n));
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrameReader_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_DepthFrameReader_add_FrameArrived(_pNative, Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_DepthFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_DepthFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/DepthFrameReader.cs.meta

+fileFormatVersion: 2
+guid: 19e437f0dfc211640b0b56e1e0221a8f
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/DepthFrameReference.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.DepthFrameReference
+    //
+    public sealed partial class DepthFrameReference : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal DepthFrameReference(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_DepthFrameReference_AddRefObject(ref _pNative);
+        }
+
+        ~DepthFrameReference()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrameReference_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrameReference_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<DepthFrameReference>(_pNative);
+                Windows_Kinect_DepthFrameReference_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_DepthFrameReference_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrameReference");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_DepthFrameReference_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_DepthFrameReference_AcquireFrame(RootSystem.IntPtr pNative);
+        public Windows.Kinect.DepthFrame AcquireFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("DepthFrameReference");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_DepthFrameReference_AcquireFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.DepthFrame>(objectPointer, n => new Windows.Kinect.DepthFrame(n));
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/DepthFrameReference.cs.meta

+fileFormatVersion: 2
+guid: f53daf0889b08bf4494ecbd1914a99d6
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/DepthFrameSource.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.DepthFrameSource
+    //
+    public sealed partial class DepthFrameSource : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal DepthFrameSource(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_DepthFrameSource_AddRefObject(ref _pNative);
+        }
+
+        ~DepthFrameSource()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrameSource_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrameSource_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<DepthFrameSource>(_pNative);
+                Windows_Kinect_DepthFrameSource_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern ushort Windows_Kinect_DepthFrameSource_get_DepthMaxReliableDistance(RootSystem.IntPtr pNative);
+        public  ushort DepthMaxReliableDistance
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrameSource");
+                }
+
+                return Windows_Kinect_DepthFrameSource_get_DepthMaxReliableDistance(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern ushort Windows_Kinect_DepthFrameSource_get_DepthMinReliableDistance(RootSystem.IntPtr pNative);
+        public  ushort DepthMinReliableDistance
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrameSource");
+                }
+
+                return Windows_Kinect_DepthFrameSource_get_DepthMinReliableDistance(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_DepthFrameSource_get_FrameDescription(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.FrameDescription FrameDescription
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrameSource");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_DepthFrameSource_get_FrameDescription(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.FrameDescription>(objectPointer, n => new Windows.Kinect.FrameDescription(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_DepthFrameSource_get_IsActive(RootSystem.IntPtr pNative);
+        public  bool IsActive
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrameSource");
+                }
+
+                return Windows_Kinect_DepthFrameSource_get_IsActive(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_DepthFrameSource_get_KinectSensor(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.KinectSensor KinectSensor
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("DepthFrameSource");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_DepthFrameSource_get_KinectSensor(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectSensor>(objectPointer, n => new Windows.Kinect.KinectSensor(n));
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_FrameCapturedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>>> Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_FrameCapturedEventArgs_Delegate))]
+        private static void Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>> callbackList = null;
+            Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<DepthFrameSource>(pNative);
+                var args = new Windows.Kinect.FrameCapturedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrameSource_add_FrameCaptured(RootSystem.IntPtr pNative, _Windows_Kinect_FrameCapturedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs> FrameCaptured
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_FrameCapturedEventArgs_Delegate(Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_DepthFrameSource_add_FrameCaptured(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_DepthFrameSource_add_FrameCaptured(_pNative, Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<DepthFrameSource>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_DepthFrameSource_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_DepthFrameSource_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_DepthFrameSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_DepthFrameSource_OpenReader(RootSystem.IntPtr pNative);
+        public Windows.Kinect.DepthFrameReader OpenReader()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("DepthFrameSource");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_DepthFrameSource_OpenReader(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.DepthFrameReader>(objectPointer, n => new Windows.Kinect.DepthFrameReader(n));
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_DepthFrameSource_add_FrameCaptured(_pNative, Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_DepthFrameSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/DepthFrameSource.cs.meta

+fileFormatVersion: 2
+guid: ec16a6a3c150d4c479a008f45c1851ec
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/DepthSpacePoint.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.DepthSpacePoint
+    //
+    [RootSystem.Runtime.InteropServices.StructLayout(RootSystem.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct DepthSpacePoint
+    {
+        public float X { get; set; }
+        public float Y { get; set; }
+
+        public override int GetHashCode()
+        {
+            return X.GetHashCode() ^ Y.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (!(obj is DepthSpacePoint))
+            {
+                return false;
+            }
+
+            return this.Equals((DepthSpacePoint)obj);
+        }
+
+        public bool Equals(DepthSpacePoint obj)
+        {
+            return X.Equals(obj.X) && Y.Equals(obj.Y);
+        }
+
+        public static bool operator ==(DepthSpacePoint a, DepthSpacePoint b)
+        {
+            return a.Equals(b);
+        }
+
+        public static bool operator !=(DepthSpacePoint a, DepthSpacePoint b)
+        {
+            return !(a.Equals(b));
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/DepthSpacePoint.cs.meta

+fileFormatVersion: 2
+guid: 87a047e9c131269479b899f8dd9cac89
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/DetectionResult.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.DetectionResult
+    //
+    public enum DetectionResult : int
+    {
+        Unknown                                  =0,
+        No                                       =1,
+        Maybe                                    =2,
+        Yes                                      =3,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/DetectionResult.cs.meta

+fileFormatVersion: 2
+guid: 6f242e10b172a6340a49529ef0ad2d90
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/Expression.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.Expression
+    //
+    public enum Expression : int
+    {
+        Neutral                                  =0,
+        Happy                                    =1,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/Expression.cs.meta

+fileFormatVersion: 2
+guid: 13c84518ab4fa60499742f896207e91e
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/FrameCapturedEventArgs.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.FrameCapturedEventArgs
+    //
+    public sealed partial class FrameCapturedEventArgs : RootSystem.EventArgs, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal FrameCapturedEventArgs(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_FrameCapturedEventArgs_AddRefObject(ref _pNative);
+        }
+
+        ~FrameCapturedEventArgs()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_FrameCapturedEventArgs_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_FrameCapturedEventArgs_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<FrameCapturedEventArgs>(_pNative);
+                Windows_Kinect_FrameCapturedEventArgs_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.FrameCapturedStatus Windows_Kinect_FrameCapturedEventArgs_get_FrameStatus(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.FrameCapturedStatus FrameStatus
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("FrameCapturedEventArgs");
+                }
+
+                return Windows_Kinect_FrameCapturedEventArgs_get_FrameStatus(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.FrameSourceTypes Windows_Kinect_FrameCapturedEventArgs_get_FrameType(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.FrameSourceTypes FrameType
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("FrameCapturedEventArgs");
+                }
+
+                return Windows_Kinect_FrameCapturedEventArgs_get_FrameType(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_FrameCapturedEventArgs_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("FrameCapturedEventArgs");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_FrameCapturedEventArgs_get_RelativeTime(_pNative));
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/FrameCapturedEventArgs.cs.meta

+fileFormatVersion: 2
+guid: 085ec75a343f958408701e00ba2168ce
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/FrameCapturedStatus.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.FrameCapturedStatus
+    //
+    public enum FrameCapturedStatus : int
+    {
+        Unknown                                  =0,
+        Queued                                   =1,
+        Dropped                                  =2,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/FrameCapturedStatus.cs.meta

+fileFormatVersion: 2
+guid: ccf1cabe437c4764d9818a2fd30827f0
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/FrameDescription.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.FrameDescription
+    //
+    public sealed partial class FrameDescription : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal FrameDescription(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_FrameDescription_AddRefObject(ref _pNative);
+        }
+
+        ~FrameDescription()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_FrameDescription_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_FrameDescription_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<FrameDescription>(_pNative);
+                Windows_Kinect_FrameDescription_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern uint Windows_Kinect_FrameDescription_get_BytesPerPixel(RootSystem.IntPtr pNative);
+        public  uint BytesPerPixel
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("FrameDescription");
+                }
+
+                return Windows_Kinect_FrameDescription_get_BytesPerPixel(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern float Windows_Kinect_FrameDescription_get_DiagonalFieldOfView(RootSystem.IntPtr pNative);
+        public  float DiagonalFieldOfView
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("FrameDescription");
+                }
+
+                return Windows_Kinect_FrameDescription_get_DiagonalFieldOfView(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_FrameDescription_get_Height(RootSystem.IntPtr pNative);
+        public  int Height
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("FrameDescription");
+                }
+
+                return Windows_Kinect_FrameDescription_get_Height(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern float Windows_Kinect_FrameDescription_get_HorizontalFieldOfView(RootSystem.IntPtr pNative);
+        public  float HorizontalFieldOfView
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("FrameDescription");
+                }
+
+                return Windows_Kinect_FrameDescription_get_HorizontalFieldOfView(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern uint Windows_Kinect_FrameDescription_get_LengthInPixels(RootSystem.IntPtr pNative);
+        public  uint LengthInPixels
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("FrameDescription");
+                }
+
+                return Windows_Kinect_FrameDescription_get_LengthInPixels(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern float Windows_Kinect_FrameDescription_get_VerticalFieldOfView(RootSystem.IntPtr pNative);
+        public  float VerticalFieldOfView
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("FrameDescription");
+                }
+
+                return Windows_Kinect_FrameDescription_get_VerticalFieldOfView(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern int Windows_Kinect_FrameDescription_get_Width(RootSystem.IntPtr pNative);
+        public  int Width
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("FrameDescription");
+                }
+
+                return Windows_Kinect_FrameDescription_get_Width(_pNative);
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/FrameDescription.cs.meta

+fileFormatVersion: 2
+guid: 855fcb405500ab14b8902d15d27ed0ab
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/FrameEdges.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.FrameEdges
+    //
+    [RootSystem.Flags]
+    public enum FrameEdges : uint
+    {
+        None                                     =0,
+        Right                                    =1,
+        Left                                     =2,
+        Top                                      =4,
+        Bottom                                   =8,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/FrameEdges.cs.meta

+fileFormatVersion: 2
+guid: 34cd6f0c5382cd9458b3b1ef06e001ba
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/FrameSourceTypes.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.FrameSourceTypes
+    //
+    [RootSystem.Flags]
+    public enum FrameSourceTypes : uint
+    {
+        None                                     =0,
+        Color                                    =1,
+        Infrared                                 =2,
+        LongExposureInfrared                     =4,
+        Depth                                    =8,
+        BodyIndex                                =16,
+        Body                                     =32,
+        Audio                                    =64,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/FrameSourceTypes.cs.meta

+fileFormatVersion: 2
+guid: bbb237f869b7c684aa4bff904d74ceed
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/HandState.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.HandState
+    //
+    public enum HandState : int
+    {
+        Unknown                                  =0,
+        NotTracked                               =1,
+        Open                                     =2,
+        Closed                                   =3,
+        Lasso                                    =4,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/HandState.cs.meta

+fileFormatVersion: 2
+guid: 61c6c0071af9a08459843e571124cbef
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/InfraredFrame.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.InfraredFrame
+    //
+    public sealed partial class InfraredFrame : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal InfraredFrame(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_InfraredFrame_AddRefObject(ref _pNative);
+        }
+
+        ~InfraredFrame()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrame_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrame_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<InfraredFrame>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_InfraredFrame_Dispose(_pNative);
+            }
+                Windows_Kinect_InfraredFrame_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_InfraredFrame_get_FrameDescription(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.FrameDescription FrameDescription
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("InfraredFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_InfraredFrame_get_FrameDescription(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.FrameDescription>(objectPointer, n => new Windows.Kinect.FrameDescription(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_InfraredFrame_get_InfraredFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.InfraredFrameSource InfraredFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("InfraredFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_InfraredFrame_get_InfraredFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.InfraredFrameSource>(objectPointer, n => new Windows.Kinect.InfraredFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_InfraredFrame_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("InfraredFrame");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_InfraredFrame_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrame_CopyFrameDataToArray(RootSystem.IntPtr pNative, RootSystem.IntPtr frameData, int frameDataSize);
+        public void CopyFrameDataToArray(ushort[] frameData)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("InfraredFrame");
+            }
+
+            var frameDataSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(frameData, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _frameData = frameDataSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_InfraredFrame_CopyFrameDataToArray(_pNative, _frameData, frameData.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrame_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/InfraredFrame.cs.meta

+fileFormatVersion: 2
+guid: 716d52dd0cd344f439914ed99e62b0e5
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/InfraredFrameArrivedEventArgs.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.InfraredFrameArrivedEventArgs
+    //
+    public sealed partial class InfraredFrameArrivedEventArgs : RootSystem.EventArgs, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal InfraredFrameArrivedEventArgs(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_InfraredFrameArrivedEventArgs_AddRefObject(ref _pNative);
+        }
+
+        ~InfraredFrameArrivedEventArgs()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrameArrivedEventArgs_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrameArrivedEventArgs_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<InfraredFrameArrivedEventArgs>(_pNative);
+                Windows_Kinect_InfraredFrameArrivedEventArgs_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_InfraredFrameArrivedEventArgs_get_FrameReference(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.InfraredFrameReference FrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("InfraredFrameArrivedEventArgs");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_InfraredFrameArrivedEventArgs_get_FrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.InfraredFrameReference>(objectPointer, n => new Windows.Kinect.InfraredFrameReference(n));
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/InfraredFrameArrivedEventArgs.cs.meta

+fileFormatVersion: 2
+guid: 47e956b7b74fcd447a28c068f2fcaf56
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/InfraredFrameReader.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.InfraredFrameReader
+    //
+    public sealed partial class InfraredFrameReader : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal InfraredFrameReader(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_InfraredFrameReader_AddRefObject(ref _pNative);
+        }
+
+        ~InfraredFrameReader()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrameReader_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrameReader_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<InfraredFrameReader>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_InfraredFrameReader_Dispose(_pNative);
+            }
+                Windows_Kinect_InfraredFrameReader_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_InfraredFrameReader_get_InfraredFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.InfraredFrameSource InfraredFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("InfraredFrameReader");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_InfraredFrameReader_get_InfraredFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.InfraredFrameSource>(objectPointer, n => new Windows.Kinect.InfraredFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_InfraredFrameReader_get_IsPaused(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrameReader_put_IsPaused(RootSystem.IntPtr pNative, bool isPaused);
+        public  bool IsPaused
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("InfraredFrameReader");
+                }
+
+                return Windows_Kinect_InfraredFrameReader_get_IsPaused(_pNative);
+            }
+            set
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("InfraredFrameReader");
+                }
+
+                Windows_Kinect_InfraredFrameReader_put_IsPaused(_pNative, value);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.InfraredFrameArrivedEventArgs>>> Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.InfraredFrameArrivedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate))]
+        private static void Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.InfraredFrameArrivedEventArgs>> callbackList = null;
+            Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<InfraredFrameReader>(pNative);
+                var args = new Windows.Kinect.InfraredFrameArrivedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrameReader_add_FrameArrived(RootSystem.IntPtr pNative, _Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.InfraredFrameArrivedEventArgs> FrameArrived
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate(Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_InfraredFrameReader_add_FrameArrived(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_InfraredFrameReader_add_FrameArrived(_pNative, Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<InfraredFrameReader>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrameReader_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_InfraredFrameReader_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_InfraredFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_InfraredFrameReader_AcquireLatestFrame(RootSystem.IntPtr pNative);
+        public Windows.Kinect.InfraredFrame AcquireLatestFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("InfraredFrameReader");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_InfraredFrameReader_AcquireLatestFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.InfraredFrame>(objectPointer, n => new Windows.Kinect.InfraredFrame(n));
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrameReader_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_InfraredFrameReader_add_FrameArrived(_pNative, Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_InfraredFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_InfraredFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/InfraredFrameReader.cs.meta

+fileFormatVersion: 2
+guid: 0937005bb1a679a40a0bffab4f8fa84b
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/InfraredFrameReference.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.InfraredFrameReference
+    //
+    public sealed partial class InfraredFrameReference : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal InfraredFrameReference(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_InfraredFrameReference_AddRefObject(ref _pNative);
+        }
+
+        ~InfraredFrameReference()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrameReference_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrameReference_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<InfraredFrameReference>(_pNative);
+                Windows_Kinect_InfraredFrameReference_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_InfraredFrameReference_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("InfraredFrameReference");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_InfraredFrameReference_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_InfraredFrameReference_AcquireFrame(RootSystem.IntPtr pNative);
+        public Windows.Kinect.InfraredFrame AcquireFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("InfraredFrameReference");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_InfraredFrameReference_AcquireFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.InfraredFrame>(objectPointer, n => new Windows.Kinect.InfraredFrame(n));
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/InfraredFrameReference.cs.meta

+fileFormatVersion: 2
+guid: 89acda427f65cc64dbe156710db8760f
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/InfraredFrameSource.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.InfraredFrameSource
+    //
+    public sealed partial class InfraredFrameSource : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal InfraredFrameSource(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_InfraredFrameSource_AddRefObject(ref _pNative);
+        }
+
+        ~InfraredFrameSource()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrameSource_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrameSource_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<InfraredFrameSource>(_pNative);
+                Windows_Kinect_InfraredFrameSource_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_InfraredFrameSource_get_FrameDescription(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.FrameDescription FrameDescription
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("InfraredFrameSource");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_InfraredFrameSource_get_FrameDescription(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.FrameDescription>(objectPointer, n => new Windows.Kinect.FrameDescription(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_InfraredFrameSource_get_IsActive(RootSystem.IntPtr pNative);
+        public  bool IsActive
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("InfraredFrameSource");
+                }
+
+                return Windows_Kinect_InfraredFrameSource_get_IsActive(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_InfraredFrameSource_get_KinectSensor(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.KinectSensor KinectSensor
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("InfraredFrameSource");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_InfraredFrameSource_get_KinectSensor(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectSensor>(objectPointer, n => new Windows.Kinect.KinectSensor(n));
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_FrameCapturedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>>> Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_FrameCapturedEventArgs_Delegate))]
+        private static void Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>> callbackList = null;
+            Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<InfraredFrameSource>(pNative);
+                var args = new Windows.Kinect.FrameCapturedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrameSource_add_FrameCaptured(RootSystem.IntPtr pNative, _Windows_Kinect_FrameCapturedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs> FrameCaptured
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_FrameCapturedEventArgs_Delegate(Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_InfraredFrameSource_add_FrameCaptured(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_InfraredFrameSource_add_FrameCaptured(_pNative, Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<InfraredFrameSource>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_InfraredFrameSource_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_InfraredFrameSource_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_InfraredFrameSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_InfraredFrameSource_OpenReader(RootSystem.IntPtr pNative);
+        public Windows.Kinect.InfraredFrameReader OpenReader()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("InfraredFrameSource");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_InfraredFrameSource_OpenReader(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.InfraredFrameReader>(objectPointer, n => new Windows.Kinect.InfraredFrameReader(n));
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_InfraredFrameSource_add_FrameCaptured(_pNative, Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_InfraredFrameSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/InfraredFrameSource.cs.meta

+fileFormatVersion: 2
+guid: 8b41da8047304434eb12d404c2f99979
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/IsAvailableChangedEventArgs.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.IsAvailableChangedEventArgs
+    //
+    public sealed partial class IsAvailableChangedEventArgs : RootSystem.EventArgs, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal IsAvailableChangedEventArgs(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_IsAvailableChangedEventArgs_AddRefObject(ref _pNative);
+        }
+
+        ~IsAvailableChangedEventArgs()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_IsAvailableChangedEventArgs_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_IsAvailableChangedEventArgs_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<IsAvailableChangedEventArgs>(_pNative);
+                Windows_Kinect_IsAvailableChangedEventArgs_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_IsAvailableChangedEventArgs_get_IsAvailable(RootSystem.IntPtr pNative);
+        public  bool IsAvailable
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("IsAvailableChangedEventArgs");
+                }
+
+                return Windows_Kinect_IsAvailableChangedEventArgs_get_IsAvailable(_pNative);
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/IsAvailableChangedEventArgs.cs.meta

+fileFormatVersion: 2
+guid: 65a7600b04976b84db9c9ec171a5d71f
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/Joint.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.Joint
+    //
+    [RootSystem.Runtime.InteropServices.StructLayout(RootSystem.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct Joint
+    {
+        public Windows.Kinect.JointType JointType { get; set; }
+        public Windows.Kinect.CameraSpacePoint Position { get; set; }
+        public Windows.Kinect.TrackingState TrackingState { get; set; }
+
+        public override int GetHashCode()
+        {
+            return JointType.GetHashCode() ^ Position.GetHashCode() ^ TrackingState.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (!(obj is Joint))
+            {
+                return false;
+            }
+
+            return this.Equals((Joint)obj);
+        }
+
+        public bool Equals(Joint obj)
+        {
+            return JointType.Equals(obj.JointType) && Position.Equals(obj.Position) && TrackingState.Equals(obj.TrackingState);
+        }
+
+        public static bool operator ==(Joint a, Joint b)
+        {
+            return a.Equals(b);
+        }
+
+        public static bool operator !=(Joint a, Joint b)
+        {
+            return !(a.Equals(b));
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/Joint.cs.meta

+fileFormatVersion: 2
+guid: c6ab2966f653a9b439da02f3ae85c867
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/JointOrientation.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.JointOrientation
+    //
+    [RootSystem.Runtime.InteropServices.StructLayout(RootSystem.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct JointOrientation
+    {
+        public Windows.Kinect.JointType JointType { get; set; }
+        public Windows.Kinect.Vector4 Orientation { get; set; }
+
+        public override int GetHashCode()
+        {
+            return JointType.GetHashCode() ^ Orientation.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (!(obj is JointOrientation))
+            {
+                return false;
+            }
+
+            return this.Equals((JointOrientation)obj);
+        }
+
+        public bool Equals(JointOrientation obj)
+        {
+            return JointType.Equals(obj.JointType) && Orientation.Equals(obj.Orientation);
+        }
+
+        public static bool operator ==(JointOrientation a, JointOrientation b)
+        {
+            return a.Equals(b);
+        }
+
+        public static bool operator !=(JointOrientation a, JointOrientation b)
+        {
+            return !(a.Equals(b));
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/JointOrientation.cs.meta

+fileFormatVersion: 2
+guid: d616618770c2c84469f5aaa5f72ca2ca
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/JointType.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.JointType
+    //
+    public enum JointType : int
+    {
+        SpineBase                                =0,
+        SpineMid                                 =1,
+        Neck                                     =2,
+        Head                                     =3,
+        ShoulderLeft                             =4,
+        ElbowLeft                                =5,
+        WristLeft                                =6,
+        HandLeft                                 =7,
+        ShoulderRight                            =8,
+        ElbowRight                               =9,
+        WristRight                               =10,
+        HandRight                                =11,
+        HipLeft                                  =12,
+        KneeLeft                                 =13,
+        AnkleLeft                                =14,
+        FootLeft                                 =15,
+        HipRight                                 =16,
+        KneeRight                                =17,
+        AnkleRight                               =18,
+        FootRight                                =19,
+        SpineShoulder                            =20,
+        HandTipLeft                              =21,
+        ThumbLeft                                =22,
+        HandTipRight                             =23,
+        ThumbRight                               =24,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/JointType.cs.meta

+fileFormatVersion: 2
+guid: 1791e2ee3f5ea1343a2694b4e1b3f00f
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/KinectAudioCalibrationState.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.KinectAudioCalibrationState
+    //
+    public enum KinectAudioCalibrationState : int
+    {
+        Unknown                                  =0,
+        CalibrationRequired                      =1,
+        Calibrated                               =2,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/KinectAudioCalibrationState.cs.meta

+fileFormatVersion: 2
+guid: 87d856dfd833c524381664b12e58813a
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/KinectCapabilities.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.KinectCapabilities
+    //
+    [RootSystem.Flags]
+    public enum KinectCapabilities : uint
+    {
+        None                                     =0,
+        Vision                                   =1,
+        Audio                                    =2,
+        Face                                     =4,
+        Expressions                              =8,
+        Gamechat                                 =16,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/KinectCapabilities.cs.meta

+fileFormatVersion: 2
+guid: 6dcba0f7ec870d94c849f4d8ed860377
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/KinectSensor.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.KinectSensor
+    //
+    public sealed partial class KinectSensor : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal KinectSensor(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_KinectSensor_AddRefObject(ref _pNative);
+        }
+
+        ~KinectSensor()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_KinectSensor_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_KinectSensor_AddRefObject(ref RootSystem.IntPtr pNative);
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_KinectSensor_get_AudioSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.AudioSource AudioSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectSensor");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_KinectSensor_get_AudioSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.AudioSource>(objectPointer, n => new Windows.Kinect.AudioSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_KinectSensor_get_BodyFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.BodyFrameSource BodyFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectSensor");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_KinectSensor_get_BodyFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyFrameSource>(objectPointer, n => new Windows.Kinect.BodyFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_KinectSensor_get_BodyIndexFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.BodyIndexFrameSource BodyIndexFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectSensor");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_KinectSensor_get_BodyIndexFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyIndexFrameSource>(objectPointer, n => new Windows.Kinect.BodyIndexFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_KinectSensor_get_ColorFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.ColorFrameSource ColorFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectSensor");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_KinectSensor_get_ColorFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.ColorFrameSource>(objectPointer, n => new Windows.Kinect.ColorFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_KinectSensor_get_CoordinateMapper(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.CoordinateMapper CoordinateMapper
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectSensor");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_KinectSensor_get_CoordinateMapper(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.CoordinateMapper>(objectPointer, n => new Windows.Kinect.CoordinateMapper(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_KinectSensor_get_DepthFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.DepthFrameSource DepthFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectSensor");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_KinectSensor_get_DepthFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.DepthFrameSource>(objectPointer, n => new Windows.Kinect.DepthFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_KinectSensor_get_InfraredFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.InfraredFrameSource InfraredFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectSensor");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_KinectSensor_get_InfraredFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.InfraredFrameSource>(objectPointer, n => new Windows.Kinect.InfraredFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_KinectSensor_get_IsAvailable(RootSystem.IntPtr pNative);
+        public  bool IsAvailable
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectSensor");
+                }
+
+                return Windows_Kinect_KinectSensor_get_IsAvailable(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_KinectSensor_get_IsOpen(RootSystem.IntPtr pNative);
+        public  bool IsOpen
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectSensor");
+                }
+
+                return Windows_Kinect_KinectSensor_get_IsOpen(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.KinectCapabilities Windows_Kinect_KinectSensor_get_KinectCapabilities(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.KinectCapabilities KinectCapabilities
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectSensor");
+                }
+
+                return Windows_Kinect_KinectSensor_get_KinectCapabilities(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_KinectSensor_get_LongExposureInfraredFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.LongExposureInfraredFrameSource LongExposureInfraredFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectSensor");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_KinectSensor_get_LongExposureInfraredFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.LongExposureInfraredFrameSource>(objectPointer, n => new Windows.Kinect.LongExposureInfraredFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_KinectSensor_get_UniqueKinectId(RootSystem.IntPtr pNative);
+        public  string UniqueKinectId
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("KinectSensor");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_KinectSensor_get_UniqueKinectId(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+
+                var managedString = RootSystem.Runtime.InteropServices.Marshal.PtrToStringUni(objectPointer);
+                RootSystem.Runtime.InteropServices.Marshal.FreeCoTaskMem(objectPointer);
+                return managedString;
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_IsAvailableChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_IsAvailableChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.IsAvailableChangedEventArgs>>> Windows_Kinect_IsAvailableChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.IsAvailableChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_IsAvailableChangedEventArgs_Delegate))]
+        private static void Windows_Kinect_IsAvailableChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.IsAvailableChangedEventArgs>> callbackList = null;
+            Windows_Kinect_IsAvailableChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<KinectSensor>(pNative);
+                var args = new Windows.Kinect.IsAvailableChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_KinectSensor_add_IsAvailableChanged(RootSystem.IntPtr pNative, _Windows_Kinect_IsAvailableChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.IsAvailableChangedEventArgs> IsAvailableChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_IsAvailableChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_IsAvailableChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_IsAvailableChangedEventArgs_Delegate(Windows_Kinect_IsAvailableChangedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_IsAvailableChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_KinectSensor_add_IsAvailableChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_IsAvailableChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_IsAvailableChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_KinectSensor_add_IsAvailableChanged(_pNative, Windows_Kinect_IsAvailableChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_IsAvailableChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<KinectSensor>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_KinectSensor_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_KinectSensor_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_KinectSensor_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Static Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_KinectSensor_GetDefault();
+        public static Windows.Kinect.KinectSensor GetDefault()
+        {
+            RootSystem.IntPtr objectPointer = Windows_Kinect_KinectSensor_GetDefault();
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectSensor>(objectPointer, n => new Windows.Kinect.KinectSensor(n));
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_KinectSensor_Open(RootSystem.IntPtr pNative);
+        public void Open()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("KinectSensor");
+            }
+
+            Windows_Kinect_KinectSensor_Open(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_KinectSensor_Close(RootSystem.IntPtr pNative);
+        public void Close()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("KinectSensor");
+            }
+
+            Windows_Kinect_KinectSensor_Close(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_KinectSensor_OpenMultiSourceFrameReader(RootSystem.IntPtr pNative, Windows.Kinect.FrameSourceTypes enabledFrameSourceTypes);
+        public Windows.Kinect.MultiSourceFrameReader OpenMultiSourceFrameReader(Windows.Kinect.FrameSourceTypes enabledFrameSourceTypes)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("KinectSensor");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_KinectSensor_OpenMultiSourceFrameReader(_pNative, enabledFrameSourceTypes);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.MultiSourceFrameReader>(objectPointer, n => new Windows.Kinect.MultiSourceFrameReader(n));
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_IsAvailableChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_IsAvailableChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_KinectSensor_add_IsAvailableChanged(_pNative, Windows_Kinect_IsAvailableChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_IsAvailableChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_KinectSensor_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/KinectSensor.cs.meta

+fileFormatVersion: 2
+guid: a5a5ec3f3f1b0064fae54e1512e12887
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/KinectUnityAddinUtils.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.KinectUnityAddinUtils
+    //
+    public sealed partial class KinectUnityAddinUtils
+    {
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void KinectUnityAddin_FreeMemory(RootSystem.IntPtr pToDealloc);
+        public static void FreeMemory(RootSystem.IntPtr pToDealloc)
+        {
+            KinectUnityAddin_FreeMemory(pToDealloc);
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/KinectUnityAddinUtils.cs.meta

+fileFormatVersion: 2
+guid: 985cae59f29daa947acc082d310c3492
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/LongExposureInfraredFrame.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.LongExposureInfraredFrame
+    //
+    public sealed partial class LongExposureInfraredFrame : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal LongExposureInfraredFrame(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_LongExposureInfraredFrame_AddRefObject(ref _pNative);
+        }
+
+        ~LongExposureInfraredFrame()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrame_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrame_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<LongExposureInfraredFrame>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_LongExposureInfraredFrame_Dispose(_pNative);
+            }
+                Windows_Kinect_LongExposureInfraredFrame_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_LongExposureInfraredFrame_get_FrameDescription(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.FrameDescription FrameDescription
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_LongExposureInfraredFrame_get_FrameDescription(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.FrameDescription>(objectPointer, n => new Windows.Kinect.FrameDescription(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_LongExposureInfraredFrame_get_LongExposureInfraredFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.LongExposureInfraredFrameSource LongExposureInfraredFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_LongExposureInfraredFrame_get_LongExposureInfraredFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.LongExposureInfraredFrameSource>(objectPointer, n => new Windows.Kinect.LongExposureInfraredFrameSource(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_LongExposureInfraredFrame_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrame");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_LongExposureInfraredFrame_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrame_CopyFrameDataToArray(RootSystem.IntPtr pNative, RootSystem.IntPtr frameData, int frameDataSize);
+        public void CopyFrameDataToArray(ushort[] frameData)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrame");
+            }
+
+            var frameDataSmartGCHandle = new Helper.SmartGCHandle(RootSystem.Runtime.InteropServices.GCHandle.Alloc(frameData, RootSystem.Runtime.InteropServices.GCHandleType.Pinned));
+            var _frameData = frameDataSmartGCHandle.AddrOfPinnedObject();
+            Windows_Kinect_LongExposureInfraredFrame_CopyFrameDataToArray(_pNative, _frameData, frameData.Length);
+            Helper.ExceptionHelper.CheckLastError();
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrame_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/LongExposureInfraredFrame.cs.meta

+fileFormatVersion: 2
+guid: 62e292d05e1f99d4695e2306db22e75f
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/LongExposureInfraredFrameArrivedEventArgs.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.LongExposureInfraredFrameArrivedEventArgs
+    //
+    public sealed partial class LongExposureInfraredFrameArrivedEventArgs : RootSystem.EventArgs, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal LongExposureInfraredFrameArrivedEventArgs(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_AddRefObject(ref _pNative);
+        }
+
+        ~LongExposureInfraredFrameArrivedEventArgs()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<LongExposureInfraredFrameArrivedEventArgs>(_pNative);
+                Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_get_FrameReference(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.LongExposureInfraredFrameReference FrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrameArrivedEventArgs");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_get_FrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.LongExposureInfraredFrameReference>(objectPointer, n => new Windows.Kinect.LongExposureInfraredFrameReference(n));
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/LongExposureInfraredFrameArrivedEventArgs.cs.meta

+fileFormatVersion: 2
+guid: dbaaf8e0d23f24848ab81331f4379722
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/LongExposureInfraredFrameReader.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.LongExposureInfraredFrameReader
+    //
+    public sealed partial class LongExposureInfraredFrameReader : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal LongExposureInfraredFrameReader(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_LongExposureInfraredFrameReader_AddRefObject(ref _pNative);
+        }
+
+        ~LongExposureInfraredFrameReader()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrameReader_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrameReader_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<LongExposureInfraredFrameReader>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_LongExposureInfraredFrameReader_Dispose(_pNative);
+            }
+                Windows_Kinect_LongExposureInfraredFrameReader_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_LongExposureInfraredFrameReader_get_IsPaused(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrameReader_put_IsPaused(RootSystem.IntPtr pNative, bool isPaused);
+        public  bool IsPaused
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrameReader");
+                }
+
+                return Windows_Kinect_LongExposureInfraredFrameReader_get_IsPaused(_pNative);
+            }
+            set
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrameReader");
+                }
+
+                Windows_Kinect_LongExposureInfraredFrameReader_put_IsPaused(_pNative, value);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_LongExposureInfraredFrameReader_get_LongExposureInfraredFrameSource(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.LongExposureInfraredFrameSource LongExposureInfraredFrameSource
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrameReader");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_LongExposureInfraredFrameReader_get_LongExposureInfraredFrameSource(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.LongExposureInfraredFrameSource>(objectPointer, n => new Windows.Kinect.LongExposureInfraredFrameSource(n));
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.LongExposureInfraredFrameArrivedEventArgs>>> Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.LongExposureInfraredFrameArrivedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate))]
+        private static void Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.LongExposureInfraredFrameArrivedEventArgs>> callbackList = null;
+            Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<LongExposureInfraredFrameReader>(pNative);
+                var args = new Windows.Kinect.LongExposureInfraredFrameArrivedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrameReader_add_FrameArrived(RootSystem.IntPtr pNative, _Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.LongExposureInfraredFrameArrivedEventArgs> FrameArrived
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate(Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_LongExposureInfraredFrameReader_add_FrameArrived(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_LongExposureInfraredFrameReader_add_FrameArrived(_pNative, Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<LongExposureInfraredFrameReader>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrameReader_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_LongExposureInfraredFrameReader_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_LongExposureInfraredFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_LongExposureInfraredFrameReader_AcquireLatestFrame(RootSystem.IntPtr pNative);
+        public Windows.Kinect.LongExposureInfraredFrame AcquireLatestFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrameReader");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_LongExposureInfraredFrameReader_AcquireLatestFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.LongExposureInfraredFrame>(objectPointer, n => new Windows.Kinect.LongExposureInfraredFrame(n));
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrameReader_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_LongExposureInfraredFrameReader_add_FrameArrived(_pNative, Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_LongExposureInfraredFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_LongExposureInfraredFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/LongExposureInfraredFrameReader.cs.meta

+fileFormatVersion: 2
+guid: 78a6e9053bd545d4f948fa1d8ced5879
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/LongExposureInfraredFrameReference.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.LongExposureInfraredFrameReference
+    //
+    public sealed partial class LongExposureInfraredFrameReference : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal LongExposureInfraredFrameReference(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_LongExposureInfraredFrameReference_AddRefObject(ref _pNative);
+        }
+
+        ~LongExposureInfraredFrameReference()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrameReference_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrameReference_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<LongExposureInfraredFrameReference>(_pNative);
+                Windows_Kinect_LongExposureInfraredFrameReference_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern long Windows_Kinect_LongExposureInfraredFrameReference_get_RelativeTime(RootSystem.IntPtr pNative);
+        public  RootSystem.TimeSpan RelativeTime
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrameReference");
+                }
+
+                return RootSystem.TimeSpan.FromMilliseconds(Windows_Kinect_LongExposureInfraredFrameReference_get_RelativeTime(_pNative));
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_LongExposureInfraredFrameReference_AcquireFrame(RootSystem.IntPtr pNative);
+        public Windows.Kinect.LongExposureInfraredFrame AcquireFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrameReference");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_LongExposureInfraredFrameReference_AcquireFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.LongExposureInfraredFrame>(objectPointer, n => new Windows.Kinect.LongExposureInfraredFrame(n));
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/LongExposureInfraredFrameReference.cs.meta

+fileFormatVersion: 2
+guid: 91cd9161c056061438655504e2f2f7f4
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/LongExposureInfraredFrameSource.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.LongExposureInfraredFrameSource
+    //
+    public sealed partial class LongExposureInfraredFrameSource : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal LongExposureInfraredFrameSource(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_LongExposureInfraredFrameSource_AddRefObject(ref _pNative);
+        }
+
+        ~LongExposureInfraredFrameSource()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrameSource_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrameSource_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<LongExposureInfraredFrameSource>(_pNative);
+                Windows_Kinect_LongExposureInfraredFrameSource_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_LongExposureInfraredFrameSource_get_FrameDescription(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.FrameDescription FrameDescription
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrameSource");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_LongExposureInfraredFrameSource_get_FrameDescription(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.FrameDescription>(objectPointer, n => new Windows.Kinect.FrameDescription(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_LongExposureInfraredFrameSource_get_IsActive(RootSystem.IntPtr pNative);
+        public  bool IsActive
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrameSource");
+                }
+
+                return Windows_Kinect_LongExposureInfraredFrameSource_get_IsActive(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_LongExposureInfraredFrameSource_get_KinectSensor(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.KinectSensor KinectSensor
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrameSource");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_LongExposureInfraredFrameSource_get_KinectSensor(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectSensor>(objectPointer, n => new Windows.Kinect.KinectSensor(n));
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_FrameCapturedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>>> Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_FrameCapturedEventArgs_Delegate))]
+        private static void Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs>> callbackList = null;
+            Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<LongExposureInfraredFrameSource>(pNative);
+                var args = new Windows.Kinect.FrameCapturedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrameSource_add_FrameCaptured(RootSystem.IntPtr pNative, _Windows_Kinect_FrameCapturedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.FrameCapturedEventArgs> FrameCaptured
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_FrameCapturedEventArgs_Delegate(Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_LongExposureInfraredFrameSource_add_FrameCaptured(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_LongExposureInfraredFrameSource_add_FrameCaptured(_pNative, Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<LongExposureInfraredFrameSource>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_LongExposureInfraredFrameSource_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_LongExposureInfraredFrameSource_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_LongExposureInfraredFrameSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_LongExposureInfraredFrameSource_OpenReader(RootSystem.IntPtr pNative);
+        public Windows.Kinect.LongExposureInfraredFrameReader OpenReader()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("LongExposureInfraredFrameSource");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_LongExposureInfraredFrameSource_OpenReader(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.LongExposureInfraredFrameReader>(objectPointer, n => new Windows.Kinect.LongExposureInfraredFrameReader(n));
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_FrameCapturedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_LongExposureInfraredFrameSource_add_FrameCaptured(_pNative, Windows_Kinect_FrameCapturedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_FrameCapturedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_LongExposureInfraredFrameSource_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/LongExposureInfraredFrameSource.cs.meta

+fileFormatVersion: 2
+guid: cdcf249c89943864ca06ab517b1d74f5
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/MultiSourceFrame.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.MultiSourceFrame
+    //
+    public sealed partial class MultiSourceFrame : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal MultiSourceFrame(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_MultiSourceFrame_AddRefObject(ref _pNative);
+        }
+
+        ~MultiSourceFrame()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_MultiSourceFrame_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_MultiSourceFrame_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<MultiSourceFrame>(_pNative);
+                Windows_Kinect_MultiSourceFrame_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_MultiSourceFrame_get_BodyFrameReference(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.BodyFrameReference BodyFrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("MultiSourceFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_MultiSourceFrame_get_BodyFrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyFrameReference>(objectPointer, n => new Windows.Kinect.BodyFrameReference(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_MultiSourceFrame_get_BodyIndexFrameReference(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.BodyIndexFrameReference BodyIndexFrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("MultiSourceFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_MultiSourceFrame_get_BodyIndexFrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.BodyIndexFrameReference>(objectPointer, n => new Windows.Kinect.BodyIndexFrameReference(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_MultiSourceFrame_get_ColorFrameReference(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.ColorFrameReference ColorFrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("MultiSourceFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_MultiSourceFrame_get_ColorFrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.ColorFrameReference>(objectPointer, n => new Windows.Kinect.ColorFrameReference(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_MultiSourceFrame_get_DepthFrameReference(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.DepthFrameReference DepthFrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("MultiSourceFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_MultiSourceFrame_get_DepthFrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.DepthFrameReference>(objectPointer, n => new Windows.Kinect.DepthFrameReference(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_MultiSourceFrame_get_InfraredFrameReference(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.InfraredFrameReference InfraredFrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("MultiSourceFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_MultiSourceFrame_get_InfraredFrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.InfraredFrameReference>(objectPointer, n => new Windows.Kinect.InfraredFrameReference(n));
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_MultiSourceFrame_get_LongExposureInfraredFrameReference(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.LongExposureInfraredFrameReference LongExposureInfraredFrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("MultiSourceFrame");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_MultiSourceFrame_get_LongExposureInfraredFrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.LongExposureInfraredFrameReference>(objectPointer, n => new Windows.Kinect.LongExposureInfraredFrameReference(n));
+            }
+        }
+
+
+        // Public Methods
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/MultiSourceFrame.cs.meta

+fileFormatVersion: 2
+guid: eb5e1a9a4aa7a3f4b8190ab4fab84118
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/MultiSourceFrameArrivedEventArgs.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.MultiSourceFrameArrivedEventArgs
+    //
+    public sealed partial class MultiSourceFrameArrivedEventArgs : RootSystem.EventArgs, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal MultiSourceFrameArrivedEventArgs(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_MultiSourceFrameArrivedEventArgs_AddRefObject(ref _pNative);
+        }
+
+        ~MultiSourceFrameArrivedEventArgs()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_MultiSourceFrameArrivedEventArgs_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_MultiSourceFrameArrivedEventArgs_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<MultiSourceFrameArrivedEventArgs>(_pNative);
+                Windows_Kinect_MultiSourceFrameArrivedEventArgs_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_MultiSourceFrameArrivedEventArgs_get_FrameReference(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.MultiSourceFrameReference FrameReference
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("MultiSourceFrameArrivedEventArgs");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_MultiSourceFrameArrivedEventArgs_get_FrameReference(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.MultiSourceFrameReference>(objectPointer, n => new Windows.Kinect.MultiSourceFrameReference(n));
+            }
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/MultiSourceFrameArrivedEventArgs.cs.meta

+fileFormatVersion: 2
+guid: 1188dd030cd382340966a429c46ed4fe
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/MultiSourceFrameReader.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.MultiSourceFrameReader
+    //
+    public sealed partial class MultiSourceFrameReader : RootSystem.IDisposable, Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal MultiSourceFrameReader(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_MultiSourceFrameReader_AddRefObject(ref _pNative);
+        }
+
+        ~MultiSourceFrameReader()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_MultiSourceFrameReader_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_MultiSourceFrameReader_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<MultiSourceFrameReader>(_pNative);
+
+            if (disposing)
+            {
+                Windows_Kinect_MultiSourceFrameReader_Dispose(_pNative);
+            }
+                Windows_Kinect_MultiSourceFrameReader_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Properties
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern Windows.Kinect.FrameSourceTypes Windows_Kinect_MultiSourceFrameReader_get_FrameSourceTypes(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.FrameSourceTypes FrameSourceTypes
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("MultiSourceFrameReader");
+                }
+
+                return Windows_Kinect_MultiSourceFrameReader_get_FrameSourceTypes(_pNative);
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern bool Windows_Kinect_MultiSourceFrameReader_get_IsPaused(RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_MultiSourceFrameReader_put_IsPaused(RootSystem.IntPtr pNative, bool isPaused);
+        public  bool IsPaused
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("MultiSourceFrameReader");
+                }
+
+                return Windows_Kinect_MultiSourceFrameReader_get_IsPaused(_pNative);
+            }
+            set
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("MultiSourceFrameReader");
+                }
+
+                Windows_Kinect_MultiSourceFrameReader_put_IsPaused(_pNative, value);
+                Helper.ExceptionHelper.CheckLastError();
+            }
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_MultiSourceFrameReader_get_KinectSensor(RootSystem.IntPtr pNative);
+        public  Windows.Kinect.KinectSensor KinectSensor
+        {
+            get
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    throw new RootSystem.ObjectDisposedException("MultiSourceFrameReader");
+                }
+
+                RootSystem.IntPtr objectPointer = Windows_Kinect_MultiSourceFrameReader_get_KinectSensor(_pNative);
+                Helper.ExceptionHelper.CheckLastError();
+                if (objectPointer == RootSystem.IntPtr.Zero)
+                {
+                    return null;
+                }
+
+                return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.KinectSensor>(objectPointer, n => new Windows.Kinect.KinectSensor(n));
+            }
+        }
+
+
+        // Events
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.MultiSourceFrameArrivedEventArgs>>> Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Kinect.MultiSourceFrameArrivedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate))]
+        private static void Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Kinect.MultiSourceFrameArrivedEventArgs>> callbackList = null;
+            Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<MultiSourceFrameReader>(pNative);
+                var args = new Windows.Kinect.MultiSourceFrameArrivedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_MultiSourceFrameReader_add_MultiSourceFrameArrived(RootSystem.IntPtr pNative, _Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Kinect.MultiSourceFrameArrivedEventArgs> MultiSourceFrameArrived
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate(Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_Handler);
+                        _Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_MultiSourceFrameReader_add_MultiSourceFrameArrived(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_MultiSourceFrameReader_add_MultiSourceFrameArrived(_pNative, Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_Handler, true);
+                        _Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+        private static RootSystem.Runtime.InteropServices.GCHandle _Windows_Data_PropertyChangedEventArgs_Delegate_Handle;
+        [RootSystem.Runtime.InteropServices.UnmanagedFunctionPointer(RootSystem.Runtime.InteropServices.CallingConvention.Cdecl)]
+        private delegate void _Windows_Data_PropertyChangedEventArgs_Delegate(RootSystem.IntPtr args, RootSystem.IntPtr pNative);
+        private static Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>> Windows_Data_PropertyChangedEventArgs_Delegate_callbacks = new Helper.CollectionMap<RootSystem.IntPtr, List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>>>();
+        [AOT.MonoPInvokeCallbackAttribute(typeof(_Windows_Data_PropertyChangedEventArgs_Delegate))]
+        private static void Windows_Data_PropertyChangedEventArgs_Delegate_Handler(RootSystem.IntPtr result, RootSystem.IntPtr pNative)
+        {
+            List<RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs>> callbackList = null;
+            Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryGetValue(pNative, out callbackList);
+            lock(callbackList)
+            {
+                var objThis = Helper.NativeObjectCache.GetObject<MultiSourceFrameReader>(pNative);
+                var args = new Windows.Data.PropertyChangedEventArgs(result);
+                foreach(var func in callbackList)
+                {
+                    Helper.EventPump.Instance.Enqueue(() => { try { func(objThis, args); } catch { } });
+                }
+            }
+        }
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_MultiSourceFrameReader_add_PropertyChanged(RootSystem.IntPtr pNative, _Windows_Data_PropertyChangedEventArgs_Delegate eventCallback, bool unsubscribe);
+        public  event RootSystem.EventHandler<Windows.Data.PropertyChangedEventArgs> PropertyChanged
+        {
+            add
+            {
+                Helper.EventPump.EnsureInitialized();
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Add(value);
+                    if(callbackList.Count == 1)
+                    {
+                        var del = new _Windows_Data_PropertyChangedEventArgs_Delegate(Windows_Data_PropertyChangedEventArgs_Delegate_Handler);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle = RootSystem.Runtime.InteropServices.GCHandle.Alloc(del);
+                        Windows_Kinect_MultiSourceFrameReader_add_PropertyChanged(_pNative, del, false);
+                    }
+                }
+            }
+            remove
+            {
+                if (_pNative == RootSystem.IntPtr.Zero)
+                {
+                    return;
+                }
+
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    callbackList.Remove(value);
+                    if(callbackList.Count == 0)
+                    {
+                        Windows_Kinect_MultiSourceFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_MultiSourceFrameReader_AcquireLatestFrame(RootSystem.IntPtr pNative);
+        public Windows.Kinect.MultiSourceFrame AcquireLatestFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("MultiSourceFrameReader");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_MultiSourceFrameReader_AcquireLatestFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.MultiSourceFrame>(objectPointer, n => new Windows.Kinect.MultiSourceFrame(n));
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_MultiSourceFrameReader_Dispose(RootSystem.IntPtr pNative);
+        public void Dispose()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            Dispose(true);
+            RootSystem.GC.SuppressFinalize(this);
+        }
+
+        private void __EventCleanup()
+        {
+            {
+                Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_MultiSourceFrameReader_add_MultiSourceFrameArrived(_pNative, Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Kinect_MultiSourceFrameArrivedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+            {
+                Windows_Data_PropertyChangedEventArgs_Delegate_callbacks.TryAddDefault(_pNative);
+                var callbackList = Windows_Data_PropertyChangedEventArgs_Delegate_callbacks[_pNative];
+                lock (callbackList)
+                {
+                    if (callbackList.Count > 0)
+                    {
+                        callbackList.Clear();
+                        if (_pNative != RootSystem.IntPtr.Zero)
+                        {
+                            Windows_Kinect_MultiSourceFrameReader_add_PropertyChanged(_pNative, Windows_Data_PropertyChangedEventArgs_Delegate_Handler, true);
+                        }
+                        _Windows_Data_PropertyChangedEventArgs_Delegate_Handle.Free();
+                    }
+                }
+            }
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/MultiSourceFrameReader.cs.meta

+fileFormatVersion: 2
+guid: a52acb4cdb90b3a4fa3937ab27ced4ff
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/MultiSourceFrameReference.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.MultiSourceFrameReference
+    //
+    public sealed partial class MultiSourceFrameReference : Helper.INativeWrapper
+
+    {
+        internal RootSystem.IntPtr _pNative;
+        RootSystem.IntPtr Helper.INativeWrapper.nativePtr { get { return _pNative; } }
+
+        // Constructors and Finalizers
+        internal MultiSourceFrameReference(RootSystem.IntPtr pNative)
+        {
+            _pNative = pNative;
+            Windows_Kinect_MultiSourceFrameReference_AddRefObject(ref _pNative);
+        }
+
+        ~MultiSourceFrameReference()
+        {
+            Dispose(false);
+        }
+
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_MultiSourceFrameReference_ReleaseObject(ref RootSystem.IntPtr pNative);
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern void Windows_Kinect_MultiSourceFrameReference_AddRefObject(ref RootSystem.IntPtr pNative);
+        private void Dispose(bool disposing)
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                return;
+            }
+
+            __EventCleanup();
+
+            Helper.NativeObjectCache.RemoveObject<MultiSourceFrameReference>(_pNative);
+                Windows_Kinect_MultiSourceFrameReference_ReleaseObject(ref _pNative);
+
+            _pNative = RootSystem.IntPtr.Zero;
+        }
+
+
+        // Public Methods
+        [RootSystem.Runtime.InteropServices.DllImport("KinectUnityAddin", CallingConvention=RootSystem.Runtime.InteropServices.CallingConvention.Cdecl, SetLastError=true)]
+        private static extern RootSystem.IntPtr Windows_Kinect_MultiSourceFrameReference_AcquireFrame(RootSystem.IntPtr pNative);
+        public Windows.Kinect.MultiSourceFrame AcquireFrame()
+        {
+            if (_pNative == RootSystem.IntPtr.Zero)
+            {
+                throw new RootSystem.ObjectDisposedException("MultiSourceFrameReference");
+            }
+
+            RootSystem.IntPtr objectPointer = Windows_Kinect_MultiSourceFrameReference_AcquireFrame(_pNative);
+            Helper.ExceptionHelper.CheckLastError();
+            if (objectPointer == RootSystem.IntPtr.Zero)
+            {
+                return null;
+            }
+
+            return Helper.NativeObjectCache.CreateOrGetObject<Windows.Kinect.MultiSourceFrame>(objectPointer, n => new Windows.Kinect.MultiSourceFrame(n));
+        }
+
+        private void __EventCleanup()
+        {
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/MultiSourceFrameReference.cs.meta

+fileFormatVersion: 2
+guid: 8e2ed2961bcca974085bf9ddcaaac6a9
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/TrackingConfidence.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.TrackingConfidence
+    //
+    public enum TrackingConfidence : int
+    {
+        Low                                      =0,
+        High                                     =1,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/TrackingConfidence.cs.meta

+fileFormatVersion: 2
+guid: 7fc638ac4166d2945b7efa3e6699e510
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/TrackingState.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.TrackingState
+    //
+    public enum TrackingState : int
+    {
+        NotTracked                               =0,
+        Inferred                                 =1,
+        Tracked                                  =2,
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/TrackingState.cs.meta

+fileFormatVersion: 2
+guid: 7448c7529f8b6564bb3357abc07b1ccf
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Standard Assets/Windows/Kinect/Vector4.cs

+using RootSystem = System;
+using System.Linq;
+using System.Collections.Generic;
+namespace Windows.Kinect
+{
+    //
+    // Windows.Kinect.Vector4
+    //
+    [RootSystem.Runtime.InteropServices.StructLayout(RootSystem.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct Vector4
+    {
+        public float X { get; set; }
+        public float Y { get; set; }
+        public float Z { get; set; }
+        public float W { get; set; }
+
+        public override int GetHashCode()
+        {
+            return X.GetHashCode() ^ Y.GetHashCode() ^ Z.GetHashCode() ^ W.GetHashCode();
+        }
+
+        public override bool Equals(object obj)
+        {
+            if (!(obj is Vector4))
+            {
+                return false;
+            }
+
+            return this.Equals((Vector4)obj);
+        }
+
+        public bool Equals(Vector4 obj)
+        {
+            return X.Equals(obj.X) && Y.Equals(obj.Y) && Z.Equals(obj.Z) && W.Equals(obj.W);
+        }
+
+        public static bool operator ==(Vector4 a, Vector4 b)
+        {
+            return a.Equals(b);
+        }
+
+        public static bool operator !=(Vector4 a, Vector4 b)
+        {
+            return !(a.Equals(b));
+        }
+    }
+
+}

Assets/Standard Assets/Windows/Kinect/Vector4.cs.meta

+fileFormatVersion: 2
+guid: 6722a9a2a7c5eaa4f98f57c7aca7cfab
+timeCreated: 18446744011573954816
+MonoImporter:
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: