day and night effect in opengl c++ - c++

Question

Well, I'm trying to make the day/night cycle in a scene using opengl with c++. I've tried glutTimerFunc. Although I 've bounded the time slice to be 10000 ms = 10 s, it gave me a very fast flipping effect.
Here is what I have done.
void turn (int value){
if(night)
{
glDisable(GL_LIGHT0);
glEnable(GL_LIGHT1);
night=!night;
}
else
{
glDisable(GL_LIGHT1);
glEnable(GL_LIGHT0);
night=!night;
}
//glutPostRedisplay();
glutTimerFunc(10000,&turn,2);
}
And in DrawGLScene function I 've called that function. And here is the WinMain function:
int WINAPI WinMain( HINSTANCE hInstance, // Instance
HINSTANCE hPrevInstance, // Previous Instance
LPSTR lpCmdLine, // Command Line Parameters
int nCmdShow) // Window Show State
{
MSG msg; // Windows Message Structure
BOOL done=FALSE; // Bool Variable To Exit Loop
// Ask The User Which Screen Mode They Prefer
//if (MessageBox(NULL,"Would You Like To Run In Fullscreen Mode?", "Start FullScreen?",MB_YESNO|MB_ICONQUESTION)==IDNO)
//{
fullscreen=FALSE; // Windowed Mode
//}
// Create Our OpenGL Window
if (!CreateGLWindow("day night",700,500,16,fullscreen))
{
return 0; // Quit If Window Was Not Created
}
glutTimerFunc(10000,&turn,2);
//turn(1);
while(!done) // Loop That Runs While done=FALSE
{
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE)) // Is There A Message Waiting?
{
if (msg.message==WM_QUIT) // Have We Received A Quit Message?
{
done=TRUE; // If So done=TRUE
}
else // If Not, Deal With Window Messages
{
TranslateMessage(&msg); // Translate The Message
DispatchMessage(&msg); // Dispatch The Message
}
}
else // If There Are No Messages
{
// Draw The Scene. Watch For ESC Key And Quit Messages From DrawGLScene()
if (active) // Program Active?
{
if (keys[VK_ESCAPE]) // Was ESC Pressed?
{
done=TRUE; // ESC Signalled A Quit
}
else // Not Time To Quit, Update Screen
{
DrawGLScene(); // Draw The Scene
SwapBuffers(hDC); // Swap Buffers (Double Buffering)
}
}
if (keys[VK_F1]) // Is F1 Being Pressed?
{
keys[VK_F1]=FALSE; // If So Make Key FALSE
KillGLWindow(); // Kill Our Current Window
fullscreen=!fullscreen; // Toggle Fullscreen / Windowed Mode
// Recreate Our OpenGL Window
if (!CreateGLWindow("day night",700,500,16,fullscreen))
{
return 0; // Quit If Window Was Not Created
}
}
}
}
// Shutdown
KillGLWindow(); // Kill The Window
return (msg.wParam); // Exit The Program
}

Answer 1

If your DrawGLScene has been registered using glutDisplayFunc and is therefore called to draw each frame then you'll also be (re)registering your timer function every time you redraw the frame, i.e. every time you call glutPostRedisplay().
To start the timer sequence you should just call glutTimerFunc once, before you call glutMainLoop, and not call it in DrawGLScene.
It's still necessary to call glutTimerFunc within the timer function to initiate the next flip.
EDIT I see you're not even using glutMainLoop. This means that your call to glutTimerFunc isn't doing anything. GLUT based handlers only work when they're dispatched by the glutMainLoop function.
The only reason your code is doing anything at all is because you're calling DrawGLScene within a Windows event loop which then directly calls your timer function in each pass through the Windows event loop. This is the source of the unexpectedly high frequency.
If you intend to stick with using the Windows event model then you'd be better off just using standard Windows timer events (i.e. SetTimer) to handle the flips.
Alternatively rewrite your code to use glutMainLoop and have all of the keypresses and other events handled by GLUT.

Answer 2

This is because real day/night is not a boolean, it is a gradual change between day and night. In addition, only 10 seconds is a very short day/night cycle- you usually want a few minutes at least.