使用OpenGL绘图，无需占用CPU，也无需并行化

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);
}

您没有指出如何实现openGLobj->Arrow方法，但如果您在这方面使用了100%的CPU时间，那么您可能正在使用即时模式绘制箭头。这确实是CPU密集型的，因为对于glBegin（）和glEnd（）中的每一条指令，都必须将数据从CPU传输到GPU。如果你正在使用GLUT来绘制你的数据，它也确实是不够的。

这里的方法是使用GPU内存和处理能力来挖掘数据。Phyatt已经为您指明了一些方向，但我将尝试更具体地说：使用顶点缓冲区对象（VBO）。

这个想法是预先分配在GPU上显示数据所需的内存，并在需要时更新这一块内存。这可能会对代码的效率产生巨大的影响，因为你将使用高效的视频卡驱动程序来处理CPU->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;
} 

最后，我不能向你保证这是最有效的做事方式。也许，如果你有大量的数据，你需要一些数据结构，比如八叉树或场景图来优化你的代码。

我建议你看看OpenSceneGraph或可视化工具包，看看这些方法是否还没有为你实现，这会为你节省很多时间。

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

• OpenGL编码（特别是面向对象）的一些最佳实践是什么

基本上，我看到人们为了提高FPS和降低质量所做的事情包括：

• 使用DisplayLists。（缓存复杂或重复的矩阵堆栈）。

• 使用顶点阵列。

• 使用面较少的更简单的几何体。

• 使用更简单的照明。

• 使用更简单的纹理。

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

假设所有向量都在频繁变化，以至于无法缓存任何渲染。。。

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

在画得足够快之后，试着让画得更复杂，比如用矩形棱镜代替直线，用金字塔代替彩色点。

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

我不是这方面的专家，但我会在谷歌上搜索其他涉及优化的OpenGL教程。

希望能有所帮助。

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