0

私はここ数週間VBOを学んでいますが、ここでVBOは「数百fpsで約100万の頂点」をレンダリングできると言われています。ただし、現在のVBOテストプログラムでは、レンダリングする頂点が100万個弱で、約50FPSしか得られません。VBOの効率を最適化する方法はありますか？または、おそらく、私は何か間違ったことをしていますか？私のテストプログラムはここにあります：

編集：フィードバックに基づいてコードを改善しました。

#include <windows.h>
#include <SFML/Graphics.hpp>
#include <iostream>

#include <glew.h>
#include <gl/gl.h>
#include <gl/glu.h>

using namespace std;

float cube_vertices[] = {-1, -1, 1,
                         1, -1, 1,
                         1, 1, 1,
                         -1, 1, 1,

                         -1, -1, -1,
                         -1, 1, -1,
                         1, 1, -1,
                         1, -1, -1,

                         -1, 1, -1,
                         -1, 1, 1,
                         1, 1, 1,
                         1, 1, -1,

                         -1, -1, -1,
                         1, -1, -1,
                         1, -1, 1,
                         -1, -1, 1,

                         1, -1, -1,
                         1, 1, -1,
                         1, 1, 1,
                         1, -1, 1,

                         -1, -1, -1,
                         -1, -1, 1,
                         -1, 1, 1,
                         -1, 1, -1};

float cube_normals[] = {0, 0, 1,
                        0, 0, 1,
                        0, 0, 1,
                        0, 0, 1,

                        0, 0, -1,
                        0, 0, -1,
                        0, 0, -1,
                        0, 0, -1,

                        0, 1, 0,
                        0, 1, 0,
                        0, 1, 0,
                        0, 1, 0,

                        0, -1, 0,
                        0, -1, 0,
                        0, -1, 0,
                        0, -1, 0,

                        1, 0, 0,
                        1, 0, 0,
                        1, 0, 0,
                        1, 0, 0,

                        -1, 0, 0,
                        -1, 0, 0,
                        -1, 0, 0,
                        -1, 0, 0};
class Scene {
public:
    void setup_projection( int w, int h ) {
        glViewport( 0, 0, w, h );
        glMatrixMode( GL_PROJECTION );
        glLoadIdentity();
        gluPerspective( 50, (GLdouble)w/(GLdouble)h, 1, 5000.0 );
        glMatrixMode( GL_MODELVIEW );
    }
};
int main() {
    ///Number of models to render
    int NumberOfCubes = 0;
    cout << "Enter number of cubes to render: ";
    cin >> NumberOfCubes;
    system("cls");

    ///Create vectors for mesh data
    //6 faces * 4 verts * x, y, z * number of cubes
    std::vector<float> vertices; vertices.resize(6*4*3*NumberOfCubes);
    std::vector<float> normals; normals.resize(6*4*3*NumberOfCubes);
    for(int i = 0; i < NumberOfCubes; i++)
    {
        for(int j = 0; j < 6*4*3; j++)
        {
            vertices[(i*6*4*3) + j] = cube_vertices[j] + i;
            normals[(i*6*4*3) + j] = cube_normals[j];
        }
    }

    ///Store size of the vectors
    int SizeOfVertices = vertices.size() * sizeof(float);
    int SizeOfNormals = normals.size() * sizeof(float);

    ///Window setup, lighting setup
    sf::RenderWindow window(sf::VideoMode(800, 600, 32), "Test");
    Scene scene;
    scene.setup_projection(window.getSize().x,window.getSize().y);
    glewInit();
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_LIGHTING);
    glShadeModel(GL_SMOOTH);
    glEnable(GL_LIGHT0);
    float XL = .5, YL = .1, ZL = 1;
    GLfloat ambientLight[] = { 0.2f, 0.2f, 0.2f, 1.0f };
    GLfloat diffuseLight[] = { 0.8f, 0.8f, 0.8, 1.0f };
    GLfloat specularLight[] = { 0.5f, 0.5f, 0.5f, 1.0f };
    GLfloat lightpos[] = {XL, YL, ZL, 0.};
    glLightfv(GL_LIGHT0, GL_AMBIENT, ambientLight);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuseLight);
    glLightfv(GL_LIGHT0, GL_SPECULAR, specularLight);
    glLightfv(GL_LIGHT0, GL_POSITION, lightpos);

    ///Generate the VBO
    GLuint VBOID;
    glGenBuffers(1, &VBOID);
    glBindBuffer(GL_ARRAY_BUFFER, VBOID);
    glBufferData(GL_ARRAY_BUFFER, SizeOfVertices + SizeOfNormals, 0, GL_STATIC_DRAW);
    glBufferSubData(GL_ARRAY_BUFFER, 0, SizeOfVertices, &vertices[0]);
    glBufferSubData(GL_ARRAY_BUFFER, SizeOfVertices, SizeOfNormals + SizeOfVertices, &normals[0]);
    glBindBuffer(GL_ARRAY_BUFFER, 0);

    ///FPS Stuff
    sf::Clock FPS;
    sf::Clock ShowFPS;
    float fps;

    ///Start loop
    cout << "Rendering " << NumberOfCubes * 8 << " vertices." << endl;
    cout << "Using graphics card: " << glGetString(GL_RENDERER) << endl;

    while( window.isOpen() ) {
        sf::Event event;
        while( window.pollEvent( event ) ) {
            if( event.type == sf::Event::Closed )
                window.close();
        }
        fps = FPS.getElapsedTime().asSeconds();
        fps = 1 / fps;
        FPS.restart();
        if(ShowFPS.getElapsedTime().asSeconds() > 1)
        {
            cout << "FPS: " << fps << "\t FrameTime: " << 1000 / fps << endl;
            ShowFPS.restart();
        }

        glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        scene.setup_projection(window.getSize().x,window.getSize().y);
        glMatrixMode(GL_MODELVIEW);
        glLoadIdentity();
        gluLookAt(-25, -25, 150, 50, 50, 50, 0, 1, 0);

        glBindBuffer(GL_ARRAY_BUFFER, VBOID);
        glEnableClientState(GL_NORMAL_ARRAY);
        glEnableClientState(GL_VERTEX_ARRAY);
        glColor3f(1, 0, 0);

        glNormalPointer(GL_FLOAT, 0, 0);
        glVertexPointer(3, GL_FLOAT, 0, 0);

        glDrawArrays(GL_QUADS, 0, 6*4*NumberOfCubes);

        glDisableClientState(GL_VERTEX_ARRAY);
        glDisableClientState(GL_NORMAL_ARRAY);
        glBindBuffer(GL_ARRAY_BUFFER, 0);

        window.display();
    }
    return 1;
}
4

3 に答える 3

1

コードに関するいくつかの注意：

void Scene::resize( int w, int h ) {
    glViewport( 0, 0, w, h );
    glMatrixMode( GL_PROJECTION );
    glLoadIdentity();
    gluPerspective( 50, (GLdouble)w/(GLdouble)h, 1, 5000.0 );
    glMatrixMode( GL_MODELVIEW );
}

ビューポートと投影の設定は、ある種の「サイズ変更」操作ではないことを理解してください。それらは描画プロセスの一部であるため、そのように扱う必要があります。良い点は、描画を繰り返すたびにこの関数を呼び出すことです。しかし、私はそれを呼ばないでしょうresize。setup_projectionこの関数が何を実行するのか、何に反応するのかを明確にするために、より適切な名前は、または類似したものでした。常にそれが何をするかによって関数を呼び出してください！

これ

cout << endl << endl << "Close program when finished." << endl;

bool ProgramRunning(true);
while(ProgramRunning == true) {}

おそらく期待どおりに機能しません。閉じるのはコンソールウィンドウ/ターミナルです。これにより、プログラムは標準の入力とプロセスリーダーを失い、それによってプログラムが終了します。whileループの後のコードは、まったく実行されません。これまで機能がなかったProgrammRunningフラグをfalseに設定するシグナルハンドラーをインストールできます。

ただし、これに対処するための標準的な方法は、ユーザーがEnterキーを押すまでユーザーが一時停止するのを待つことです。

cout << "Program execution finished, hit the ENTER key to terminate" << endl;
cin.get();

ここで、50 FPSしか得られない理由について：最も可能性の高い理由は、V-Syncが有効になっていて、ディスプレイのリフレッシュ周波数が50Hzであるためです。50Hzは珍しいですが、聞いたことはありません。また、ディスプレイが60Hzで実行されている可能性もありますが、何らかの理由で、各リトレースの更新期限が設定されていないため、平均して6フレームごとにコードが欠落しています。

もう1つの理由は、GeForceで実行されていないが、ラップトップのチップセットGPUで実行されている可能性があります。ハイブリッドグラフィックシステムを使用している場合は、プログラムを実行する前に、すべてのドライバーが正しくインストールされていることと、GeForceGPUに切り替えていることを確認してください。

の出力を印刷glGetString(GL_RENDERER);して確認してください。ウィンドウを開いた後、OpenGLコンテキストを作成して

cout << glGetString(GL_RENDERER) << endl;
于 2012-11-05T10:33:08.207 に答える
0

ダブルバッファリングを使用していますか？はいの場合sync to vblank、ドライバで有効になっている可能性があります。これは、ダブルバッファリングを使用するすべてのOpengGLアプリケーションが、最大でモニターのリフレッシュレート（通常は約50〜60Hz）でレンダリングされることを意味します。

同じコードを（大幅に）小さいモデルで試して、FPSがこの値を超えるかどうかを確認できます。

于 2012-11-05T03:01:22.973 に答える
0

さらに調査を行った後、VBOインデックスについて知り、それを使用して、100万の頂点で数百のFPSを取得することができました。

于 2012-11-16T21:18:18.380 に答える