float measureBeginEndPerformance(Model& model) {
int N = (int)model.cpuIndex.size();
const unsigned int* index = &model.cpuIndex[0];
const float* vertex = reinterpret_cast<const float*>(&model.cpuVertex[0]);
const float* normal = reinterpret_cast<const float*>(&model.cpuNormal[0]);
const float* color = reinterpret_cast<const float*>(&model.cpuColor[0]);
const float* texCoord= reinterpret_cast<const float*>(&model.cpuTexCoord[0]);
glPushAttrib(GL_ALL_ATTRIB_BITS);
configureCameraAndLights();
float k = 0;
double t0 = 0, t1 = 0;
for (int j = 0; j < frames + 1; ++j) {
// Don't count the first frame against us; it is cache warmup
if (j == 1) {
t0 = System::time();
}
k += kstep;
glClearColor(1.0f, 1.0f, 1.0f, 0.04f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, model.textureID);
for (int c = 0; c < count; ++c) {
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(c - (count - 1) / 2.0, 0, -2);
glRotatef(k * ((c & 1) * 2 - 1) + 90, 0, 1, 0);
glBegin(GL_TRIANGLES);
for (int i = 0; i < N; ++i) {
const int v = index[i];
const int v3 = 3 * v;
glColor4fv(color + v * 4);
glTexCoord2fv(texCoord + v + v);
glNormal3fv(normal + v3);
glVertex3fv(vertex + v3);
}
glEnd();
}
glSwapBuffers();
}
glFinish();
t1 = System::time();
glPopAttrib();
return frames / (System::time() - t0);
}
float measureDrawElementsRAMPerformance(Model& model) {
// Number of indices
const int N = (int)model.cpuIndex.size();
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
configureCameraAndLights();
float k = 0;
double t0 = 0, t1 = 0;
glFinish();
for (int j = 0; j < frames + 1; ++j) {
// Don't count the first frame against us; it is cache warmup
if (j == 1) {
t0 = System::time();
}
k += kstep;
glClearColor(1.0f, 1.0f, 1.0f, 0.04f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, model.textureID);
for (int c = 0; c < count; ++c) {
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(c - (count - 1) / 2.0, 0, -2);
glRotatef(k * ((c & 1) * 2 - 1) + 90, 0, 1, 0);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glNormalPointer(GL_FLOAT, 0, &model.cpuNormal[0]);
glColorPointer(4, GL_FLOAT, 0, &model.cpuColor[0]);
glTexCoordPointer(2, GL_FLOAT, 0, &model.cpuTexCoord[0]);
glVertexPointer(3, GL_FLOAT, 0, &model.cpuVertex[0]);
glDrawElements(GL_TRIANGLES, N, GL_UNSIGNED_INT, &model.cpuIndex[0]);
}
glSwapBuffers();
}
glFinish();
t1 = System::time();
glPopClientAttrib();
glPopAttrib();
return frames / (t1 - t0);
}
void CanvasGL::renderNoise() {
if (!noiseShader_)
return;
activate();
glViewport(0, 0, getScreenDimensions().x, getScreenDimensions().y);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
noiseShader_->activate();
drawRect();
noiseShader_->deactivate();
glSwapBuffers();
activateDefaultRenderContext();
}
void display()
{
/*
* A Simple display function to run the entire show
* static variables are used to save past state of
* the worm, and reflect future motion based on state
*/ static float trans;
static float timer;
static float dt;
if(dt == 0.0f){
dt = DELTA_T;
trans = START_CORD;
}
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-2.0 * 64/48.0, 2.0 * 64/48.0, -2.0, 2.0, 0.1, 100);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Angular (maybe isometric) view
gluLookAt(2.0, 2.0, 2.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
// Side View
//gluLookAt(1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
// Top View
//gluLookAt(0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT);
glColor4f(0,0,1.0,1.0);
glTranslatef(trans, 0.0, 0.0);
capsule();
glTranslatef(0.5f, 0.0, 0.0);
glRotatef(ANGLE_MAX*(timer), 0.0, 0.0, 1.0f);
body();
glTranslatef(0.5f, 0.0, 0.0);
glRotatef(-2*ANGLE_MAX*(timer), 0.0, 0.0, 1.0f);
body();
glTranslatef(0.5f, 0.0, 0.0);
glRotatef(ANGLE_MAX*(timer), 0.0, 0.0, 1.0f);
body();
if(timer == 1 || (timer==0 && dt<0)){
dt = -dt;
}
#ifdef __APPLE__
glSwapAPPLE();
#else
glSwapBuffers();
#endif
trans = trans + 0.1f*timer;
timer = timer + dt;
}
void CanvasGL::renderTexture(int unitNumber) {
if (!shader_)
return;
activate();
glViewport(0, 0, getScreenDimensions().x, getScreenDimensions().y);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
shader_->activate();
shader_->setUniform("tex_", unitNumber);
drawRect();
shader_->deactivate();
glDisable(GL_BLEND);
glSwapBuffers();
activateDefaultRenderContext();
}
float measureDrawArraysVBOPeakPerformance(Model& model) {
bool hasVBO =
(strstr((char*)glGetString(GL_EXTENSIONS), "GL_ARB_vertex_buffer_object") != NULL) &&
(glGenBuffersARB != NULL) &&
(glBufferDataARB != NULL) &&
(glDeleteBuffersARB != NULL);
if (! hasVBO) {
return 0.0;
}
// Load the vertex arrays
// Number of vertices
const int V = (int)model.cpuVertex.size();
GLuint vbo, indexBuffer;
glGenBuffersARB(1, &vbo);
glGenBuffersARB(1, &indexBuffer);
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
size_t vertexSize = V * sizeof(float) * 3;
GLintptrARB vertexPtr = 0;
// Upload data
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, vertexSize, &model.cpuVertex[0], GL_STATIC_DRAW_ARB);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
float w = 0.8f, h = 0.6f;
glFrustum(-w/2, w/2, -h/2, h/2, 0.5f, 100);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glShadeModel(GL_SMOOTH);
glDisable(GL_NORMALIZE);
glDisable(GL_COLOR_MATERIAL);
glCullFace(GL_BACK);
float k = 0;
double t0 = 0, t1 = 0;
glFinish();
for (int j = 0; j < frames + 1; ++j) {
if (j == 1) {
t0 = System::time();
}
k += kstep;
glClearColor(1.0f, 1.0f, 1.0f, 0.04f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnableClientState(GL_VERTEX_ARRAY);
for (int c = 0; c < count; ++c) {
static const float col[] = {1, 0, 0, 1, 0, 0};
glColor3fv(col + (c % 3));
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(c - (count - 1) / 2.0, 0, -2);
glRotatef(k * ((c & 1) * 2 - 1) + 90, 0, 1, 0);
glVertexPointer(3, GL_FLOAT, 0, (void*)vertexPtr);
glDrawArrays(GL_TRIANGLES, 0, V);
}
glSwapBuffers();
}
glFinish();
t1 = System::time();
glPopClientAttrib();
glPopAttrib();
glDeleteBuffersARB(1, &indexBuffer);
glDeleteBuffersARB(1, &vbo);
glFinish();
return frames / (t1 - t0);
}
// glInterleavedArrays with 16-bit indices (should be the fastest indexed version)
float measureDrawElementsVBOIPerformance(Model& model, bool use_glInterleavedArrays) {
bool hasVBO =
(strstr((char*)glGetString(GL_EXTENSIONS), "GL_ARB_vertex_buffer_object") != NULL) &&
(glGenBuffersARB != NULL) &&
(glBufferDataARB != NULL) &&
(glDeleteBuffersARB != NULL);
if (! hasVBO) {
return 0.0;
}
// Load the vertex arrays
// Number of indices
const int N = (int)model.cpuIndex.size();
// Number of vertices
const int V = (int)model.cpuVertex.size();
GLuint vbo, indexBuffer;
glGenBuffersARB(1, &vbo);
glGenBuffersARB(1, &indexBuffer);
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
size_t vertexSize = V * sizeof(float) * 3;
size_t normalSize = V * sizeof(float) * 3;
size_t colorSize = V * sizeof(float) * 4;
size_t texCoordSize = V * sizeof(float) * 2;
size_t totalSize = vertexSize + normalSize + texCoordSize + colorSize;
// Pointers relative to the start of the vbo in video memory used
// for manually interleaving
GLintptrARB texCoordPtr = 0;
GLintptrARB colorPtr = texCoordPtr + 2 * sizeof(float);
GLintptrARB normalPtr = colorPtr + 4 * sizeof(float);
GLintptrARB vertexPtr = normalPtr + 3 * sizeof(float);
GLintptrARB indexPtr = 0;
// Upload data
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, indexBuffer);
glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, N * sizeof(unsigned short), &model.cpuIndex16[0], GL_STATIC_DRAW_ARB);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
float* interleave = (float*)malloc(totalSize);
// Interleave the buffers in memory
float* ptr = interleave;
for (int i = 0; i < V; ++i) {
ptr[0] = model.cpuTexCoord[i].x;
++ptr;
ptr[0] = model.cpuTexCoord[i].y;
++ptr;
ptr[0] = model.cpuColor[i].x;
++ptr;
ptr[0] = model.cpuColor[i].y;
++ptr;
ptr[0] = model.cpuColor[i].z;
++ptr;
ptr[0] = model.cpuColor[i].w;
++ptr;
ptr[0] = model.cpuNormal[i].x;
++ptr;
ptr[0] = model.cpuNormal[i].y;
++ptr;
ptr[0] = model.cpuNormal[i].z;
++ptr;
ptr[0] = model.cpuVertex[i].x;
++ptr;
ptr[0] = model.cpuVertex[i].y;
++ptr;
ptr[0] = model.cpuVertex[i].z;
++ptr;
}
glBufferDataARB(GL_ARRAY_BUFFER_ARB, totalSize, interleave, GL_STATIC_DRAW_ARB);
free(interleave);
configureCameraAndLights();
float k = 0;
double t0 = 0, t1 = 0;
for (int j = 0; j < frames + 1; ++j) {
if (j == 1) {
t0 = System::time();
}
k += kstep;
glClearColor(1.0f, 1.0f, 1.0f, 0.04f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, model.textureID);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
if (use_glInterleavedArrays) {
// Use old-style OpenGL interleaving
glInterleavedArrays(GL_T2F_C4F_N3F_V3F, 0, (void*)0);
} else {
GLsizei stride = (3+3+4+2) * sizeof(float);
// Manually interleave, which gives more flexibility
glTexCoordPointer(2, GL_FLOAT, stride, (void*)texCoordPtr);
glColorPointer (4, GL_FLOAT, stride, (void*)colorPtr);
glNormalPointer (GL_FLOAT, stride, (void*)normalPtr);
glVertexPointer (3, GL_FLOAT, stride, (void*)vertexPtr);
}
for (int c = 0; c < count; ++c) {
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(c - (count - 1) / 2.0, 0, -2);
glRotatef(k * ((c & 1) * 2 - 1) + 90, 0, 1, 0);
debugAssertGLOk();
glDrawElements(GL_TRIANGLES, N, GL_UNSIGNED_SHORT, (void*)indexPtr);
debugAssertGLOk();
}
glSwapBuffers();
}
glFinish();
t1 = System::time();
glPopClientAttrib();
glPopAttrib();
glDeleteBuffersARB(1, &indexBuffer);
glDeleteBuffersARB(1, &vbo);
return frames / (t1 - t0);
}
// Non-interleaved VBO with 16-bit indices
float measureDrawElementsVBO16Performance(Model& model) {
bool hasVBO =
(strstr((char*)glGetString(GL_EXTENSIONS), "GL_ARB_vertex_buffer_object") != NULL) &&
(glGenBuffersARB != NULL) &&
(glBufferDataARB != NULL) &&
(glDeleteBuffersARB != NULL);
if (! hasVBO) {
return 0.0;
}
// Load the vertex arrays
// Number of indices
const int N = (int)model.cpuIndex.size();
// Number of vertices
const int V = (int)model.cpuVertex.size();
GLuint vbo, indexBuffer;
glGenBuffersARB(1, &vbo);
glGenBuffersARB(1, &indexBuffer);
glPushAttrib(GL_ALL_ATTRIB_BITS);
glPushClientAttrib(GL_CLIENT_ALL_ATTRIB_BITS);
size_t vertexSize = V * sizeof(float) * 3;
size_t normalSize = V * sizeof(float) * 3;
size_t texCoordSize = V * sizeof(float) * 2;
size_t colorSize = V * sizeof(float) * 4;
size_t totalSize = vertexSize + normalSize + texCoordSize + colorSize;
size_t indexSize = N * sizeof(unsigned short);
// Pointers relative to the start of the vbo in video memory
// (would interleaving be faster?)
GLintptrARB vertexPtr = 0;
GLintptrARB normalPtr = vertexSize + vertexPtr;
GLintptrARB colorPtr = normalSize + normalPtr;
GLintptrARB texCoordPtr = colorSize + colorPtr;
GLintptrARB indexPtr = 0;
// Upload data
glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, indexBuffer);
glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB, indexSize, &model.cpuIndex16[0], GL_STATIC_DRAW_ARB);
glBindBufferARB(GL_ARRAY_BUFFER_ARB, vbo);
glBufferDataARB(GL_ARRAY_BUFFER_ARB, totalSize, NULL, GL_STATIC_DRAW_ARB);
glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, vertexPtr, vertexSize, &model.cpuVertex[0]);
glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, colorPtr, colorSize, &model.cpuColor[0]);
glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, normalPtr, normalSize, &model.cpuNormal[0]);
glBufferSubDataARB(GL_ARRAY_BUFFER_ARB, texCoordPtr, texCoordSize, &model.cpuTexCoord[0]);
configureCameraAndLights();
float k = 0;
double t0 = 0, t1 = 0;
for (int j = 0; j < frames + 1; ++j) {
if (j == 1) {
t0 = System::time();
}
k += kstep;
glClearColor(1.0f, 1.0f, 1.0f, 0.04f);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, model.textureID);
glEnableClientState(GL_COLOR_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glEnableClientState(GL_TEXTURE_COORD_ARRAY);
glEnableClientState(GL_VERTEX_ARRAY);
glColorPointer(4, GL_FLOAT, 0, (void*)colorPtr);
glTexCoordPointer(2, GL_FLOAT, 0, (void*)texCoordPtr);
glNormalPointer(GL_FLOAT, 0, (void*)normalPtr);
glVertexPointer(3, GL_FLOAT, 0, (void*)vertexPtr);
for (int c = 0; c < count; ++c) {
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(c - (count - 1) / 2.0, 0, -2);
glRotatef(k * ((c & 1) * 2 - 1) + 90, 0, 1, 0);
glDrawElements(GL_TRIANGLES, N, GL_UNSIGNED_SHORT, (void*)indexPtr);
}
glSwapBuffers();
}
glFinish();
t1 = System::time();
glPopClientAttrib();
glPopAttrib();
glDeleteBuffersARB(1, &indexBuffer);
glDeleteBuffersARB(1, &vbo);
return frames / (t1 - t0);
}
