change avatar, add angle, change background etc

@@ -68,3 +68,5 @@ crashlytics-build.properties
 # Temporary auto-generated Android Assets
 # Temporary auto-generated Android Assets
 /[Aa]ssets/[Ss]treamingAssets/aa.meta
 /[Aa]ssets/[Ss]treamingAssets/aa.meta
 /[Aa]ssets/[Ss]treamingAssets/aa/*
 /[Aa]ssets/[Ss]treamingAssets/aa/*
+
+*.meta
\ No newline at end of file

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: clothingSet_04_tex
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: 784c78924e5396744953169847d21860, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: girl_texture_01
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: e955f1ae9549b1f418ecd6aa9ba99082, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: hair1
+  m_Shader: {fileID: 46, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 2800000, guid: f8b7dc5e8d3dff3479902cbf2cf50f42, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _BumpScale: 1
+    - _Cutoff: 0.5
+    - _DetailNormalMapScale: 1
+    - _DstBlend: 0
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _OcclusionStrength: 1
+    - _Parallax: 0.02
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _UVSec: 0
+    - _ZWrite: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!91 &9100000
+AnimatorController:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: girlAC
+  serializedVersion: 5
+  m_AnimatorParameters: []
+  m_AnimatorLayers:
+  - serializedVersion: 5
+    m_Name: Base Layer
+    m_StateMachine: {fileID: 1107184895931894816}
+    m_Mask: {fileID: 0}
+    m_Motions: []
+    m_Behaviours: []
+    m_BlendingMode: 0
+    m_SyncedLayerIndex: -1
+    m_DefaultWeight: 0
+    m_IKPass: 0
+    m_SyncedLayerAffectsTiming: 0
+    m_Controller: {fileID: 9100000}
+--- !u!1102 &1102235434097723244
+AnimatorState:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: New State
+  m_Speed: 1
+  m_CycleOffset: 0
+  m_Transitions: []
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 7400002, guid: a5e11101db1088e47b2aef562350ae30, type: 3}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
+--- !u!1107 &1107184895931894816
+AnimatorStateMachine:
+  serializedVersion: 5
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: Base Layer
+  m_ChildStates:
+  - serializedVersion: 1
+    m_State: {fileID: 1102235434097723244}
+    m_Position: {x: 302.25, y: 74, z: 0}
+  m_ChildStateMachines: []
+  m_AnyStateTransitions: []
+  m_EntryTransitions: []
+  m_StateMachineTransitions: {}
+  m_StateMachineBehaviours: []
+  m_AnyStatePosition: {x: 50, y: 20, z: 0}
+  m_EntryPosition: {x: 50, y: 120, z: 0}
+  m_ExitPosition: {x: 800, y: 120, z: 0}
+  m_ParentStateMachinePosition: {x: 800, y: 20, z: 0}
+  m_DefaultState: {fileID: 1102235434097723244}

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: BoneMaterial
+  m_Shader: {fileID: 200, guid: 0000000000000000f000000000000000, type: 0}
+  m_ShaderKeywords: 
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses: []
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _InvFade: 1
+    m_Colors:
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _TintColor: {r: 0.5, g: 0.5, b: 0.5, a: 0.5}

+using UnityEngine;
+using System.Collections;
+using Windows.Kinect;
+
+public class BodySourceManager : MonoBehaviour 
+{
+    private KinectSensor _Sensor;
+    private BodyFrameReader _Reader;
+    private Body[] _Data = null;
+    
+    public Body[] GetData()
+    {
+        return _Data;
+    }
+    
+
+    void Start () 
+    {
+        _Sensor = KinectSensor.GetDefault();
+
+        if (_Sensor != null)
+        {
+            _Reader = _Sensor.BodyFrameSource.OpenReader();
+            
+            if (!_Sensor.IsOpen)
+            {
+                _Sensor.Open();
+            }
+        }   
+    }
+    
+    void Update () 
+    {
+        if (_Reader != null)
+        {
+            var frame = _Reader.AcquireLatestFrame();
+            if (frame != null)
+            {
+                if (_Data == null)
+                {
+                    _Data = new Body[_Sensor.BodyFrameSource.BodyCount];
+                }
+                
+                frame.GetAndRefreshBodyData(_Data);
+                
+                frame.Dispose();
+                frame = null;
+            }
+        }    
+    }
+    
+    void OnApplicationQuit()
+    {
+        if (_Reader != null)
+        {
+            _Reader.Dispose();
+            _Reader = null;
+        }
+        
+        if (_Sensor != null)
+        {
+            if (_Sensor.IsOpen)
+            {
+                _Sensor.Close();
+            }
+            
+            _Sensor = null;
+        }
+    }
+}

+using UnityEngine;
+using System.Collections;
+using System.Collections.Generic;
+using Kinect = Windows.Kinect;
+
+public class BodySourceView : MonoBehaviour 
+{
+    public Material BoneMaterial;
+    public GameObject BodySourceManager;
+    
+    private Dictionary<ulong, GameObject> _Bodies = new Dictionary<ulong, GameObject>();
+    private BodySourceManager _BodyManager;
+    
+    private Dictionary<Kinect.JointType, Kinect.JointType> _BoneMap = new Dictionary<Kinect.JointType, Kinect.JointType>()
+    {
+        { Kinect.JointType.FootLeft, Kinect.JointType.AnkleLeft },
+        { Kinect.JointType.AnkleLeft, Kinect.JointType.KneeLeft },
+        { Kinect.JointType.KneeLeft, Kinect.JointType.HipLeft },
+        { Kinect.JointType.HipLeft, Kinect.JointType.SpineBase },
+        
+        { Kinect.JointType.FootRight, Kinect.JointType.AnkleRight },
+        { Kinect.JointType.AnkleRight, Kinect.JointType.KneeRight },
+        { Kinect.JointType.KneeRight, Kinect.JointType.HipRight },
+        { Kinect.JointType.HipRight, Kinect.JointType.SpineBase },
+        
+        { Kinect.JointType.HandTipLeft, Kinect.JointType.HandLeft },
+        { Kinect.JointType.ThumbLeft, Kinect.JointType.HandLeft },
+        { Kinect.JointType.HandLeft, Kinect.JointType.WristLeft },
+        { Kinect.JointType.WristLeft, Kinect.JointType.ElbowLeft },
+        { Kinect.JointType.ElbowLeft, Kinect.JointType.ShoulderLeft },
+        { Kinect.JointType.ShoulderLeft, Kinect.JointType.SpineShoulder },
+        
+        { Kinect.JointType.HandTipRight, Kinect.JointType.HandRight },
+        { Kinect.JointType.ThumbRight, Kinect.JointType.HandRight },
+        { Kinect.JointType.HandRight, Kinect.JointType.WristRight },
+        { Kinect.JointType.WristRight, Kinect.JointType.ElbowRight },
+        { Kinect.JointType.ElbowRight, Kinect.JointType.ShoulderRight },
+        { Kinect.JointType.ShoulderRight, Kinect.JointType.SpineShoulder },
+        
+        { Kinect.JointType.SpineBase, Kinect.JointType.SpineMid },
+        { Kinect.JointType.SpineMid, Kinect.JointType.SpineShoulder },
+        { Kinect.JointType.SpineShoulder, Kinect.JointType.Neck },
+        { Kinect.JointType.Neck, Kinect.JointType.Head },
+    };
+    
+    void Update () 
+    {
+        if (BodySourceManager == null)
+        {
+            return;
+        }
+        
+        _BodyManager = BodySourceManager.GetComponent<BodySourceManager>();
+        if (_BodyManager == null)
+        {
+            return;
+        }
+        
+        Kinect.Body[] data = _BodyManager.GetData();
+        if (data == null)
+        {
+            return;
+        }
+        
+        List<ulong> trackedIds = new List<ulong>();
+        foreach(var body in data)
+        {
+            if (body == null)
+            {
+                continue;
+              }
+                
+            if(body.IsTracked)
+            {
+                trackedIds.Add (body.TrackingId);
+            }
+        }
+        
+        List<ulong> knownIds = new List<ulong>(_Bodies.Keys);
+        
+        // First delete untracked bodies
+        foreach(ulong trackingId in knownIds)
+        {
+            if(!trackedIds.Contains(trackingId))
+            {
+                Destroy(_Bodies[trackingId]);
+                _Bodies.Remove(trackingId);
+            }
+        }
+
+        foreach(var body in data)
+        {
+            if (body == null)
+            {
+                continue;
+            }
+            
+            if(body.IsTracked)
+            {
+                if(!_Bodies.ContainsKey(body.TrackingId))
+                {
+                    _Bodies[body.TrackingId] = CreateBodyObject(body.TrackingId);
+                    
+                }
+                RefreshBodyObject(body, _Bodies[body.TrackingId]);
+            }
+        }
+    }
+    
+    private GameObject CreateBodyObject(ulong id)
+    {
+        GameObject body = new GameObject("Body:" + id);
+        
+        for (Kinect.JointType jt = Kinect.JointType.SpineBase; jt <= Kinect.JointType.ThumbRight; jt++)
+        {
+            GameObject jointObj = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            
+            LineRenderer lr = jointObj.AddComponent<LineRenderer>();
+            lr.SetVertexCount(2);
+            lr.material = BoneMaterial;
+            lr.SetWidth(0.05f, 0.05f);
+            
+            jointObj.transform.localScale = new Vector3(0.3f, 0.3f, 0.3f);
+            jointObj.name = jt.ToString();
+            jointObj.transform.parent = body.transform;
+        }
+        
+        return body;
+    }
+    
+    private void RefreshBodyObject(Kinect.Body body, GameObject bodyObject)
+    {
+    
+        for (Kinect.JointType jt = Kinect.JointType.SpineBase; jt <= Kinect.JointType.ThumbRight; jt++)
+        {
+            Kinect.Joint sourceJoint = body.Joints[jt];
+            Debug.Log(body.Joints[jt].JointType);
+            Debug.Log(sourceJoint.Position.X * 10);
+            Debug.Log(sourceJoint.Position.Y * 10);
+            Debug.Log(sourceJoint.Position.Z * 10);
+            Kinect.Joint? targetJoint = null;
+            
+            if(_BoneMap.ContainsKey(jt))
+            {
+                targetJoint = body.Joints[_BoneMap[jt]];
+            }
+            Transform jointObj = bodyObject.transform.Find(jt.ToString());
+            jointObj.localPosition = GetVector3FromJoint(sourceJoint);
+            
+            LineRenderer lr = jointObj.GetComponent<LineRenderer>();
+            if(targetJoint.HasValue)
+            {
+                lr.SetPosition(0, jointObj.localPosition);
+                lr.SetPosition(1, GetVector3FromJoint(targetJoint.Value));
+                lr.SetColors(GetColorForState (sourceJoint.TrackingState), GetColorForState(targetJoint.Value.TrackingState));
+            }
+            else
+            {
+                lr.enabled = false;
+            }
+        }
+    }
+    
+    private static Color GetColorForState(Kinect.TrackingState state)
+    {
+        switch (state)
+        {
+        case Kinect.TrackingState.Tracked:
+            return Color.green;
+
+        case Kinect.TrackingState.Inferred:
+            return Color.red;
+
+        default:
+            return Color.black;
+        }
+    }
+    
+    private static Vector3 GetVector3FromJoint(Kinect.Joint joint)
+    {
+        return new Vector3(joint.Position.X * 10, joint.Position.Y * 10, joint.Position.Z * 10);
+    }
+}

+using UnityEngine;
+using System.Collections;
+using Windows.Kinect;
+
+public class ColorSourceManager : MonoBehaviour 
+{
+    public int ColorWidth { get; private set; }
+    public int ColorHeight { get; private set; }
+
+    private KinectSensor _Sensor;
+    private ColorFrameReader _Reader;
+    private Texture2D _Texture;
+    private byte[] _Data;
+    
+    public Texture2D GetColorTexture()
+    {
+        return _Texture;
+    }
+    
+    void Start()
+    {
+        _Sensor = KinectSensor.GetDefault();
+        
+        if (_Sensor != null) 
+        {
+            _Reader = _Sensor.ColorFrameSource.OpenReader();
+            
+            var frameDesc = _Sensor.ColorFrameSource.CreateFrameDescription(ColorImageFormat.Rgba);
+            ColorWidth = frameDesc.Width;
+            ColorHeight = frameDesc.Height;
+            
+            _Texture = new Texture2D(frameDesc.Width, frameDesc.Height, TextureFormat.RGBA32, false);
+            _Data = new byte[frameDesc.BytesPerPixel * frameDesc.LengthInPixels];
+            
+            if (!_Sensor.IsOpen)
+            {
+                _Sensor.Open();
+            }
+        }
+    }
+    
+    void Update () 
+    {
+        if (_Reader != null) 
+        {
+            var frame = _Reader.AcquireLatestFrame();
+            
+            if (frame != null)
+            {
+                frame.CopyConvertedFrameDataToArray(_Data, ColorImageFormat.Rgba);
+                _Texture.LoadRawTextureData(_Data);
+                _Texture.Apply();
+                
+                frame.Dispose();
+                frame = null;
+            }
+        }
+    }
+
+    void OnApplicationQuit()
+    {
+        if (_Reader != null) 
+        {
+            _Reader.Dispose();
+            _Reader = null;
+        }
+        
+        if (_Sensor != null) 
+        {
+            if (_Sensor.IsOpen)
+            {
+                _Sensor.Close();
+            }
+            
+            _Sensor = null;
+        }
+    }
+}

+using UnityEngine;
+using System.Collections;
+using Windows.Kinect;
+
+public class ColorSourceView : MonoBehaviour
+{
+    public GameObject ColorSourceManager;
+    private ColorSourceManager _ColorManager;
+    
+    void Start ()
+    {
+        gameObject.GetComponent<Renderer>().material.SetTextureScale("_MainTex", new Vector2(-1, 1));
+    }
+    
+    void Update()
+    {
+        if (ColorSourceManager == null)
+        {
+            return;
+        }
+        
+        _ColorManager = ColorSourceManager.GetComponent<ColorSourceManager>();
+        if (_ColorManager == null)
+        {
+            return;
+        }
+        
+        gameObject.GetComponent<Renderer>().material.mainTexture = _ColorManager.GetColorTexture();
+    }
+}

+using UnityEngine;
+using System.Collections;
+using Windows.Kinect;
+
+public class DepthSourceManager : MonoBehaviour
+{   
+    private KinectSensor _Sensor;
+    private DepthFrameReader _Reader;
+    private ushort[] _Data;
+
+    public ushort[] GetData()
+    {
+        return _Data;
+    }
+
+    void Start () 
+    {
+        _Sensor = KinectSensor.GetDefault();
+        
+        if (_Sensor != null) 
+        {
+            _Reader = _Sensor.DepthFrameSource.OpenReader();
+            _Data = new ushort[_Sensor.DepthFrameSource.FrameDescription.LengthInPixels];
+        }
+    }
+    
+    void Update () 
+    {
+        if (_Reader != null)
+        {
+            var frame = _Reader.AcquireLatestFrame();
+            if (frame != null)
+            {
+                frame.CopyFrameDataToArray(_Data);
+                frame.Dispose();
+                frame = null;
+            }
+        }
+    }
+    
+    void OnApplicationQuit()
+    {
+        if (_Reader != null)
+        {
+            _Reader.Dispose();
+            _Reader = null;
+        }
+        
+        if (_Sensor != null)
+        {
+            if (_Sensor.IsOpen)
+            {
+                _Sensor.Close();
+            }
+            
+            _Sensor = null;
+        }
+    }
+}

+using UnityEngine;
+using System.Collections;
+using Windows.Kinect;
+
+public enum DepthViewMode
+{
+    SeparateSourceReaders,
+    MultiSourceReader,
+}
+
+public class DepthSourceView : MonoBehaviour
+{
+    public DepthViewMode ViewMode = DepthViewMode.SeparateSourceReaders;
+    
+    public GameObject ColorSourceManager;
+    public GameObject DepthSourceManager;
+    public GameObject MultiSourceManager;
+    
+    private KinectSensor _Sensor;
+    private CoordinateMapper _Mapper;
+    private Mesh _Mesh;
+    private Vector3[] _Vertices;
+    private Vector2[] _UV;
+    private int[] _Triangles;
+    
+    // Only works at 4 right now
+    private const int _DownsampleSize = 4;
+    private const double _DepthScale = 0.1f;
+    private const int _Speed = 50;
+    
+    private MultiSourceManager _MultiManager;
+    private ColorSourceManager _ColorManager;
+    private DepthSourceManager _DepthManager;
+
+    void Start()
+    {
+        _Sensor = KinectSensor.GetDefault();
+        if (_Sensor != null)
+        {
+            _Mapper = _Sensor.CoordinateMapper;
+            var frameDesc = _Sensor.DepthFrameSource.FrameDescription;
+
+            // Downsample to lower resolution
+            CreateMesh(frameDesc.Width / _DownsampleSize, frameDesc.Height / _DownsampleSize);
+
+            if (!_Sensor.IsOpen)
+            {
+                _Sensor.Open();
+            }
+        }
+    }
+
+    void CreateMesh(int width, int height)
+    {
+        _Mesh = new Mesh();
+        GetComponent<MeshFilter>().mesh = _Mesh;
+
+        _Vertices = new Vector3[width * height];
+        _UV = new Vector2[width * height];
+        _Triangles = new int[6 * ((width - 1) * (height - 1))];
+
+        int triangleIndex = 0;
+        for (int y = 0; y < height; y++)
+        {
+            for (int x = 0; x < width; x++)
+            {
+                int index = (y * width) + x;
+
+                _Vertices[index] = new Vector3(x, -y, 0);
+                _UV[index] = new Vector2(((float)x / (float)width), ((float)y / (float)height));
+
+                // Skip the last row/col
+                if (x != (width - 1) && y != (height - 1))
+                {
+                    int topLeft = index;
+                    int topRight = topLeft + 1;
+                    int bottomLeft = topLeft + width;
+                    int bottomRight = bottomLeft + 1;
+
+                    _Triangles[triangleIndex++] = topLeft;
+                    _Triangles[triangleIndex++] = topRight;
+                    _Triangles[triangleIndex++] = bottomLeft;
+                    _Triangles[triangleIndex++] = bottomLeft;
+                    _Triangles[triangleIndex++] = topRight;
+                    _Triangles[triangleIndex++] = bottomRight;
+                }
+            }
+        }
+
+        _Mesh.vertices = _Vertices;
+        _Mesh.uv = _UV;
+        _Mesh.triangles = _Triangles;
+        _Mesh.RecalculateNormals();
+    }
+    
+    void OnGUI()
+    {
+        GUI.BeginGroup(new Rect(0, 0, Screen.width, Screen.height));
+        GUI.TextField(new Rect(Screen.width - 250 , 10, 250, 20), "DepthMode: " + ViewMode.ToString());
+        GUI.EndGroup();
+    }
+
+    void Update()
+    {
+        if (_Sensor == null)
+        {
+            return;
+        }
+        
+        if (Input.GetButtonDown("Fire1"))
+        {
+            if(ViewMode == DepthViewMode.MultiSourceReader)
+            {
+                ViewMode = DepthViewMode.SeparateSourceReaders;
+            }
+            else
+            {
+                ViewMode = DepthViewMode.MultiSourceReader;
+            }
+        }
+        
+        float yVal = Input.GetAxis("Horizontal");
+        float xVal = -Input.GetAxis("Vertical");
+
+        transform.Rotate(
+            (xVal * Time.deltaTime * _Speed), 
+            (yVal * Time.deltaTime * _Speed), 
+            0, 
+            Space.Self);
+            
+        if (ViewMode == DepthViewMode.SeparateSourceReaders)
+        {
+            if (ColorSourceManager == null)
+            {
+                return;
+            }
+            
+            _ColorManager = ColorSourceManager.GetComponent<ColorSourceManager>();
+            if (_ColorManager == null)
+            {
+                return;
+            }
+            
+            if (DepthSourceManager == null)
+            {
+                return;
+            }
+            
+            _DepthManager = DepthSourceManager.GetComponent<DepthSourceManager>();
+            if (_DepthManager == null)
+            {
+                return;
+            }
+            
+            gameObject.GetComponent<Renderer>().material.mainTexture = _ColorManager.GetColorTexture();
+            RefreshData(_DepthManager.GetData(),
+                _ColorManager.ColorWidth,
+                _ColorManager.ColorHeight);
+        }
+        else
+        {
+            if (MultiSourceManager == null)
+            {
+                return;
+            }
+            
+            _MultiManager = MultiSourceManager.GetComponent<MultiSourceManager>();
+            if (_MultiManager == null)
+            {
+                return;
+            }
+            
+            gameObject.GetComponent<Renderer>().material.mainTexture = _MultiManager.GetColorTexture();
+            
+            RefreshData(_MultiManager.GetDepthData(),
+                        _MultiManager.ColorWidth,
+                        _MultiManager.ColorHeight);
+        }
+    }
+    
+    private void RefreshData(ushort[] depthData, int colorWidth, int colorHeight)
+    {
+        var frameDesc = _Sensor.DepthFrameSource.FrameDescription;
+        
+        ColorSpacePoint[] colorSpace = new ColorSpacePoint[depthData.Length];
+        _Mapper.MapDepthFrameToColorSpace(depthData, colorSpace);
+        
+        for (int y = 0; y < frameDesc.Height; y += _DownsampleSize)
+        {
+            for (int x = 0; x < frameDesc.Width; x += _DownsampleSize)
+            {
+                int indexX = x / _DownsampleSize;
+                int indexY = y / _DownsampleSize;
+                int smallIndex = (indexY * (frameDesc.Width / _DownsampleSize)) + indexX;
+                
+                double avg = GetAvg(depthData, x, y, frameDesc.Width, frameDesc.Height);
+                
+                avg = avg * _DepthScale;
+                
+                _Vertices[smallIndex].z = (float)avg;
+                
+                // Update UV mapping with CDRP
+                var colorSpacePoint = colorSpace[(y * frameDesc.Width) + x];
+                _UV[smallIndex] = new Vector2(colorSpacePoint.X / colorWidth, colorSpacePoint.Y / colorHeight);
+            }
+        }
+        
+        _Mesh.vertices = _Vertices;
+        _Mesh.uv = _UV;
+        _Mesh.triangles = _Triangles;
+        _Mesh.RecalculateNormals();
+    }
+    
+    private double GetAvg(ushort[] depthData, int x, int y, int width, int height)
+    {
+        double sum = 0.0;
+        
+        for (int y1 = y; y1 < y + 4; y1++)
+        {
+            for (int x1 = x; x1 < x + 4; x1++)
+            {
+                int fullIndex = (y1 * width) + x1;
+                
+                if (depthData[fullIndex] == 0)
+                    sum += 4500;
+                else
+                    sum += depthData[fullIndex];
+                
+            }
+        }
+
+        return sum / 16;
+    }
+
+    void OnApplicationQuit()
+    {
+        if (_Mapper != null)
+        {
+            _Mapper = null;
+        }
+        
+        if (_Sensor != null)
+        {
+            if (_Sensor.IsOpen)
+            {
+                _Sensor.Close();
+            }
+
+            _Sensor = null;
+        }
+    }
+}

+using UnityEngine;
+using System.Collections;
+
+public class DisableOnStart : MonoBehaviour {
+
+    // Use this for initialization
+    void Start () 
+    {
+        gameObject.SetActive (false);
+    }
+}

+using UnityEngine;
+using System.Collections;
+using Windows.Kinect;
+
+public class InfraredSourceManager : MonoBehaviour 
+{
+    private KinectSensor _Sensor;
+    private InfraredFrameReader _Reader;
+    private ushort[] _Data;
+    private byte[] _RawData;
+    
+    // I'm not sure this makes sense for the Kinect APIs
+    // Instead, this logic should be in the VIEW
+    private Texture2D _Texture;
+
+    public Texture2D GetInfraredTexture()
+    {
+        return _Texture;
+    }
+    
+    void Start()
+    {
+        _Sensor = KinectSensor.GetDefault();
+        if (_Sensor != null) 
+        {
+            _Reader = _Sensor.InfraredFrameSource.OpenReader();
+            var frameDesc = _Sensor.InfraredFrameSource.FrameDescription;
+            _Data = new ushort[frameDesc.LengthInPixels];
+            _RawData = new byte[frameDesc.LengthInPixels * 4];
+            _Texture = new Texture2D(frameDesc.Width, frameDesc.Height, TextureFormat.BGRA32, false);
+            
+            if (!_Sensor.IsOpen)
+            {
+                _Sensor.Open();
+            }
+        }
+    }
+
+    void Update () 
+    {
+        if (_Reader != null) 
+        {
+            var frame = _Reader.AcquireLatestFrame();
+            if (frame != null)
+            {
+                frame.CopyFrameDataToArray(_Data);
+                
+                int index = 0;
+                foreach(var ir in _Data)
+                {
+                    byte intensity = (byte)(ir >> 8);
+                    _RawData[index++] = intensity;
+                    _RawData[index++] = intensity;
+                    _RawData[index++] = intensity;
+                    _RawData[index++] = 255; // Alpha
+                }
+                
+                _Texture.LoadRawTextureData(_RawData);
+                _Texture.Apply();
+                
+                frame.Dispose();
+                frame = null;
+            }
+        }
+    }
+    
+    void OnApplicationQuit()
+    {
+        if (_Reader != null) 
+        {
+            _Reader.Dispose();
+            _Reader = null;
+        }
+        
+        if (_Sensor != null) 
+        {
+            if (_Sensor.IsOpen)
+            {
+                _Sensor.Close();
+            }
+            
+            _Sensor = null;
+        }
+    }
+}

+using UnityEngine;
+using System.Collections;
+
+public class InfraredSourceView : MonoBehaviour 
+{
+    public GameObject InfraredSourceManager;
+    private InfraredSourceManager _InfraredManager;
+    
+    void Start () 
+    {
+        gameObject.GetComponent<Renderer>().material.SetTextureScale("_MainTex", new Vector2(-1, 1));
+    }
+    
+    void Update()
+    {
+        if (InfraredSourceManager == null)
+        {
+            return;
+        }
+        
+        _InfraredManager = InfraredSourceManager.GetComponent<InfraredSourceManager>();
+        if (_InfraredManager == null)
+        {
+            return;
+        }
+    
+        gameObject.GetComponent<Renderer>().material.mainTexture = _InfraredManager.GetInfraredTexture();
+    }
+}

+using UnityEngine;
+using System.Collections;
+using Windows.Kinect;
+
+public class MultiSourceManager : MonoBehaviour {
+    public int ColorWidth { get; private set; }
+    public int ColorHeight { get; private set; }
+    
+    private KinectSensor _Sensor;
+    private MultiSourceFrameReader _Reader;
+    private Texture2D _ColorTexture;
+    private ushort[] _DepthData;
+    private byte[] _ColorData;
+
+    public Texture2D GetColorTexture()
+    {
+        return _ColorTexture;
+    }
+    
+    public ushort[] GetDepthData()
+    {
+        return _DepthData;
+    }
+
+    void Start () 
+    {
+        _Sensor = KinectSensor.GetDefault();
+        
+        if (_Sensor != null) 
+        {
+            _Reader = _Sensor.OpenMultiSourceFrameReader(FrameSourceTypes.Color | FrameSourceTypes.Depth);
+            
+            var colorFrameDesc = _Sensor.ColorFrameSource.CreateFrameDescription(ColorImageFormat.Rgba);
+            ColorWidth = colorFrameDesc.Width;
+            ColorHeight = colorFrameDesc.Height;
+            
+            _ColorTexture = new Texture2D(colorFrameDesc.Width, colorFrameDesc.Height, TextureFormat.RGBA32, false);
+            _ColorData = new byte[colorFrameDesc.BytesPerPixel * colorFrameDesc.LengthInPixels];
+            
+            var depthFrameDesc = _Sensor.DepthFrameSource.FrameDescription;
+            _DepthData = new ushort[depthFrameDesc.LengthInPixels];
+            
+            if (!_Sensor.IsOpen)
+            {
+                _Sensor.Open();
+            }
+        }
+    }
+    
+    void Update () 
+    {
+        if (_Reader != null) 
+        {
+            var frame = _Reader.AcquireLatestFrame();
+            if (frame != null)
+            {
+                var colorFrame = frame.ColorFrameReference.AcquireFrame();
+                if (colorFrame != null)
+                {
+                    var depthFrame = frame.DepthFrameReference.AcquireFrame();
+                    if (depthFrame != null)
+                    {
+                        colorFrame.CopyConvertedFrameDataToArray(_ColorData, ColorImageFormat.Rgba);
+                        _ColorTexture.LoadRawTextureData(_ColorData);
+                        _ColorTexture.Apply();
+                        
+                        depthFrame.CopyFrameDataToArray(_DepthData);
+                        
+                        depthFrame.Dispose();
+                        depthFrame = null;
+                    }
+                
+                    colorFrame.Dispose();
+                    colorFrame = null;
+                }
+                
+                frame = null;
+            }
+        }
+    }
+    
+    void OnApplicationQuit()
+    {
+        if (_Reader != null)
+        {
+            _Reader.Dispose();
+            _Reader = null;
+        }
+        
+        if (_Sensor != null)
+        {
+            if (_Sensor.IsOpen)
+            {
+                _Sensor.Close();
+            }
+            
+            _Sensor = null;
+        }
+    }
+}