title: Cuda and OpenGL Interop
body: <p>I've been reading through the CUDA documentation and it seems to me, that every buffer that needs to interface with OpenGL needs to be created in the glBuffer. </p>
  
  <p>According to the nvidia programming guide, this has to be done like this:</p>
  
  <pre><code>GLuint positionsVBO;
  struct cudaGraphicsResource* positionsVBO_CUDA;
  
  int main() {
  
      // Explicitly set device
      cudaGLSetGLDevice(0);
      // Initialize OpenGL and GLUT
      ...
      glutDisplayFunc(display);
      // Create buffer object and register it with CUDA
      glGenBuffers(1, positionsVBO);
      glBindBuffer(GL_ARRAY_BUFFER, &amp;vbo);
      unsigned int size = width * height * 4 * sizeof(float);
      glBufferData(GL_ARRAY_BUFFER, size, 0, GL_DYNAMIC_DRAW);
      glBindBuffer(GL_ARRAY_BUFFER, 0);
      cudaGraphicsGLRegisterBuffer(&amp;positionsVBO_CUDA, positionsVBO, cudaGraphicsMapFlagsWriteDiscard);
  
      // Launch rendering loop
      glutMainLoop();
  }
  void display() {
      // Map buffer object for writing from CUDA
      float4* positions;
      cudaGraphicsMapResources(1, &amp;positionsVBO_CUDA, 0);
      size_t num_bytes;
      cudaGraphicsResourceGetMappedPointer((void**)&amp;positions, &amp;num_bytes, positionsVBO_CUDA));
      // Execute kernel
      dim3 dimBlock(16, 16, 1);
      dim3 dimGrid(width / dimBlock.x, height / dimBlock.y, 1);
      createVertices&lt;&lt;&lt;dimGrid, dimBlock&gt;&gt;&gt;(positions, time, width, height);
      // Unmap buffer object
      cudaGraphicsUnmapResources(1, &amp;positionsVBO_CUDA, 0);
      // Render from buffer object
      glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
      glBindBuffer(GL_ARRAY_BUFFER, positionsVBO);
      glVertexPointer(4, GL_FLOAT, 0, 0);
      glEnableClientState(GL_VERTEX_ARRAY);
      glDrawArrays(GL_POINTS, 0, width * height);
      glDisableClientState(GL_VERTEX_ARRAY);
      // Swap buffers
      glutSwapBuffers();
      glutPostRedisplay();
  }
  void deleteVBO() {
      cudaGraphicsUnregisterResource(positionsVBO_CUDA);
      glDeleteBuffers(1, &amp;positionsVBO);
  }
  
  __global__ void createVertices(float4* positions, float time, unsigned int width, unsigned int height) { 
      // [....]
  }
  </code></pre>
  
  <p>Is there a way to give the cudaMalloc created memory space directly to OpenGL? I've got already working code written on cuda and I want to put my float4 array directly into OpenGL. </p>
  
  <p>Say if've got already code like:</p>
  
  <pre><code>float4 *cd = (float4*) cudaMalloc(elements*sizeof(float4)). 
  do_something&lt;&lt;&lt;16,1&gt;&gt;&gt;(cd);
  </code></pre>
  
  <p>And I wanted to display the output of do_something through OpenGL.</p>
  
  <p>Side note: why is the cudaGraphicsResourceGetMappedPointer function run on every timestep?</p>