This is the second post in a series of posts which covers various features and extensions available in Visual Studio.  I work in Visual Studio for most of my day and over time I have found a number of extensions that have been extremely useful while coding. This post covers a list of the ones I use most and why.

Keywords: Visual Studio, Extensions

Introduction

The extensions I have included have various different features and capabilities and each of them make my life easier as a developer. I am not listing them in any particular order. All the extensions can be found in the manager but I will provide links to each extension in this post. Enjoy.

Extensions

CodeMaid

I like my code neat and organised. I like to group my members at the top based on access and my methods into regions. I also like to have things in alphabetical order, I have no idea why but it makes me happy to know that my code is always neat. One easy way to make sure you have neatly formatted code is to use CodeMaid. CodeMaid is an open source extension that will clean and simplify your code for you. You can configure various options on how you want it to clean your code. From whether to add regions, ordering preferences, and which rules to use. I have personally set it to organise my code every time I save but you can configure this to what suits you best.

CodeMaid comes with a simple code discovery tool called Spade which allows you to dig into your code quickly and you can drag and drop the code in Spade to reorganise the code how you prefer.

Link: http://www.codemaid.net/

CodeCracker

Is an analyser library for C# and VB that helps identify Design, Naming, Performance, Style, Usage and Refactoring items within your code. There is some overlap with the Style Cop extension there are some additional checks in Style Cop that don't exist in CodeCracker and some that exist in Style Cop Analysers. I run both side by side and get some very neat code in the end and some great information on how to improve my code.

Link: http://code-cracker.github.io/

Powershell Tools

I user Powershell extensively while developing solutions especially when I use Azure and these tools provide some really helpful features. It adds some scripting enhancements, Intellisense, project systems, and debugging for Powershell right in Visual Studio.

Link: http://adamdriscoll.github.io/poshtools/

Productivity Power Tools 2015

This is a collection of tools built by Microsoft that helps you be more productive. They have added features for Peek Help, Quick Tasks, Power Commands, Fix Mixed Tabs, and a whole lot more. Some of the best features they have added is the Solution Explorer Errors which helps you find errors quickly within your code.

Link: https://visualstudiogallery.msdn.microsoft.com/34ebc6a2-2777-421d-8914-e29c1dfa7f5d

Visual Studio 2015 Color Theme Editor

We all work in our IDE for a long period of time and its great when we can have a good looking experience. Its a pain to go and customise your theme everytime you reinstall or get a new machine. The easiest way to manage this is through the theme editor extension which allows you to change themes and customize your IDE base on past themes which you have exported or downloaded.

Spell Checker

One thing I like to see is that my comments and strings are spelt correctly. I use Visual Studio Spell checker, its not a bad tool, I think its a little limited as to what it checks but works for my needs.

Link: https://github.com/EWSoftware/VSSpellChecker/wiki

Refactoring Essentials

Refactoring is a great way to enhance and maintain your code over time. The Refactoring Essentials extension has been extremely useful day today and has a ton of great features. With rich analysers and some very useful refactorings this tool has made my life a lot easier.

C# Essentials

C# Essentials is a set of analysers, code fixes and refactorings which are targeted with working in C# 6 and the new features that are included. This extension will identify when parameters are in strings, when auto-properties are getter only, and conversions to interpolated strings.

Link: https://github.com/DustinCampbell/CSharpEssentials

SideWaffle

There are times when I am working with Visual Studio and I think wouldn’t it be nice to create a project with Angular, or add new files to a project such as a robot.txt. This extension reduces the amount of work needed to maintain and build new websites. Here is a video from his site:

Link: http://sidewaffle.com/

GitHub Extension

Most developers today work with Git as their choice of source control, the default installation of Visual Studio does not include the GitHub Extension. Simply go install it and it adds great features for working with Git and GitHub right from visual studio.

Link: https://visualstudio.github.com/

Web Essentials

I am not going to cover web essentials in detail here because it has been done so many times, but it is an amazing collection of tools for web development.

Link: http://vswebessentials.com/

VSColorOutput

The last one on my list for this post is VSColorOutput which modifies the colours of the output windows using regular expressions to select text in the output window and modify its colour. This is brilliant if you rely on the output window for a large amount of information. It makes it easy to identify important information in your output windows and its pretty to boot.

Link: http://mike-ward.net/vscoloroutput

Summary

I hope you have found these extensions useful, I want to thank Rob Maclean for his input on this list you can find him at http://www.sadev.co.za

Coming up on the 8^th March in Johannesburg is a new full day conference for all software developers and those interested in DevOps & databases known as DevConf. This conference is being run for the first time and has attracted over 40 speakers, including a number international speakers to spend the day sharing and learning. DevConf serves to inspire software developers. A range of topics applicable to software development will be presented. From keeping up to date with the latest technologies and trends to tackling the challenges of working in large enterprise systems – it's a buffet of experiences, ideas and pragmatic advice as well as an opportunity to connect with peers across the industry. To achieve this the conference will have five tracks of content with over 40 sessions, covering programming languages, soft skills & working in teams, DevOps, databases and tools & frameworks giving developers the opportunity to grow their existing skills and cross skill for the future.

DevConf is being run by the Developer User Group with support from other user groups and sponsors and ticket sales are open. You can get all the details and tickets at http://www.devconf.co.za

This series of posts will detail my somewhat bumbling ordeal of becoming more informed when it comes to electronics, and things IoT. I must put a disclaimer in place. I am NOT an electronic engineer, I studied Computer Science and Psychology at University and am the first to admit that electronics is the equivalent of unicorns and magic to me at this point.

Join me on this journey and I hope I can show you somethings not to do and something new through what looks to be a very long series of complete mess ups. In this part I am going to look at IoT and Microsoft.

Keywords: Internet of Things, Raspberry Pi, Arduino, Microsoft, Windows Universal Platform.

Introduction

In this session I will be investigating the various options we have with regards to using the Windows IoT Core OS and getting setup. I will go into the various devices and programming options we have with regards to IoT on Windows and how we go about setting up our device for the series going forward.

Discussion

Internet of Things (IoT) has a been a major buzz word over the last year and a bit. What the heck is IoT? What is a thing of the internet? Is it anything that connects to the internet?

The one true source of a things true Wikipedia defines IoT as:

“The Internet of Things (IoT) is the network of physical objects, devices, vehicles, buildings and other items which are embedded with electronics, software, sensors, and network connectivity, which enables these objects to collect and exchange data”

While this definitely holds true I think something else is missing from the definition. This ability for items to communicate and exchange data also allows us to gain insight into how things work and improve on how they function. This exchange data enables us to control these items and build up models of how they interact and affect various aspects of the real world. This opens a world of opportunities for automation of various areas of life from making coffee in the morning (which is critically important) to manufacturing of cars, and sanitation. When we combine this world of millions if not billions of devices with the cloud we start seeing an amazing platform to gain information and to make our lives easier.

Microsoft has been making some pushes into IoT through two paths. The paths are:

• Operating system or IoT Clients
• Cloud or IoT Services

Figure 1.0 – IoT Base Structure shows a basic structure of an IoT Solution. Basically the information from sensors is passed and handled by the IoT Device. In some instances the device will process the information and do what it needs to without forwarding the information on to services. This is useful in offline scenarios where the IoT device does not have access the internet. In this scenario there is a wealth of information available which could be useful.

Figure 1.0 – IoT Base Structure

Lets look at this with the Microsoft Technologies this is seen by Figure 1.1 IoT with the Microsoft Stack.

Figure 1.1 IoT with the Microsoft Stack.

As you can see there is quite an extensive set of component that form part of Microsoft’s set IoT stack. If we take a look at Figure 1.2 Azure IoT Reference Architecture Diagram we can see that the components that the Azure Stack provide covers all the various areas required to build a pretty great solution.

Figure 1.2 Azure IoT Reference Architecture Diagram

I now have a basic understanding of IoT what are my options if I am looking at Microsoft. What is this Windows IoT Core thing? It is a build of Windows 10 that is engineered for devices which may not have a display and leverage different CPU architecture which focuses on low power. To sum up Windows IoT Core is an operating system design for IoT Scenarios. It is an edition of Windows 10 optimized for small footprint, low cost IoT devices.  It supports universal apps, but does not include the Windows shell for first party apps, making it ideal for single purpose devices. IoT Core comes in a number of different flavors but we will be focusing on the basic Windows IoT Core version which is royalty free.

What devices are supported by Windows IoT at this point in time (2016/01)?

• Raspberry Pi 2
• MinnowBoard Max
• DragonBoard

All of these low power devices that are supported are about 1000 times faster than my first computer and they a 10th of the size. I love how far we have come. There are tons of IoT devices that don't support Windows IoT but Microsoft is working with various partners and the number of supported devices is increasing all the time.

If you want to follow this series its probably a good time to get your hands on the following for the next installment:

• 1x Raspberry Pi 2
• 1x Network Cable
• 1x MicroSD card
• 1x LED 
• Some wires
• Some resistors

There are a tons of kits available on the internet which are great to start with and can be shipped in fairly short times.

Conclusion

IoT is an exciting area to venture into, so far I feel like I am going to have to learn something about electronics but lets wing it for now. In the next installment of the series is to look deeper at the application options on Windows IoT Core and Universal Windows Platform and Node.js and build our first burnt out circuit board. I can't personally can’t wait to blow up some electronics.

I for one welcome our new robot overlords.

References

https://en.wikipedia.org/wiki/Internet_of_Things

http://ms-iot.github.io/content/en-US/IoTCore.htm

http://www.windowsondevices.com

Additionally we are also working on running the following camps:

• Unity 3D Porting Lab
• Cloud Camp
• Cloud Data Camp

See below for more details:

We are looking forward to seeing you there. Cape Town event details happening soon.

This is a series of posts that goes through the new features of Visual Studio. This specific post focuses on some of the new features of 2013. With 2015 coming soon and the CTP being available I will doing the same for 2015 once it is released. This first article covers the use of some of the new features in VS 2013. This is article is designed to be a walk through that you can do your self.

Introduction

The IDE is probably one of the most important tools a developer has. With various IDE’s out there from IntelliJ to Sublime and Visual Studio to name a few I generally find myself living in Visual Studio. What ever platform I work with, be it Unity3D, C++, C#, HTML JavaScript, PHP, VB, F# its all supported and is a great editor. There are a number of reasons for me mainly working in VS most of them subjective but mostly because I am most comfortable in Visual Studio and it has some amazing features.

This is the first of hopefully many walk through of the various features of Visual Studio. This issue we will be going through the introduction of the Sign in and Sync Settings, the Enhanced Scroll bar, Navigate to, and Peek Definition. I have structured this so you can follow through the step by step to become familiar with each of the features.

Discussion

In the current release of Visual Studio 2013 there were a lot of new features made available. For this walk through we will be leveraging Visual Studio 2013 Update 4 and C#. The first big change that has come to Visual Studio is the addition of roaming settings. What exactly does this mean? As a developer I have a lot of personal preferences as to how my IDE is configured. What if I was asked to work on another machine? In the past we needed to reconfigure all those settings again. Fortunately not any more now we log in to Visual Studio with our profile and Visual Studio will automatically setup as per your previous configurations.

Roaming Profiles:

Start up Visual Studio 2013 you should see a screen similar to below. As you can see I am currently logged out of Visual Studio (Highlighted in red) click on this sign in link.

This will display the following login screen. In order to take advantage of roaming settings you will need to have a Microsoft account, which can easily be created from this page.

Once you have logged in. All the settings that you have on your profile will now be downloaded and Visual Studio’s theme will be updated. Additionally if you have not setup Visual Studio and changes you make to your IDE from this point forward will be synchronised to which ever Visual Studio 2013 and above you use. Below you can see my Visual Studio was updated with my preferred settings (yes I know its just a picture but it works I promise).

This is really a great feature for developers that work across multiple machines and if you reinstall your OS and want to setup your environment quickly. Now that we have logged in lets build a simple project that we can check out the other features with.

Setup for the other features:

Now we are going to look at the other features the best way to do this is to simply create a project. I am using a C# console application. See below:

Once we have the project created we have the usual Program.cs file and the program class.

Enhanced Scroll bar:

The next feature we are going to look at is the new scroll bar. In the static void main add the following erroneous line of code:

   1: Hello I am text;

This line of “code” isn't really a line of real code as we all know but it does help us demonstrate some of the new features.

Have a look at the area I have highlighted in red. There are three indicators now visible in your scroll bar. The first indicator is the Yellow Line, this shows where changes have occurred in the file since it was opened. The next indicator is the red line which shows where errors are. The last indicator is the white line that goes across the scroll bar which shows where the cursor is currently located. If I save the file the Yellow Line changes to green showing that this was a change since opening the file that has been saved. In summary:

• Red = Errors
• Yellow = Changes
• Green = Changes that have been saved
• While Line = Current Cursor position

That's not all we can see with the scroll bar, if you right click on it and select scroll bar options.

We are presented with all the customisations we can leverage for the scroll bar.

Here we can change what information is shown as also how the scroll bar works. Lets select the Use map mode option.

Now with the Map mode on I can see a smaller view of my code and if I mouse over any section of it a preview is displayed. This is a great feature for keeping track of code and navigating around a source file quickly. The next feature I am going to look at also involves navigation.

Navigate To:

When projects grow in size they become more and more difficult to locate specific information inside the solution. This is where the NavigateTo function comes in handy. This feature is accessed by pressing ctrl+, (control + comma) and shows a bar on the top right. In this input bar you can type what you are looking for and Visual Studio will search within your entire solution for any file that has that item and open to the appropriate location in the file.

Simply click on the most appropriate resolve and Visual studio will navigate you to the correct place. If you have text selected in your source file and press ctrl+, it will automatically populate the box with the selected text to help you find where else in the solution the text can be found.

The last feature we are going to look at is the Peek Definition.

Peek Definition:

Have you ever wanted to look at how a function in another file is implemented? Peek definition will give you an easy way of solving this problem. Lets delete the silly text we inserted into  the Main function. Insert the below code into the Main function in its place.

   1: Cat cat = new Cat("Bob", 16);

   2: cat.Meow();

   3: cat.Lives = 9; 

Obviously these classes don't exist. So lets create them quickly by putting the cursor on the type Cat and pressing ctrl +. (control + full stop) select generate class. This will automatically create the class for you. Now select the new Cat object and press ctrl + . again and generate the constructor. To finish off generate the stubs for both Meow() and Lives. We now have the option of opening the Cat.cs file but that would be the slow way. What we can do now is select any of the components of the Cat class and press Alt + F12. It will show the below screen:

This opens a preview / peek window with a view into the source code into Cat.cs code. This is a great feature for looking at other code inside of an application. You can also modify code inside of the window to make quick changes or open the file from the peek window if you want to have it available as a separate tab.

Conclusion

Visual Studio 2013 has a number of amazing features that help us be more productive. Why We are currently eagerly awaiting the release of VS 2015 which will have even more great features for developers. If there any specific features you would like me to cover in the next one please drop me a comment or send me a message through the blog.

References

What's New in Visual Studio 2013 [Online]
Available: http://msdn.microsoft.com/en-us/library/bb386063.aspx [20 January 2015]

Johan Ohlin (2013) 8 great features in Visual Studio 2013 [Online]
Available: http://www.codeproject.com/Articles/685332/great-features-in-Visual-Studio [20 January 2015]

Shateesh Averti (2013) Look at Enhanced Scrollbar in VS 2013 [Online]
Available: http://www.c-sharpcorner.com/Blogs/13546/look-at-enhanced-scrollbar-in-vs-2013.aspx [20 January 2015]

It was great seeing all the amazing developers across South Africa and we are looking forward to seeing you all again in November 2014.

Slides:

• ASP.Net WebAPI and SignalR
• ALM and the cloud
• Azure and Mobility
• Azure Service Bus

Code:

• ASP.Net WebAPI
• SignalR
• Service Bus

Abstract

This article will look into how to leverage the new Kinect for Windows 2.0 device to create a simple executive toy using Unity and the Unity plugin. The aim is to demonstrate how easy it is to leverage Kinect in your Unity projects and how to build some thing simple quickly. This is a step by step guide on how to great the Kinect Wall app and how it works.

Keywords: Unity3D, Kinect, Shaders, Cg, Geometry Shaders, Vertex Shaders, Fragment Shaders, Textures

Introduction

Research Method

I am taking a tutorial approach for this article where I will show you step by step how to build create the application. The application source code will be available on Codeplex free to use in anyway you like.

Requirements

• Unity 3d Pro – yes unfortunately because we are accessing unsafe code we need Pro
• Kinect SDK
• Kinect Unity Plugin

Tutorial

The first step is to start Unity and create a new Project. Give it a name and click create.

The next step is to do some minor admin in my project. The main thing I do here is create the following folders so I can manage my project a little neater:

• Materials
• Scripts
• Shaders
• Scenes
• Textures

Now we begin to setup some of the items we need to create to make this all work. We will need the following:

• Empty Material
• Scene – Main one with our camera, lights, etc
• Textures – These are textures we are going to use for our bricks
• Shader – This does all the depth and body index process as well as all the geometry generation
• Main Script – This spins up the Kinect device and passes information through to the Shader for processing.

We now need to add the Kinect for Windows v2 assets by going to the Assets –> Import Package –> Custom Package option and selecting the Kinect v2 Unity package. This will import all the required assets into the project so we can access the sensor. I need to enable unsafe code, the way that I do this is by adding a file called smcs.rsp to my Assets folder. This file is a simple text file with the single line inside of –unsafe.

Next we create the mainscript file and retrieve all the information from the sensor and pass it to the Shader. Inside the MainScript there are a number of default methods. Start which is used for initialisation and Update which is called as part of the update thread. Inside the Start function we are going to initialise the sensor and some of the storage structure for the stream of information. Firstly I create some local variables to store the sensor states:

   1: private KinectSensor sensor;

   2: private DepthFrameReader depthreader;

   3: private BodyIndexFrameReader bodyreader;

   4: private byte[] depthdata;

   5: private byte[] bodydata;

The KinectSensor object gives us access to the various data streams from the device. Because we want the outline of the player and the depth information we need to access to the DepthFrame and BodyIndex information.

   1: depthreader = sensor.DepthFrameSource.OpenReader();

   2: bodyreader = sensor.BodyIndexFrameSource.OpenReader();

We get the information from the reader in the update loop in the following manner

   1: var depthframe = depthreader.AcquireLatestFrame();

   2:  

   3: if (depthframe != null)

   4: {

   5:     fixed (byte* pData = depthdata)

   6:     {

   7:         depthframe.CopyFrameDataToIntPtr(new System.IntPtr(pData), (uint)depthdata.Length);

   8:     }

   9:     depthframe.Dispose();

  10:     depthframe = null;

  11:  

  12:     DepthTexture.LoadRawTextureData(depthdata);

  13:     DepthTexture.Apply();

  14: }

This will read the information into a byte array that I can then send to the Shader either through a Texture of via a ComputeBuffer. To kick start the shader I need to set all the parameters and then tell it to start drawing using the following:

   1: ShaderMaterial.SetTexture("_MainTex", MainTexture);

   2: ShaderMaterial.SetTexture("_DepthTex", DepthTexture);

   3: ShaderMaterial.SetFloat("_DepthWidth", DepthWidth);

   4: ShaderMaterial.SetFloat("_DepthHeight", DepthHeight);

   5: ShaderMaterial.SetBuffer("_BodyIndexBuffer", bodyIndexBuffer);

   6: ShaderMaterial.SetPass(0);

   7:     

   8: Graphics.DrawProcedural(MeshTopology.Points, WallWidth * WallHeight, 1);

We now have everything in the MainScript we need, to see the complete source code with both methods of getting data to a Shader as well as getting bodyindex information have a look at the codeplex source where the complete project is available.

Remember to save your scene scene into the scene folder. I then add some items to my scene the first is a few lights to provide a clean effect for the wall. The next is an empty game object (GameObject –> Create Empty /Ctrl-Shift-N). I now add my main script into my Scripts folder and select the mainScriptObject and drag the script onto it.

What I need to do now is create a shader and a material that will use this shader. Creating the shader first and then the material I then drag the material on to the mainScriptObject shader material property. Now we start looking at the shader. The shader will handle all the tile generation for my scene. I will be leveraging a geometry shader to perform all the object handling. The reason for this is mainly performance and processing for the textures will take too long outside of the shader.

The shader itself is below and I have commented as much of the code as possible to make it easy to understand. Currently the depth from the depth buffer isn't functioning as I had hoped and will post an update as soon as I have tweaked it.

   1: Shader "Custom/WallShader" {

   2:     Properties {

   3:         _MainTex ("Main Brick Texture", 2D) = "white" {}

   4:         _DepthTex ("Kinect Depth Image", 2D) = "white" {}

   5:         _DepthImageWidth("Depth Image Width",Float) = 100

   6:         _DepthImageHeight("Depth Image Height",Float) = 50          

   7:     }

   8:     SubShader {

   9:         Tags { "LightMode" = "ForwardBase" }            

  10:         Pass

  11:         {    

  12:             Cull Off            

  13:             LOD 200

  14:     

  15:             CGPROGRAM        

  16:                 #pragma vertex VS_Main

  17:                 #pragma geometry GS_Main            

  18:                 #pragma fragment FS_Main

  19:                 #include "UnityCG.cginc"                                

  20:                 

  21:                 uniform fixed4 _LightColor0;

  22:                 #define TAM 36

  23:  

  24:                 float MinDepthMM = 500.0;

  25:                 float MaxDepthMM = 8000.0;

  26:  

  27:                 float _DepthImageWidth;

  28:                 float _DepthImageHeight;                

  29:                 

  30:                 float4    _MainTex_ST;

  31:                 sampler2D _MainTex;

  32:  

  33:                 StructuredBuffer<float> _BodyIndexBuffer;

  34:                 StructuredBuffer<float> _DepthBuffer;

  35:                         

  36:                 // Structs for passing information from item to item

  37:                 struct EMPTY_INPUT

  38:                 {

  39:                 };

  40:  

  41:                 struct POSCOLOR_INPUT

  42:                 {

  43:                     float4    pos            : POSITION;

  44:                     float4  color        : COLOR;

  45:                     float2    uv_MainTex    : TEXCOORD0;

  46:                     float3    normal    : NORMAL;

  47:                 };

  48:                                 

  49:                 // Depth Helper function 

  50:                 float DepthFromPacked4444(float4 packedDepth)

  51:                 {

  52:                     // convert from [0,1] to [0,15]

  53:                     packedDepth *= 15.01f;

  54:     

  55:                     // truncate to an int

  56:                     int4 rounded = (int4)packedDepth;                

  57:     

  58:                     return rounded.w * 4096 + rounded.x * 256 + rounded.y * 16 + rounded.z;                

  59:                 }

  60:  

  61:                 

  62:                 EMPTY_INPUT VS_Main() 

  63:                 {

  64:                     return (EMPTY_INPUT)0;

  65:                 }

  66:  

  67:                  

  68:                 [maxvertexcount(TAM)]

  69:                 void GS_Main(point EMPTY_INPUT p[1], uint primID : SV_PrimitiveID, inout TriangleStream<POSCOLOR_INPUT> triStream)

  70:                 {                                                    

  71:                     float4 currentCoordinates = float4(primID % 100, (primID / 100), 0, 1.0);    

  72:                     

  73:                     float4 offset = float4(0,0,0,0);

  74:                     float4 scale = float4(1,1,1,0);

  75:                     float4 curcolor = float4(1,1,1,1);    

  76:  

  77:                     float depth = 0;

  78:                                         

  79:                     //TODO - Figure out best way to handle this // I suspect a compute shader would work                                                        

  80:                     float4 textureCoordinates = float4(currentCoordinates.x/100 * 512/4,currentCoordinates.y/50 * 424,0,0);

  81:  

  82:                     int index = (int)(textureCoordinates.x) + ((int)textureCoordinates.y * 512/4);

  83:                     int depthindex = (int)(textureCoordinates.x) + ((int)textureCoordinates.y * 512);

  84:                     float player = _BodyIndexBuffer[index];

  85:                     uint depthinfo = (uint)_DepthBuffer[depthindex] >> 3;

  86:                     

  87:                     // Get more depth information

  88:                     if(player > 0 && player < 1) 

  89:                     {                                                

  90:                         depth = -3;

  91:                         depth -= depthinfo * 3;                        

  92:                     }                            

  93:                                                             

  94:                      

  95:                     float f = 1.0;

  96:                     //Construct a cube

  97:  

  98:                     const float4 vc[TAM] = { 

  99:                         float4( -f,  f,  f, 1.0f), float4(  f,  f,  f, 1.0f), float4(  f,  f, -f, 1.0f),   //Top                                

 100:                         float4(  f,  f, -f, 1.0f), float4( -f,  f, -f, 1.0f), float4( -f,  f,  f, 1.0f),   //Top

 101:  

 102:                         float4(  f,  f, -f, 1.0f), float4(  f,  f,  f, 1.0f), float4(  f, -f,  f, 1.0f),   //Right

 103:                         float4(  f, -f,  f, 1.0f), float4(  f, -f, -f, 1.0f), float4(  f,  f, -f, 1.0f),   //Right

 104:  

 105:                         float4( -f,  f, -f, 1.0f), float4(  f,  f, -f, 1.0f), float4(  f, -f, -f, 1.0f),   //Front

 106:                         float4(  f, -f, -f, 1.0f), float4( -f, -f, -f, 1.0f), float4( -f,  f, -f, 1.0f),   //Front

 107:  

 108:                         float4( -f, -f, -f, 1.0f), float4(  f, -f, -f, 1.0f), float4(  f, -f,  f, 1.0f),   //Bottom                                         

 109:                         float4(  f, -f,  f, 1.0f), float4( -f, -f,  f, 1.0f), float4( -f, -f, -f, 1.0f),   //Bottom

 110:  

 111:                         float4( -f,  f,  f, 1.0f), float4( -f,  f, -f, 1.0f), float4( -f, -f, -f, 1.0f),   //Left

 112:                         float4( -f,  -f, -f, 1.0f), float4( -f, -f, f, 1.0f), float4( -f,  f,  f, 1.0f),   //Left

 113:  

 114:                         float4(  -f,  f,  f, 1.0f), float4( -f, f,  f, 1.0f), float4(  -f, -f,  f, 1.0f),   //Back

 115:                         float4(  f, -f,  f, 1.0f), float4(  -f, -f,  f, 1.0f), float4( -f,  f,  f, 1.0f)    //Back

 116:                     };

 117:  

 118:  

 119:                     const float2 UV1[TAM] = { 

 120:                         float2( 0.0f,    1.0f ), float2( 1.0f,   1.0f ), float2( 1.0f,   0.0f ),         

 121:                         float2( 1.0f,    0.0f ), float2( 0.0f,   0.0f ), float2( 0.0f,   1.0f ),         

 122:  

 123:                         float2( 0.0f,    1.0f ), float2( 1.0f,   1.0f ), float2( 1.0f,   0.0f ),         

 124:                         float2( 1.0f,    0.0f ), float2( 0.0f,   0.0f ), float2( 0.0f,   1.0f ), 

 125:  

 126:                         float2( 0.0f,    1.0f ), float2( 1.0f,   1.0f ), float2( 1.0f,   0.0f ),         

 127:                         float2( 1.0f,    0.0f ), float2( 0.0f,   0.0f ), float2( 0.0f,   1.0f ), 

 128:  

 129:                         float2( 0.0f,    1.0f ), float2( 1.0f,   1.0f ), float2( 1.0f,   0.0f ),         

 130:                         float2( 1.0f,    0.0f ), float2( 0.0f,   0.0f ), float2( 0.0f,   1.0f ), 

 131:  

 132:                         float2( 0.0f,    1.0f ), float2( 1.0f,   1.0f ), float2( 1.0f,   0.0f ),         

 133:                         float2( 1.0f,    0.0f ), float2( 0.0f,   0.0f ), float2( 0.0f,   1.0f ), 

 134:                         

 135:                         float2( 0.0f,    1.0f ), float2( 1.0f,   1.0f ), float2( 1.0f,   0.0f ),         

 136:                         float2( 1.0f,    0.0f ), float2( 0.0f,   0.0f ), float2( 0.0f,   1.0f )                        

 137:                         

 138:                     };                        

 139:  

 140:                     const int TRI_STRIP[TAM]  = {  0, 1, 2,  3, 4, 5,

 141:                         6, 7, 8,  9,10,11,

 142:                         12,13,14, 15,16,17,

 143:                         18,19,20, 21,22,23,

 144:                         24,25,26, 27,28,29,

 145:                         30,31,32, 33,34,35  

 146:                     }; 

 147:  

 148:  

 149:                     POSCOLOR_INPUT v[TAM];

 150:                     int i = 0;    

 151:  

 152:                     currentCoordinates.z = depth;

 153:  

 154:                     float3 lightdirection = normalize(_WorldSpaceLightPos0.xyz);

 155:                     float3 lightcolor = _LightColor0;

 156:                     // Assign new vertices positions 

 157:                     for (i=0;i<TAM;i++) {         

 158:                         float4 npos = float4(currentCoordinates.x, 50 - currentCoordinates.y,depth,1.0) * scale + offset;

 159:                         v[i].pos = npos + vc[i]; 

 160:                         v[i].color = curcolor;   

 161:                         v[i].uv_MainTex = TRANSFORM_TEX(UV1[i],_MainTex);                        

 162:                         v[i].normal = float3(0,0,0);

 163:                         v[i].pos = mul(UNITY_MATRIX_MVP, v[i].pos);

 164:                     }                                    

 165:                         

 166:                     // Build the cube tile by submitting triangle strip vertices

 167:                     for (i=0;i<TAM/3;i++)                    

 168:                     {                     

 169:                         //Calculate the normal of the triangle

 170:                         float4 U = v[TRI_STRIP[i*3+1]].pos - v[TRI_STRIP[i*3+0]].pos;

 171:                         float4 V = v[TRI_STRIP[i*3+2]].pos - v[TRI_STRIP[i*3+0]].pos;

 172:                         float3 normal = normalize(cross(U,V));

 173:                         float3 normaldirection = normalize( mul(float4(normal,1.0), _World2Object).xyz);

 174:                         float4 ncolor = float4(_LightColor0.xyz * v[TRI_STRIP[i*3+0]].color.rgb * max(0.0, dot(normaldirection, lightdirection)),1.0);

 175:  

 176:                         //Set the normal and the color based on the color

 177:                         v[TRI_STRIP[i*3+0]].normal = normal;

 178:                         v[TRI_STRIP[i*3+0]].color = ncolor;

 179:                         v[TRI_STRIP[i*3+1]].normal = normal;

 180:                         v[TRI_STRIP[i*3+1]].color = ncolor;

 181:                         v[TRI_STRIP[i*3+2]].normal = normal;

 182:                         v[TRI_STRIP[i*3+2]].color = ncolor;

 183:                         

 184:                         triStream.Append(v[TRI_STRIP[i*3+0]]);

 185:                         triStream.Append(v[TRI_STRIP[i*3+1]]);

 186:                         triStream.Append(v[TRI_STRIP[i*3+2]]);

 187:  

 188:                         triStream.RestartStrip();

 189:                     }                                        

 190:                 }

 191:  

 192:                 //Fragment Shader - with Lighting

 193:                 float4 FS_Main(POSCOLOR_INPUT input) : COLOR

 194:                 {                    

 195:                     half4 texcol = tex2D (_MainTex, input.uv_MainTex);

 196:  

 197:                     return texcol * input.color;                    

 198:                 }                

 199:  

 200:             ENDCG

 201:         }

 202:     } 

 203:     FallBack "Diffuse"

 204: }

With that all done you can now run your scene with the Kinect v2 Running and you should see the wall pushing out when you walk in front of it.

Video Link - https://www.youtube.com/watch?v=cFsPluBZn1s

Conclusion

Using Kinect v2 with Unity3D is extremely easy and the API’s are pretty much identical to the .Net API. Probably the biggest lesson is the benefit of using Shaders to handle the large volume of information between the various image streams you are receiving from the device.

Edit: I have uploaded the zip file of the complete project to codeplex.

Source Code

 https://sharpflipwall.codeplex.com

References

http://wiki.unity3d.com/index.php/Getting_Started_with_Shaders

http://www.bricksntiles.com/textures/

http://answers.unity3d.com/questions/744622/

http://johannes.gotlen.se/blog/2013/02/realtime-marching-cubes/

http://en.wikibooks.org/wiki/Cg_Programming/Unity

https://www.youtube.com/watch?v=bqKULvitmpU

When all the travelling began it was exciting and actually very much what was to be expected but the trick to working anywhere was connectivity. Skype, Google Talk, What’sApp, Telegram, QQ, Mxit, Lync, Facebook, Twitter, WeChat, Email, Yammer, VPN, DirectAccess and in tough times when connectivity is hard to find, plain text messaging all enable me to stay connected. Depending on the country WIFI coverage varies but you can always rely on good old fashioned Mobile networks, its easy to pickup a new SIM card and its definitely cheaper than roaming. Airports have a mobile store where you can get setup before stepping foot onto foreign soil and this should be your first port of call. 

Your gear bag is a trusty sidekick that holds everything you could possibly need while not at home or in the office. It would be difficult to say which are the most important items as I think this would differ from person to person. Currently in my bag:

• Laptop – Used for work, entertainment, and possibly a traditional weapon
• Camera – Used to record everything, I take photos like a damn tourist even at home
• USB Battery Pack x2 – Ensuring I always have power where ever I go
• Smart phone – this is probably the single most important item with GPS, email, etc
• Universal adapter – power power everywhere and damn I dislike the South African plug standard
• Tablet – this is great for watching movies, or just taking notes
• Note book – used for doodling, writing and killing hours during layovers when the Tablet, Laptop and everything else is dead
• Water bottle – always good to stay hydrated

The contents of the bags are important but the bag itself is also key, mine is light and comfortable for both carrying and sleeping on. For those moments your find yourself wanting to lay under a tree and work on your laptop it makes a great head rest.

Working from anywhere is an amazing experience, adding another dimension to your day. No more staring at a concrete wall or cubicles, how about looking out into a street in Paris, watching a waves crash while sitting on the patio, or in the Alps while it snows. If I see you out there say hello, even if I have my headphones on and look engrossed in work, part of the benefits is meeting new people.

Thanks to Elance and the Common Room for the Blogathon event.

www.the-common-room.co.za

www.elance.com