Converting the N-Body C tutorial

int[] MeshHeight = new int[1];
MeshHeight[0] = 8*64;
 
 ComputeBuffer<int> mMeshHeight = new ComputeBuffer<int>(context, ComputeMemoryFlags.WriteOnly, MeshHeight);

 
//How to convert this c++ statement into Cloo.NET?
vbo_cl = clCreateFromGLBuffer(cxGPUContext, CL_MEM_WRITE_ONLY, *vbo, NULL);
 
//One possibility I can think of, however, what it the right <T> for the statemetn below? (int[] vbo = new vbo[1])
ComputeBuffer<T>.CreateFromGLBuffer<T>(cxGPUContext, ComputeMemoryFlags.WriteOnly, vbo[0]);

//Given (unsigned int VboSize = mesh_width * mesh_height * 4 * sizeof(float);)
 
IntPtr mVBOSize = new IntPtr(VboSize);
 
                //Which of the below statemetns is correct or there are interchangable?
                 kernel.SetMemoryArgument(0,mVBO);
 
                 kernel.SetArgument(0,mVBOSize , mVBO);

 
cl_mem vbo_cl;
 
 // Create VBO
//*****************************************************************************
void createVBO(GLuint* vbo)
{
    // create VBO
    unsigned int size = mesh_width * mesh_height * 4 * sizeof(float);
    if(!bQATest)
    {
        // create buffer object
        glGenBuffers(1, vbo);
        glBindBuffer(GL_ARRAY_BUFFER, *vbo);
 
        // initialize buffer object
        glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW);
 
        #ifdef GL_INTEROP
            // create OpenCL buffer from GL VBO
            vbo_cl = clCreateFromGLBuffer(cxGPUContext, CL_MEM_WRITE_ONLY, *vbo, NULL);
        #else
            // create standard OpenCL mem buffer
            vbo_cl = clCreateBuffer(cxGPUContext, CL_MEM_WRITE_ONLY, size, NULL, &ciErrNum);
        #endif
    }
    else 
    {
        // create standard OpenCL mem buffer
        vbo_cl = clCreateBuffer(cxGPUContext, CL_MEM_WRITE_ONLY, size, NULL, &ciErrNum);
    }
}

                //Create OpenCLOpenGL Interop Context
                IntPtr curDC = wglGetCurrentDC();
 
                OpenTK.Graphics.IGraphicsContextInternal ctx = (OpenTK.Graphics.IGraphicsContextInternal)OpenTK.Graphics.GraphicsContext.CurrentContext;
 
                IntPtr raw_context_handle = ctx.Context.Handle;
 
                ComputeContextProperty p1 = new ComputeContextProperty(ComputeContextPropertyName.CL_GL_CONTEXT_KHR, raw_context_handle);
                ComputeContextProperty p2 = new ComputeContextProperty(ComputeContextPropertyName.CL_WGL_HDC_KHR, curDC);
                ComputeContextProperty p3 = new ComputeContextProperty(ComputeContextPropertyName.Platform, ComputePlatform.Platforms[0].Handle);
                List<ComputeContextProperty> props = new List<ComputeContextProperty>() { p1, p2, p3 };
 
                ComputeContextPropertyList Properties = new ComputeContextPropertyList(props);
cxGPUContext = new ComputeContext(ComputeDeviceTypes.Gpu, Properties, null, IntPtr.Zero);

           //continue from previous upper codes
 
            CreateVBO();
 
             kernel = program.CreateKernel("sine_wave");
            mWidth = new ComputeBuffer<int>(cxGPUContext, ComputeMemoryFlags.WriteOnly, meshWidth);  //meshWidth = 256
            mHeight = new ComputeBuffer<int>(cxGPUContext, ComputeMemoryFlags.WriteOnly, meshHeight);//meshWidth = 256
 
            kernel.SetMemoryArgument(0,mVbo);   //created in CreateVBO();
            kernel.SetMemoryArgument(1, mWidth);
            kernel.SetMemoryArgument(2, mHeight);
 
            cqCommandQueue = new ComputeCommandQueue(cxGPUContext, cxGPUContext.Devices[0], ComputeCommandQueueFlags.None);

private void createVBO()
{
            if (vbo[0] != 0)
            {
                GL.DeleteBuffers(1, ref vbo[0]);
                vbo[0] = 0;
            }
 
            GL.GenBuffers(1, out vbo[0]);
 
            GL.BindBuffer(BufferTarget.ArrayBuffer, vbo[0]);
            vboSize = meshWidth* meshHeight * 4 * sizeof(float);   //int vobSize
            vboMemSize = Marshal.AllocHGlobal((int)vboSize);       //intPtr vboMemSize
 
            GL.BufferData(BufferTarget.ArrayBuffer, vboMemSize, IntPtr.Zero, BufferUsageHint.DynamicDraw);
 
                if (GL_Interop)
                {
                     //ComputeBuffer<int> mVbo
                    mVbo= ComputeBuffer<int>.CreateFromGLBuffer<int>(cxGPUContext, ComputeMemoryFlags.WriteOnly, vbo[0]);
                }
                else
                {
                    mVbo= new ComputeBuffer<int>(cxGPUContext, ComputeMemoryFlags.WriteOnly, vbo[0]); 
                }
            }
        }

        protected override void OnRenderFrame(FrameEventArgs e)
        {
                      // run OpenCL kernel to generate vertex positions
                       runKernel();
 
                      //rest of the OpenTK codes  for rendering the sineWave using vertex positions generated by OpenCL kernel
         }

private void runKernel()
 {
 
            if (GL_Interop)
            {
                GL.Finish();
                List<ComputeMemory> c = new List<ComputeMemory>() { mVbo };     //ComputeBuffer<int> to vbo[0]
                cqCommandQueue.AcquireGLObjects(c, null);
            }
            unsafe
            {
                fixed (float* anim = &animationState[0])   //float animationState = 0.0f;
                {
                    IntPtr animPointer = new IntPtr((void*) anim);
                    kernel.SetArgument(3, new IntPtr(sizeof(float)), animPointer);
                }
            }
            globalWorkSize = new long[2];
            globalWorkSize[0] = meshWidth;
            globalWorkSize[1] = meshHeigh;
 
            cqCommandQueue.Execute(kernel, null, globalWorkSize, null, null);
 
            if (GL_Interop)
            {
                    cqCommandQueue.ReleaseGLObjects(c, null);
                    cqCommandQueue.Finish(); //ERROR ==> ComputeErrorCode = outofResource
            }
            else
            {
                GL.BindBuffer(BufferTarget.ArrayBuffer, vbo[0]);
                IntPtr pointer = GL.MapBuffer(BufferTarget.ArrayBuffer, BufferAccess.WriteOnly);
                long vboSize = meshWidth*meshHeigh*4*sizeof(float);
 
                cqCommandQueue.Read<int>(mVbo, true, 0, vboSize, pointer, null);//ERROR ==> ComputeErrorCode = InvalidValue
 
                GL.UnmapBuffer(BufferTarget.ArrayBuffer);
            }
        }

               if (GL_Interop)
                {
                     //ComputeBuffer<float> mVbo
                    mVbo= ComputeBuffer<float>.CreateFromGLBuffer<float>(cxGPUContext, ComputeMemoryFlags.WriteOnly, vbo[0]);
                }
                else
                {
//change last arg:
                    mVbo= new ComputeBuffer<float>(cxGPUContext, ComputeMemoryFlags.WriteOnly, /*not vbo[0] but*/ numberOfElementsInVBO); 
                }