Более эффективно использовать GL_TRIANGLE_STRIP или индексированный GL_TRIANGLES для рисования динамического числа квадов

Я разрабатываю простую основанную на спрайтах 2D-игру на C ++, которая использует OpenGL для аппаратного рендеринга и SDL для управления окнами и пользовательского ввода. Поскольку это 2D-игра, мне всегда нужно рисовать четырехугольники, но поскольку число спрайтов является динамическим, я никогда не могу полагаться на постоянное количество четырехугольников. Следовательно, мне нужно перебуферизовать все данные вершин через мой VBO в каждом кадре (поскольку может быть больше или меньше квадов, чем было в последнем кадре, и, следовательно, буфер может иметь другой размер).

Прототип программы, которую я имею до сих пор, создает окно и позволяет пользователю добавлять и удалять квадраты в диагональном ряду с помощью клавиш со стрелками вверх и вниз. Прямо сейчас квадратики, которые я рисую, — это простые, не текстурированные белые квадраты. Вот код, с которым я работаю (компилируется и корректно работает под OS X 10.6.8 и Ubuntu 12.04 с OpenGL 2.1):

#if defined(__APPLE__)
#include <OpenGL/OpenGL.h>
#endif
#if defined(__linux__)
#define GL_GLEXT_PROTOTYPES
#include <GL/glx.h>
#endif

#include <GL/gl.h>
#include <SDL.h>
#include <iostream>
#include <vector>
#include <string>struct Vertex
{
//vertex coordinates
GLint x;
GLint y;
};

//Constants
const int SCREEN_WIDTH = 1024;
const int SCREEN_HEIGHT = 768;
const int FPS = 60; //our framerate
//Globals
SDL_Surface *screen;                    //the screen
std::vector<Vertex> vertices;           //the actual vertices for the quads
std::vector<GLint> startingElements;    //the index where the 4 vertices of each quad begin in the 'vertices' vector
std::vector<GLint> counts;              //the number of vertices for each quad
GLuint VBO = 0;                         //the handle to the vertex buffervoid createVertex(GLint x, GLint y)
{
Vertex vertex;
vertex.x = x;
vertex.y = y;
vertices.push_back(vertex);
}

//creates a quad at position x,y, with a width of w and a height of h (in pixels)
void createQuad(GLint x, GLint y, GLint w, GLint h)
{
//Since we're drawing the quads using GL_TRIANGLE_STRIP, the vertex drawing
//order is from top to bottom, left to right, like so:
//
//    1-----3
//    |     |
//    |     |
//    2-----4

createVertex(x, y);     //top-left vertex
createVertex(x, y+h);   //bottom-left vertex
createVertex(x+w, y);   //top-right vertex
createVertex(x+w, y+h); //bottom-right vertex

counts.push_back(4);    //each quad will always have exactly 4 vertices
startingElements.push_back(startingElements.size()*4);

std::cout << "Number of Quads: " << counts.size() << std::endl; //print out the current number of quads
}

//removes the most recently created quad
void removeQuad()
{
if (counts.size() > 0)  //we don't want to remove a quad if there aren't any to remove
{
for (int i=0; i<4; i++)
{
vertices.pop_back();
}

startingElements.pop_back();
counts.pop_back();

std::cout << "Number of Quads: " << counts.size() << std::endl;
}
else
{
std::cout << "Sorry, you can't remove a quad if there are no quads to remove!" << std::endl;
}
}void init()
{
//initialize SDL
SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER);

screen = SDL_SetVideoMode(SCREEN_WIDTH, SCREEN_HEIGHT, 0, SDL_OPENGL);

#if defined(__APPLE__)
//Enable vsync so that we don't get tearing when rendering
GLint swapInterval = 1;
CGLSetParameter(CGLGetCurrentContext(), kCGLCPSwapInterval, &swapInterval);
#endif

//Disable depth testing, lighting, and dithering, since we're going to be doing 2D rendering only
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glDisable(GL_DITHER);
glPushAttrib(GL_DEPTH_BUFFER_BIT | GL_LIGHTING_BIT);

//Set the projection matrix
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, SCREEN_WIDTH, SCREEN_HEIGHT, 0, -1.0, 1.0);

//Set the modelview matrix
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();

//Create VBO
glGenBuffers(1, &VBO);
glBindBuffer(GL_ARRAY_BUFFER, VBO);
}void gameLoop()
{
int frameDuration = 1000/FPS;   //the set duration (in milliseconds) of a single frame
int currentTicks;
int pastTicks = SDL_GetTicks();
bool done = false;
SDL_Event event;

while(!done)
{
//handle user input
while(SDL_PollEvent(&event))
{
switch(event.type)
{
case SDL_KEYDOWN:
switch (event.key.keysym.sym)
{
case SDLK_UP:   //create a new quad every time the up arrow key is pressed
createQuad(64*counts.size(), 64*counts.size(), 64, 64);
break;
case SDLK_DOWN: //remove the most recently created quad every time the down arrow key is pressed
removeQuad();
break;
default:
break;
}
break;
case SDL_QUIT:
done = true;
break;
default:
break;
}
}//Clear the color buffer
glClear(GL_COLOR_BUFFER_BIT);

glBindBuffer(GL_ARRAY_BUFFER, VBO);
//replace the current contents of the VBO with a completely new set of data (possibly including either more or fewer quads)
glBufferData(GL_ARRAY_BUFFER, vertices.size()*sizeof(Vertex), &vertices.front(), GL_DYNAMIC_DRAW);

glEnableClientState(GL_VERTEX_ARRAY);

//Set vertex data
glVertexPointer(2, GL_INT, sizeof(Vertex), 0);
//Draw the quads
glMultiDrawArrays(GL_TRIANGLE_STRIP, &startingElements.front(), &counts.front(), counts.size());

glDisableClientState(GL_VERTEX_ARRAY);

glBindBuffer(GL_ARRAY_BUFFER, 0);//Check to see if we need to delay the duration of the current frame to match the set framerate
currentTicks = SDL_GetTicks();
int currentDuration = (currentTicks - pastTicks);   //the duration of the frame so far
if (currentDuration < frameDuration)
{
SDL_Delay(frameDuration - currentDuration);
}
pastTicks = SDL_GetTicks();

// flip the buffers
SDL_GL_SwapBuffers();
}
}void cleanUp()
{
glDeleteBuffers(1, &VBO);

SDL_FreeSurface(screen);
SDL_Quit();
}int main(int argc, char *argv[])
{
std::cout << "To create a quad, press the up arrow. To remove the most recently created quad, press the down arrow." << std::endl;

init();
gameLoop();
cleanUp();

return 0;
}

В настоящее время я использую GL_TRIANGLE_STRIPS с glMultiDrawArrays () для рендеринга моих квадов. Это работает, и, кажется, довольно прилично с точки зрения производительности, но мне интересно, будет ли использование GL_TRIANGLES в сочетании с IBO для избежания дублирования вершин более эффективным способом рендеринга? Я провел некоторое исследование, и некоторые люди предполагают, что индексированные GL_TRIANGLES обычно превосходят GL_TRIANGLE_STRIPS, но они также, похоже, предполагают, что число квадов останется постоянным, и, таким образом, размер VBO и IBO не нужно будет повторно буферизовать в каждом кадре. , Это мое самое большое колебание с индексированными GL_TRIANGLES: если бы я реализовал индексированные GL_TRIANGLES, мне пришлось бы делать буферный буфер всего индекса каждый кадр в дополнение к буферизации всего VBO каждого кадра, опять же из-за динамического количества квадов.

В общем, мой вопрос заключается в следующем: учитывая, что мне приходится перебирать все мои данные вершин в GPU каждый кадр из-за динамического числа четырехугольников, будет ли эффективнее переключиться на индексированный GL_TRIANGLES для рисования четырехугольников, или мне следует придерживаться моей текущей реализации GL_TRIANGLE_STRIP?