PDA

View Full Version : Why the efficiency a simple 2D program is so low



Cocular
03-21-2012, 08:19 AM
I'm a totally new beginner to OpenGL and I'm learning it by online resource http://www.arcsynthesis.org/gltut/. (http://www.arcsynthesis.org/gltut/)

It is a 2D example that is a simply 2D spinning triangle around one point. A attach its main code below.

My problem is why a simple program run so slow. It does not run very smooth and I can a few obvious lags. This is much more frequent when I open v-sync (CPU 100% on a laptop is annoying). I also try to sleep sometime before call another glutPostRedisplay. This seems even lagger than v-sync.

My question is how to make this program run more smooth? I can never feel such lag when I play some games written in OpenGL. Also is there a way to limit the FPS?



#define ARRAY_COUNT( array ) (sizeof( array ) / (sizeof( array[0] ) * (sizeof( array ) != sizeof(void*) || sizeof( array[0] ) <= sizeof(void*))))

GLuint theProgram;

void InitializeProgram()
{
std::vector<GLuint> shaderList;

shaderList.push_back(Framework::LoadShader(GL_VERT EX_SHADER, "standard.vert"));
shaderList.push_back(Framework::LoadShader(GL_FRAG MENT_SHADER, "standard.frag"));

theProgram = Framework::CreateProgram(shaderList);
}

const float vertexPositions[] = {
0.25f, 0.25f, 0.0f, 1.0f,
0.25f, -0.25f, 0.0f, 1.0f,
-0.25f, -0.25f, 0.0f, 1.0f,
};

GLuint positionBufferObject;
GLuint vao;


void InitializeVertexBuffer()
{
glGenBuffers(1, &amp;positionBufferObject);

glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertexPositions), vertexPositions, GL_STREAM_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}

//Called after the window and OpenGL are initialized. Called exactly once, before the main loop.
void init()
{
InitializeProgram();
InitializeVertexBuffer();

glGenVertexArrays(1, &amp;vao);
glBindVertexArray(vao);
}


void ComputePositionOffsets(float &amp;fXOffset, float &amp;fYOffset)
{
const float fLoopDuration = 1.0f;
const float fScale = 3.14159f * 2.0f / fLoopDuration;

float fElapsedTime = glutGet(GLUT_ELAPSED_TIME) / 1000.0f;

float fCurrTimeThroughLoop = fmodf(fElapsedTime, fLoopDuration);

fXOffset = cosf(fCurrTimeThroughLoop * fScale) * 0.5f;
fYOffset = sinf(fCurrTimeThroughLoop * fScale) * 0.5f;
}

void AdjustVertexData(float fXOffset, float fYOffset)
{
std::vector<float> fNewData(ARRAY_COUNT(vertexPositions));
memcpy(&amp;fNewData[0], vertexPositions, sizeof(vertexPositions));

for(int iVertex = 0; iVertex < ARRAY_COUNT(vertexPositions); iVertex += 4)
{
fNewData[iVertex] += fXOffset;
fNewData[iVertex + 1] += fYOffset;
}

glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertexPositions), &amp;fNewData[0]);
glBindBuffer(GL_ARRAY_BUFFER, 0);
}

void display()
{
float fXOffset = 0.0f, fYOffset = 0.0f;
ComputePositionOffsets(fXOffset, fYOffset);
AdjustVertexData(fXOffset, fYOffset);

glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
glClear(GL_COLOR_BUFFER_BIT);

glUseProgram(theProgram);

glBindBuffer(GL_ARRAY_BUFFER, positionBufferObject);
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, 0, 0);

glDrawArrays(GL_TRIANGLES, 0, 3);

glDisableVertexAttribArray(0);
glUseProgram(0);

glutSwapBuffers();
glutPostRedisplay();
}


Standard.vert


#version 330

layout(location = 0) in vec4 position;

void main()
{
gl_Position = position;
}


Standard.frag


#version 330

out vec4 outputColor;

void main()
{
outputColor = vec4(1.0f, 1.0f, 1.0f, 1.0f);
}



BTW, Is http://www.arcsynthesis.org/gltut/ a good choice for beginner to learn opengl?

tonyo_au
03-21-2012, 09:42 PM
The site look quite good to me. I can't explain you speed problem. Have you tried compiling in release mode rather than debug?