C++ Opengl三角形基准

我正在尝试测试如何在笔记本电脑上绘制may三角形，因此我在我的系统上执行以下操作：

操作系统：Windows 10 CPU:Intel Core i5 5200U GPU:NVIDIA Geforce 820M

代码：

glfwWindowHint（GLFW_样本，4）；
glfwWindowHint（GLFW_上下文_版本_专业，3）；
glfwWindowHint（GLFW_上下文_版本_小调，3）；
glfwWindowHint（GLFW_OPENGL_FORWARD_COMPAT，GL_TRUE）；//让马科斯快乐；应该不需要
glfwWindowHint（GLFW_OPENGL_配置文件、GLFW_OPENGL_核心配置文件）；
//打开窗口并创建其OpenGL上下文
window=glfwCreateWindow（1024768，“教程02-红色三角形”，NULL，NULL）；
如果（窗口==NULL）{
fprintf（stderr，“无法打开GLFW窗口。如果您有英特尔GPU，则它们与3.3不兼容。请尝试教程的2.1版本。\n”）；
getchar（）；
glfwTerminate（）；
返回-1；
}
glfwMakeContextCurrent（窗口）；
//初始化GLEW
glewExperimental=true；//岩心剖面图所需
如果（glewInit（）！=GLEW\u确定）{
fprintf（stderr，“未能初始化GLEW\n”）；
getchar（）；
glfwTerminate（）；
返回-1；
}
//确保我们可以捕获下面按下的退出键
glfwSetInputMode（窗口，GLFW_粘滞键，GL_真）；
//深蓝色背景
glClearColor（0.0f、0.0f、0.4f、0.0f）；
胶合垂直排列；
glgenvertexarray（1和VertexArrayID）；
glBindVertexArray（VertexArrayID）；
//从着色器创建并编译我们的GLSL程序
GLuint programID=加载着色器（“SimpleVertexShader.vertexshader”、“SimpleFragmentShader.fragmentshader”）；
//三角形数
常数int v=200；
静态GLfloat g_顶点_缓冲区_数据[v*9]={
-1.0f，-1.0f，1.0f，
0.8f，0.f，0.0f，
0.5f、1.0f、0.0f、，
};
//三角形的填充缓冲区
对于（int i=9；i1个三角形
glDisableVertexAttributeArray（0）；
//交换缓冲区
glfwSwapBuffers（窗口）；
glfwPollEvents（）；
//glBufferData（GLU数组缓冲区、sizeof（g顶点缓冲区数据）、g顶点缓冲区数据、GLU静态绘图）；
frameNr++；
sprintf_s（文本，“%d%d%d”，帧号，时钟（）/1000，（帧号*1000）/（时钟（）+1））；
glfwSetWindowTitle（窗口，文本）；
}//检查是否按下ESC键或窗口是否关闭
while（glfwGetKey（窗口，GLFW_键_退出）！=GLFW_按&&
glfwWindowShouldClose（窗口）==0）；
//清除VBO
glDeleteBuffers（1和vertexbuffer）；
glDeleteVertexArrays（1和VertexArrayID）；
glDeleteProgram（programID）；
//关闭OpenGL窗口并终止GLFW
glfwTerminate（）；
返回0；

让我惊奇的是，在v=200个三角形的情况下，我只能获得80帧的速度。 这将是每秒16000个三角形，这很糟糕，不是吗

我在代码中做错了什么，或者我的图形卡真的可以处理这么少的三角形吗

---

像1080ti手柄这样的现代gpu可以使用多少个三角形（理论上我听说有110亿个三角形，虽然我知道实际上要低得多）。

既然我还没有足够的声誉来评论，让我问一下：你的三角形有多大？如果没有看到顶点着色器，很难判断，但是假设代码中的坐标直接映射到标准化设备坐标，那么三角形将覆盖屏幕的重要部分。如果我没弄错的话，你基本上是在同一个三角形的上面一遍又一遍地画。因此，您很可能会受到填充率的限制。为了获得更有意义的结果，您可能更希望只绘制一个由非重叠三角形组成的网格，或者至少绘制一个随机三角形。为了进一步降低填充率和帧缓冲区带宽要求，您可能需要确保关闭深度缓冲和混合

---

如果您对每秒原始三角形感兴趣，为什么要启用MSAA？这样做只是人为地放大光栅化器负载。正如其他人也注意到的，V-Sync可能会关闭，因为80 Hz的刷新率会非常奇怪，但最好确保通过

glfwSwapInterval（0）

明确关闭它。不是像你那样估计总的帧时间，你可能想考虑使用.< /P>< P>来测量GPU上的实际绘制时间，因为我还没有足够的评论来评论，请让我问一下：你们的三角形有多大？如果没有看到顶点着色器，很难判断，但是假设代码中的坐标直接映射到标准化设备坐标，那么三角形将覆盖屏幕的重要部分。如果我没弄错的话，你基本上是在同一个三角形的上面一遍又一遍地画。因此，您很可能是fillr

glfwWindowHint(GLFW_SAMPLES, 4);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // To make MacOS happy; should not be needed
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

// Open a window and create its OpenGL context

window = glfwCreateWindow( 1024, 768, "Tutorial 02 - Red triangle", NULL, NULL);
if( window == NULL ){
    fprintf( stderr, "Failed to open GLFW window. If you have an Intel GPU, they are not 3.3 compatible. Try the 2.1 version of the tutorials.\n" );
    getchar();
    glfwTerminate();
    return -1;
}
glfwMakeContextCurrent(window);

// Initialize GLEW
glewExperimental = true; // Needed for core profile
if (glewInit() != GLEW_OK) {
    fprintf(stderr, "Failed to initialize GLEW\n");
    getchar();
    glfwTerminate();
    return -1;
}

// Ensure we can capture the escape key being pressed below
glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);

// Dark blue background
glClearColor(0.0f, 0.0f, 0.4f, 0.0f);

GLuint VertexArrayID;
glGenVertexArrays(1, &VertexArrayID);
glBindVertexArray(VertexArrayID);

// Create and compile our GLSL program from the shaders
GLuint programID = LoadShaders( "SimpleVertexShader.vertexshader", "SimpleFragmentShader.fragmentshader" );


// Number of triangles
const int v = 200;
static  GLfloat g_vertex_buffer_data[v*9] = { 
    -1.0f, -1.0f, 1.0f,
     0.8f, 0.f, 0.0f,
     0.5f,  1.0f, 0.0f,
};

// fill buffer of triangles
for (int i = 9; i < v * 9; i += 9)
{
    g_vertex_buffer_data[i] = g_vertex_buffer_data[0];
    g_vertex_buffer_data[i+1] = g_vertex_buffer_data[1];
    g_vertex_buffer_data[i+2] = g_vertex_buffer_data[2];

    g_vertex_buffer_data[i+3] = g_vertex_buffer_data[3];
    g_vertex_buffer_data[i+4] = g_vertex_buffer_data[4];
    g_vertex_buffer_data[i+5] = g_vertex_buffer_data[5];

    g_vertex_buffer_data[i+6] = g_vertex_buffer_data[6];
    g_vertex_buffer_data[i+7] = g_vertex_buffer_data[7];
    g_vertex_buffer_data[i+8] = g_vertex_buffer_data[8];
}

GLuint vertexbuffer;
glGenBuffers(1, &vertexbuffer);
glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);

int frameNr = 0;
char text[100];
do{

    // Clear the screen
    glClear( GL_COLOR_BUFFER_BIT );

    // Use our shader
    glUseProgram(programID);

    // 1rst attribute buffer : vertices
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, vertexbuffer);
    glVertexAttribPointer(
        0,                  // attribute 0. No particular reason for 0, but must match the layout in the shader.
        3,                  // size
        GL_FLOAT,           // type
        GL_FALSE,           // normalized?
        0,                  // stride
        (void*)0            // array buffer offset
    );

    // Draw the triangle !
    glDrawArrays(GL_TRIANGLES, 0, v*3); // 3 indices starting at 0 -> 1 triangle

    glDisableVertexAttribArray(0);

    // Swap buffers
    glfwSwapBuffers(window);
    glfwPollEvents();
    //glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertex_buffer_data), g_vertex_buffer_data, GL_STATIC_DRAW);

    frameNr++;
    sprintf_s(text, "%d %d %d", frameNr, clock() / 1000, (frameNr * 1000) / (clock() + 1));
    glfwSetWindowTitle(window, text);

} // Check if the ESC key was pressed or the window was closed
while( glfwGetKey(window, GLFW_KEY_ESCAPE ) != GLFW_PRESS &&
       glfwWindowShouldClose(window) == 0 );

// Cleanup VBO
glDeleteBuffers(1, &vertexbuffer);
glDeleteVertexArrays(1, &VertexArrayID);
glDeleteProgram(programID);

// Close OpenGL window and terminate GLFW
glfwTerminate();

return 0;