Introducing OpenGL array handle which allows OpenGL interoperability.

ArrayHandleOpenGL now allows the user to automatically write to OpenGL,
rather than having to manually copy the values of an ArrayHandle.
In the case of DeviceAdapter that use host/control memory the OpenGL
code uses GlSubBufferData to easily copy the results into OpenGL.
In the case of CUDA, we directly reference the OpenGL allocated
memory and pass that to the worklets for writing.

This is the first pass at OpenGL memory being used inside Dax,
so for know you can only write out to OpenGL. You are unable to
bring memory from OpenGL back in. In the future I want to be
able to extend this work to allow reading OpenGL arrays.
ArrayHandleOpenGL can map to different openGL buffer types,
but you must set the type when constructing the ArrayHandle.

If you don't set the type explicitly Dax will attempt to guess
what type is best based on the primitive type you passed in.
If you have passed in a integer or unsigned int we will presume
that you want a GL_ELEMENT_ARRAY_BUFFER, otherwise we presume
that you want a GL_ARRAY_BUFFER

To safely render the buffer object that an ArrayHandle holds
you need to explicitly call one of the following functions:
  GetPortalControl()
  GetPortalConstControl()
  ReleaseResourcesExecution()
The portal returned by the first two has everything you need
(Handle,Type,Length) to draw something with the buffers data

The ArrayHandle holds onto the openGL buffer handle, so when
the ArrayHandle goes out of scope, so will the openGL buffer,
this also goes for CUDA Device Adapter.

Each time you call a worklet with an openGL array handle we will
call glBufferData and detach the handle from any gpu memory, so
don't expect to be able to pass a openGL handle to multiple worklets
and get a combined result currently.

Here is an example:
  {
  //create a buffer object of type GL_ARRAY_BUFFER
  dax::cont::ArrayHandleOpenGL<dax::Vector3> example;
  //this will bind the GL_ARRAY_BUFFER buffer object as the current
  //buffer object, and setup its size.
  scheduler.Invoke( dax::worklet::Normals(), triangles, example);
  //This has to be called to allow the buffer object to be used
  //for drawing.
  typedef  dax::cont::ArrayHandleOpenGL<dax::Vector3>::PortalControl PC;
  PC portal = example.GetPortalControl();
  //now you can draw something
  drawSomething(portal.GetHandle());
  //this will detach the handle from the previous gpu memory
  //allowing you to do more work without blocking the rendering
  scheduler.Invoke( dax::worklet::Normals(), triangles, example);
  } //releases the buffer object memory in OpenGL
Correct a major bug in UniformGrid point container.

I have no idea how I missed this bug, when I introduced it. But
the previous code only worked when origin was at 0,0,0.
Correct the removing of duplicate points to use basic array container.

We should always use the basic array container for intermediate
steps, as we don't know the performance characteristics of the
user given one.
Add in benchmark that verifies openGL interop works.