在OpenCL内核中使用OpenGL

Question

Is there any way to use OpenGL methods when using OpenCL kernels? I would like to vectorize my voxel-based alogorithm using GPGPU. To give a simple exmaple a paste the current code of my algorithm and maybe somebody could help me with this issue.

for(int x = 0; x < voxelWorld->getVoxelsX(); x++)
    for(int y = 0; y < voxelWorld->getVoxelsY(); y++)
        for(int z = 0; z < voxelWorld->getVoxelsZ(); z++)
        {
            glPushMatrix();
            glTranslatef((x - voxelWorld->offsetX())*voxelWorld->getVoxelSize(),
                         (y - voxelWorld->offsetY())*voxelWorld->getVoxelSize(),
                         (z - voxelWorld->offsetZ())*voxelWorld->getVoxelSize());
            if(this->doRenderWireframeWorld)
            {
                glDisable(GL_LIGHTING);
                glColor3f(1.0f, 1.0f, 1.0f);
                this->renderVoxel(false);
                glEnable(GL_LIGHTING);
            }

            if(voxelWorld->getVoxel(x, y, z) && this->doRenderVoxels)
            {
                glColor3f(0.0f, 1.0f, 0.0f);
                this->renderVoxel(true);
            }
            glPopMatrix();
        } 

I know that there should be only one loop instead of three nested loops. So I would change the code a little bit to:

for(int i = 0; i < voxelWorld->getVoxelsX() * voxelWorld->getVoxelsY() * voxelWorld->getVoxelsZ(); i++)

It would be a good start to pass the data to the OpenCL kernel, but what now? I would like to do the rendeing inside OpenCL kernel (all the glPushMatrix , glEnable ) but I assume it is impossible. Does anybody have any expericence doing such things?

Answer 1

Rendering with OpenGL is already parallelized by the GPU, you don't have to do anything further to it than just make the OpenGL drawing calls. The OpenGL implementation queues them into batches sent to the GPU, the GPU will process vertices and fragments in parallel (because that's what GPUs do).

Of course to really unleash the power of the GPU you must stop starving it by using the deprecated, old fashioned, outdated, discarded immediate mode. Ie don't use glBegin, glVertex, glEnd. Use Vertex Arrays contained in Vertex Buffer Objects.

(Full disclosure: If you'd use Display Lists you could make use of GPUs parallelization power even using immediate mode. But this is not recommended for new programs.)