Question

我正在为我的工作编写一个简单但有用的OpenGL程序，其中包括显示矢量字段的外观。因此程序只需从文件中获取数据并绘制箭头。我需要绘制几千个箭头。我正在使用Qt for windows和OpenGL API。

箭头单位是圆柱体和圆锥体，在函数Arrow（）中组合在一起。

for(long i = 0; i < modifiedArrows.size(); i++) {
    glColor4d(modifiedArrows[i].color.redF(),modifiedArrows[i].color.greenF(),
        modifiedArrows[i].color.blueF(),modifiedArrows[i].opacity);
    openGLobj->Arrow(modifiedArrows[i].fromX,modifiedArrows[i].fromY,
        modifiedArrows[i].fromZ,modifiedArrows[i].toX,
        modifiedArrows[i].toY,modifiedArrows[i].toZ, 
        simulationSettings->vectorsThickness);
}

现在的问题是运行无限循环以继续绘制这会让CPU完全忙碌，这不太好。我尽可能地从paintGL（）函数中删除所有计算，只剩下简单的计算。我用glFlush（）和glFinish（）结束了paintGL（）函数，但我总是把主CPU充满。

如果我删除此循环，CPU不会再太忙了。但无论如何我必须画出数千支箭。

除了并行化之外，还有其他解决方案吗？

Answer 1

您没有指出如何实现openGLobj-＆gt; Arrow方法，但如果您在此使用100％CPU时间，则可能使用immediate mode绘制箭头。这实际上是CPU密集型的，因为你必须为glBegin（）和glEnd（）中的每一条指令将数据从CPU传输到GPU。如果您使用GLUT绘制数据，那么它也非常缺乏。

这里的方法是使用GPU内存和处理能力来汲取数据。 Phyatt已经指出了一些方向，但我会尝试更具体：使用Vertex Buffer Object (VBO)。

我们的想法是预先分配所需的内存，以便在GPU上显示您的数据，并在需要时更新这块内存。这可能会对代码的效率产生巨大影响，因为您将使用高效的视频卡驱动程序来处理CPU-＆gt; GPU传输。

为了说明这个概念，我将在答案的最后向您展示一些伪代码，但这绝不是完全正确的。我没有测试它，也没有时间为你实现绘图，但这是一个可以澄清你的想法的概念。

class Form
{
    public:
    Form()
    {
        // generate a new VBO and get the associated ID
        glGenBuffers(1, &vboId);

        // bind VBO in order to use
        glBindBuffer(GL_ARRAY_BUFFER, vboId);

        //Populate the buffer vertices.
        generateVertices();

        // upload data to VBO
        glBufferData(GL_ARRAY_BUFFER_ARB, vertices.size(), vertices.data(), GL_STATIC_DRAW_ARB);
    }

    ~Form()
    {
        // it is safe to delete after copying data to VBO
        delete [] vertices;

        // delete VBO when program terminated
        glDeleteBuffersARB(1, &vboId);
    }

    //Implementing as virtual, because if you reimplement it on the child class, it will call the child method :)
    //Generally you will not need to reimplement this class
    virtual void draw()
    {
        glBindBuffer(GL_ARRAY_BUFFER, vboId);
        glEnableClientState(GL_VERTEX_ARRAY);           
        glVertexPointer(3, GL_FLOAT, 0, 0);

        //I am drawing the form as triangles, maybe you want to do it in your own way. Do it as you need! :)
        //Look! I am not using glBegin() and glEnd(), I am letting the video card driver handle the CPU->GPU 
        //transfer in a single instruction!
        glDrawElements(GL_TRIANGLES, vertices.size(), GL_UNSIGNED_BYTE, 0);

        glDisableClientState(GL_VERTEX_ARRAY);

        // bind with 0, so, switch back to normal pointer operation
        glBindBufferARB(GL_ARRAY_BUFFER_ARB, 0);
    }

private:
    //Populate the vertices vector with the form vertices.
    //Remember, any geometric form in OpenGL is rendered as primitives (points, quads, triangles, etc).
    //The common way of rendering this is to use multiple triangles.
    //You can draw it using glBegin() and glEnd() just to debug. After that, instead of rendering the triangles, just put
    //the generated vertices inside the vertices buffer.
    //Consider that it's at origin. You can use push's and pop's to apply transformations to the form.
    //Each form(cone or cilinder) will have its own way of drawing.
    virtual void generateVertices() = 0;

    GLuint vboId; 
    std::vector<GLfloat> vertices;
}

class Cone : public Form
{
public:
    Cone() : Form() {}
    ~Cone() : ~Form() {}

private:
    void generateVertices()
    {
        //Populate the vertices with cone's formula. Good exercise :)
        //Reference: http://mathworld.wolfram.com/Cone.html
    }

    GLuint vboId; 
    std::vector<GLfloat> vertices;
}

class Cilinder : public Form
{
public:
    Cone() : Form() {}
    ~Cone() : ~Form() {}

private:
    void generateVertices()
    {
        //Populate the vertices with cilinders's formula. Good exercise :)
        //Reference: http://math.about.com/od/formulas/ss/surfaceareavol_3.htm
    }

    GLuint vboId; 
    std::vector<GLfloat> vertices;
}


class Visualizer : public QOpenGLWidget
{
public:
    //Reimplement the draw function to draw each arrow for each data using the classes below.
    void updateGL()
    {
        for(uint i = 0; i<data.size(); i++)
        {
            //I really don't have a clue on how you position your arrows around your world model.
            //Keep in mind that those functions glPush, glPop and glMatrix are deprecated. I recommend you reading
            //http://duriansoftware.com/joe/An-intro-to-modern-OpenGL.-Chapter-3:-3D-transformation-and-projection.html if you want to implement this in the most efficient way.
            glPush();
                glMatrix(data[i].transform());
                cilinder.draw();
                cone.draw();
            glPop();
        }
    }

private:
    Cone cone;
    Cilinder cilinder;
    std::vector<Data> data;
}

作为最后一点，我不能向你保证这是最有效的做事方式。也许，如果您有大量数据，则需要一些数据结构，如Octrees或scene-graphs来优化您的代码。

我建议您查看OpenSceneGraph或Visualization ToolKit，看看这些方法是否已经为您实施，这将为您节省大量时间。

Answer 2

尝试此链接以获取一些想法：

What are some best practices for OpenGL coding (esp. w.r.t. object orientation)?

基本上我所看到的是人们为提高他们的FPS和降低质量所做的事情包括以下内容：

使用DisplayLists。（缓存复杂或重复的矩阵堆栈）。
使用顶点阵列。
使用面部较少的简单几何体。
使用更简单的灯光。
使用更简单的纹理。

OpenGL的主要优点是可以与许多显卡配合使用，这些显卡可以非常快速地进行大量的4x4矩阵变换，乘法等，并且可以提供更多的RAM内存来存储渲染或部分渲染对象。

假设所有向量都发生了很大变化，并且经常无法缓存任何渲染...

我解决这个问题的方法是将绘图简化为线条和点，然后以所需的帧速率绘制。（圆柱的一条线和方向末端的彩色点。）

在绘制得足够快之后，尝试使绘图更复杂，如矩形棱镜而不是线条，以及金字塔而不是彩色点。

圆形对象通常需要更多的曲面和计算。

我不是这方面的专家，但我会谷歌其他处理优化的OpenGL教程。

希望有所帮助。

编辑：由于评论，删除了对NeHe教程的引用。

使用OpenGL绘图而不会杀死CPU而不进行并行化

2 个答案: