glutPostRedisplay() causing extreme lag when drawing in GLUT - c++

Question

I am using GLUT to draw a sequence of lines and my glutPassiveMotionFunc(passiveMotion); (no button press mouse motion) draws a line from the end of the line sequence to wherever the cursor is. This project is intended to be a bezier curve tool so I also render tangents with glutMotionFunc(motion); (button hold mouse motion). At this stage there are drawLine() calls at every place the cursor is in the window. I call glutPostRedisplay();to refresh the screen at the end of each movement to get rid of the history of drawLine() calls.
The introduction of glutPostRedisplay(); makes the program lag more and more each time my display function glutDisplayFunc(myDisplay); renders a line segment.
void myMouse(int button, int state, int x, int y)
{
// If left button was clicked
if (button == GLUT_LEFT_BUTTON)
{
if (state == GLUT_DOWN)
{
Point point;
point.setxy(x, SCREEN_HEIGHT - y);
// Draw the red dot.
glColor3f(255, 0, 0);
drawDot(point);
pointsVector[0] = point;
points++;
pointsVector[points].setxy((float)x, (float)(SCREEN_HEIGHT - y));
glColor3f(0, 0, 0);
drawLine(pointsVector[points - 1], pointsVector[points]);
}
else if (state == GLUT_UP)
{
Handle.setxy(x, SCREEN_HEIGHT - y);
controlPoints[0] = pointsVector[0];
controlPoints[points].setxy(Handle.x, Handle.y);
glColor3f(0, 255, 0);
drawDot(Handle);
reverseControlPoints[0] = pointsVector[0];
ReverseHandle.x = (2 * pointsVector[points].x) - Handle.x;
ReverseHandle.y = (2 * pointsVector[points].y) - Handle.y;
reverseControlPoints[points].setxy(ReverseHandle.x, ReverseHandle.y);
glColor3f(0, 255, 0);
drawDot(ReverseHandle);
glColor3f(0, 0, 255);
drawLine(Handle, ReverseHandle);
}
}
}
void passiveMotion(int x, int y)
{
Point Cursor;
Cursor.setxy(x, SCREEN_HEIGHT - y);
if ((pointsVector[0].x != NULL) && (pointsVector[0].y != NULL))
{
drawLine(pointsVector[points], Cursor);
glutPostRedisplay();
}
}
void motion(int x, int y)
{
Point Cursor;
Cursor.setxy(x, SCREEN_HEIGHT - y);
//drawLine(pointsVector[points], Cursor);
Point reverseCursor;
reverseCursor.x = (2 * pointsVector[points].x) - Cursor.x;
reverseCursor.y = (2 * pointsVector[points].y) - Cursor.y;
drawLine(pointsVector[points], reverseCursor);
glutPostRedisplay();
}
void myDisplay()
{
glClear(GL_COLOR_BUFFER_BIT);
for (int i = 1; i < points; i++)
{
// draw main line & dot
glColor3f(255, 0, 0);
drawDot(pointsVector[i]);
glColor3f(0, 0, 0);
drawLine(pointsVector[i], pointsVector[i + 1]);
// draw tangent lines and tangent dots
glColor3f(0, 255, 0);
drawLine(controlPoints[i + 1], reverseControlPoints[i + 1]);
glColor3f(0, 0, 255);
drawDot(controlPoints[i + 1]);
drawDot(reverseControlPoints[i + 1]);
}
glFlush();
}
int main(int argc, char* argv[]) {
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(640, 500);
glutInitWindowPosition(100, 150);
glutCreateWindow("Bezier Curve");
glutDisplayFunc(myDisplay);
glutMouseFunc(myMouse);
glutPassiveMotionFunc(passiveMotion);
glutMotionFunc(motion);
myInit();
glutMainLoop();
return 0;
}

Answer 1

Hard to say for sure, however this snippet inside your display function looks suspicious.
controlPoints.push_back(Handle);
reverseControlPoints.push_back(ReverseHandle);
I don't know what Handle is exactly, however it seems like you're inserting new copies of it into your vectors with every frame, and I don't see you ever clearing them out. Also in myMouse() you're incrementing points which you then use to iterate through that ever-expanding vector. From my memory of how GLUT works, unless you explicitly set it to not repeat button presses, myMouse() won't fire just once when you click a mouse button, it will instead keep triggering the callback while you have it held down. Which means more increments to points, more eventual iterations through the vectors, and slower and slower code.