如何使用GPU绘制OpenGL像素

Question

I'm making a Powder Toy that makes use of Parallel Processing to do the game physics, its dealing with a 500 x 500 area of powder. The game does mostly everything with the particles on the GPU but it uses the CPU to render the particles (decreases speed by a lot). How would I render the particles on the GPU instead of the CPU? I'm mostly keeping my particle data on the GPU because most of the operations happen there, and cudaMemcpy is quite slow, making by project uncontrollably lag when its on host memory.


Here's my display function

void display()
{
    // Measure performance
    mainloopMeasurePerformanceStart(1);

    // Clear the screen
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    // Copy particle data to render
    cudaMemcpy(&particles, d_particles, sizeof(particles), cudaMemcpyDeviceToHost);

    // Loop over the sand particles
    for(int i=0;i<250000;i++)
    {
        // Is the sand particle alive
        if(particles[i].alive)
        {
            // Get the position
            int pos[2];
            id_to_pos(i,pos);

            // Draw the pixel
            glColor3f(particles[i].color[0],particles[i].color[1],particles[i].color[2]);
            glBegin(GL_QUADS);
                glVertex2d((pos[0]/500.0-0.5)*2,(pos[1]/500.0-0.5)*2);
                glVertex2d((pos[0]/500.0-0.5+0.002)*2,(pos[1]/500.0-0.5)*2);
                glVertex2d((pos[0]/500.0-0.5+0.002)*2,(pos[1]/500.0-0.5+0.002)*2);
                glVertex2d((pos[0]/500.0-0.5)*2,(pos[1]/500.0-0.5+0.002)*2);
            glEnd();
        }
    }

    // Get the mouse position
    int m_posX, m_posY;
    mousePos(&m_posX, &m_posY);

    // Draw the cursor
    glColor3f(1.0f, 1.0f, 1.0f);
    for(int i=0;i<360;i++)
    {
        // Calculate the position
        double pos[2];
        pos[0] = sin(2*PI/360*i)*cursor_radius+m_posX;
        pos[1] = cos(2*PI/360*i)*cursor_radius+m_posY;

        glBegin(GL_QUADS);
            glVertex2d((pos[0]/500.0-0.5)*2,(pos[1]/500.0-0.5)*2);
            glVertex2d((pos[0]/500.0-0.5+0.002)*2,(pos[1]/500.0-0.5)*2);
            glVertex2d((pos[0]/500.0-0.5+0.002)*2,(pos[1]/500.0-0.5+0.002)*2);
            glVertex2d((pos[0]/500.0-0.5)*2,(pos[1]/500.0-0.5+0.002)*2);
        glEnd();
    }

    // Swap the front and back frame buffers
    glutSwapBuffers();

    // Measure performance
    mainloopMeasurePerformanceEnd();
}

And where the processing for the sand happens:

__global__ void do_sand(
    Sand *particles, bool *mouseStates, unsigned long seed,
    int m_pos_x, int m_pos_y, double cursor_radius
){
    // Get the overall ID
    int id = blockIdx.x*100+threadIdx.x;

    // Convert the ID to a position
    int pos[2];
    id_to_pos(id,pos);

    // Convert the mouse position to an array
    int m_pos[2];
    m_pos[0] = m_pos_x;
    m_pos[1] = m_pos_y;

    // Is the sand particle alive
    if(particles[id].alive)
    {
        // Is there sand being cleared and is this particle in range
        if(mouseStates[GLUT_RIGHT_BUTTON] && distance_between(pos, m_pos) < cursor_radius)
        {
            // Delete this particle
            particles[id].alive = false;
        }

        // Do physics
        bool done = false;
        int check;

        switch(particles[id].model)
        {
            // Powder
            case 'P':
            {
                // Is vertical movement valid
                if(pos[1]-1 >= 0 && !done)
                {
                    // Get the ID
                    check = pos_to_id(pos[0], pos[1]-1);

                    // Is this space free
                    if(!particles[check].alive)
                    {
                        // Move the particle
                        particles[check] = particles[id];
                        particles[id].alive = false;
                        done = true;
                    }
                }

                // Randomly pick the sands course
                int choice;
                if((seed * id * 5423) % 2 == 0) choice=1;
                else choice=-1;

                // Check left movement
                if(pos[0]-choice < 500 && pos[0]-choice >= 0 && pos[1]-1 >= 0 && !done)
                {
                    // Get the ID
                    check = pos_to_id(pos[0]-choice,pos[1]-1);

                    // Is this space free
                    if(
                        !particles[check].alive &&
                        !particles[pos_to_id(pos[0]-choice,pos[1])].alive &&
                        !(
                            particles[pos_to_id(pos[0]-choice*2,pos[1])].alive &&
                            particles[pos_to_id(pos[0]-choice*2,pos[1]-1)].alive
                        )
                    ){
                        // Move the particle
                        particles[check] = particles[id];
                        particles[id].alive = false;
                        done = true;
                    }
                }

                // Check right movement
                if(pos[0]+choice < 500 && pos[0]+choice >= 0 && pos[1]-1 >= 0 && !done)
                {
                    // Get the ID
                    check = pos_to_id(pos[0]+choice,pos[1]-1);

                    // Is this space free
                    if(
                        !particles[check].alive &&
                        !particles[pos_to_id(pos[0]+choice,pos[1])].alive &&
                        !(
                            particles[pos_to_id(pos[0]+choice*2,pos[1])].alive &&
                            particles[pos_to_id(pos[0]+choice*2,pos[1]-1)].alive
                        )
                    ){
                        // Move the particle
                        particles[check] = particles[id];
                        particles[id].alive = false;
                        done = true;
                    }
                }
            }

            // Fluid
            case 'F':
            {

            }
        }
    }

    // Is there sand being added and is this particle in range
    else if(mouseStates[GLUT_LEFT_BUTTON] && distance_between(pos, m_pos) < cursor_radius)
    {
        // Make this particle
        particles[id].alive = true;
        particles[id].color[0] = 0.0f;
        particles[id].color[1] = 0.0f;
        particles[id].color[2] = 0.6f;
        particles[id].model = 'P';
    }
}

Answer 1

Since it was first released, CUDA has had support for OpenGL interoperability (Direct3D also). It is well documented , and if you have installed the CUDA examples, you have several compete sample codes you can study.

In short, you can map an existing OpenGL buffet object into the CUDA address space so that a compute kernel can read and write to the OpenGL memory, release the memory from CUDA, and then render from that CUDA modified buffer as normal. There are significant overheads in doing this, but performance may still be better than copying data to the host for rendering.

As suggested, you can read a thorough introduction in this Nvidia supplied presentation.

Answer 2

I worked out how to create textures and render them using CUDA for extra speed, if I create an array of bytes (could also be int or something else) and upload the RGB values using 3 values (or RGBA using 4 values) positioned after each other to form an image I can load it into OpenGL.

GLubyte data[width*height*3] = {
    R, G, B,
    R, G, B,
    R, G, B
}

As talonmies mentioned I could have used an OpenGL buffer object but an image seems to work for displaying each individual pixel on the screen, and I was having trouble finding information about buffer objects online.

// Setup the pixel varibles
GLubyte *pixels = new GLubyte[sxy[0]*sxy[1]*3]();

// Get the mouse pos
int m_x, m_y;
mousePos(&m_x,&m_y);

// Render on CPU
if(cpu_only) render_pixels_cpu(
    particles,pixels,sxy,
    m_x,m_y,cursor_radius
);

else
{
    // Load the pixels on the GPU
    int N = 512;
    render_pixels<<<2048,N>>>(
        N,d_particles,d_pixels,
        d_sxy,m_x,m_y,cursor_radius
    );

    // Copy the pixel data over
    cudaMemcpy(pixels, d_pixels, sizeof(GLubyte)*sxy[0]*sxy[1]*3, cudaMemcpyDeviceToHost);
}

// Generate and bind the texture
GLuint tex;
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGB, sxy[0], sxy[1], 0, GL_RGB, GL_UNSIGNED_BYTE, pixels );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );

// Free the pixels
delete pixels;

// Draw quads
glBegin(GL_QUADS);
    glTexCoord2d( 0.0, 0.0);    glVertex2d(-1.0,-1.0);
    glTexCoord2d( 1.0, 0.0);    glVertex2d( 1.0,-1.0);
    glTexCoord2d( 1.0, 1.0);    glVertex2d( 1.0, 1.0);
    glTexCoord2d( 0.0, 1.0);    glVertex2d(-1.0, 1.0);
glEnd();

// Unbind the texture
glBindTexture(GL_TEXTURE_2D, NULL);

// Delete the texture
glDeleteTextures(1, &tex);

__global__ void render_pixels(
    int N, Sand* particles, GLubyte* pixels, int* sxy,
    int m_x, int m_y, double m_radius
){
    // Get the overall ID
    int id = blockIdx.x*N+threadIdx.x;

    // Return if out of range
    if(i>sxy[0]*sxy[1])return;

    // Get the position
    int pos[2];
    id_to_pos(i,pos,sxy);

    // Calculate the image id
    int id = (pos[1]*sxy[0])+pos[0];

    // Convert the mouse pos to a position
    int mpos[2] = {m_x, m_y};

    // Calculate the distance
    double distance = distance_between(pos, mpos);

    // Is the position in range with the mouse
    if((int)distance==(int)m_radius&&m_x>-1&&m_y>-1)
    {
        // Create a circle here
        pixels[(id*3)+0] = (GLubyte)255;
        pixels[(id*3)+1] = (GLubyte)255;
        pixels[(id*3)+2] = (GLubyte)255;
    }

    else
    {
        // Set the colours
        pixels[(id*3)+0] = (GLubyte)(particles[i].color[0]*255);
        pixels[(id*3)+1] = (GLubyte)(particles[i].color[1]*255);
        pixels[(id*3)+2] = (GLubyte)(particles[i].color[2]*255);
    }
}