void InitializeOpenGL(int width, int height)
{
glEnable( GL_DEPTH_TEST ); // Enables Depth Test i.e enables use of depth buffer for drawing
glEnable( GL_TEXTURE_2D ); // Enable Texture Mapping
SizeOpenGLScreen(width, height); // resize the OpenGL Viewport to the given height and width
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_KEYDOWN:
switch(wParam) { // Check if we hit a key
case VK_ESCAPE: // If we hit the escape key
PostQuitMessage(0); // Send a QUIT message to the window
break;
}
break;
case WM_DESTROY: // If the window is destroyed
PostQuitMessage(0); // Send a QUIT Message to the window
break;
default: // Return by default
lRet = (long)DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
case WM_KEYDOWN:
if(wParam == VK_ESCAPE) DeInit(); // Quit if we pressed ESCAPE
break;
case WM_DESTROY: // If the window is destroyed
DeInit(); // Release memory and restore settings
break;
default: // Return by default
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
case WM_LBUTTONDOWN: // If the left mouse button was clicked
// We want to be able to turn wire frame on and off, so let's switch it
g_bRenderMode = !g_bRenderMode;
// Change the rendering mode to and from lines or triangles
if(g_bRenderMode)
{
// Render the triangles in fill mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
else
{
// Render the triangles in wire frame mode
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE: // Check if we hit the ESCAPE key.
PostQuitMessage(0); // Tell windows we want to quit
break;
}
break;
case WM_CLOSE: // If the window is closed
PostQuitMessage(0); // Tell windows we want to quit
break;
}
return DefWindowProc (hWnd, uMsg, wParam, lParam); // Return the default
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are in window mode
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
case WM_KEYDOWN:
//////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////
switch(wParam) { // Check if we hit a key
case VK_ESCAPE:
PostQuitMessage(0); // Send a QUIT message
break;
case VK_UP: // If we hit the UP arrow key
g_Camera.MoveCamera(kSpeed); // Move our camera forward by a positive speed
RenderScene(); // Redraw the screen to reflect changes
break;
case VK_DOWN: // If we hit the DOWN arrow key
g_Camera.MoveCamera(-kSpeed); // Move our camera backward by a negative speed
RenderScene(); // Redraw the screen to reflect changes
break;
}
break;
//////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////
case WM_CLOSE: // If the window is being closed
PostQuitMessage(0); // Post a QUIT message to the window; // Release memory and restore settings
break;
default: // Return by default
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
void InitializeOpenGL(int width, int height)
{
g_hDC = GetDC(g_hWnd); // This sets our global HDC
// We don't free this hdc until the end of our program
if (!bSetupPixelFormat(g_hDC)) // This sets our pixel format/information
PostQuitMessage (0); // If there's an error, quit
g_hRC = wglCreateContext(g_hDC); // This creates a rendering context from our hdc
wglMakeCurrent(g_hDC, g_hRC); // This makes the rendering context we just created the one we want to use
SizeOpenGLScreen(width, height); // Setup the screen translations and viewport
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 1;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// We check if the user hits the left mouse button,
// then change the draw style of the cylinder.
case WM_LBUTTONDOWN: // If the left mouse button was clicked
if(g_RenderMode == GLU_FILL) // Check if we were in GLU_FILL mode
g_RenderMode = GLU_LINE; // Then we need to switch to GLU_LINE mode
else
g_RenderMode = GLU_FILL; // Otherwise, we want GLU_FILL now.
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
case WM_KEYDOWN:
switch(wParam) { // Check if we hit a key
case VK_ESCAPE: // If we hit the escape key
PostQuitMessage(0); // Send a QUIT message to the window
break;
}
break;
case WM_DESTROY: // If the window is destroyed
PostQuitMessage(0); // Send a QUIT Message to the window
break;
default: // Return by default
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
void MainLoop(void)
{
bool done = false; // is our job done ? not yet !
SDL_Event event;
while(! done) // as long as our job's not done
{
while( SDL_PollEvent(& event) ) // look for events (like keystrokes, resizing etc.)
{
switch ( event.type ) // what kind of event have we got ?
{
case SDL_QUIT : // if user wishes to quit
done = true; // this implies our job is done
break;
case SDL_KEYDOWN : // if the user has pressed a key
HandleKeyPressEvent( & event. key.keysym ); // callback for handling keystrokes, arg is key pressed
break;
case SDL_KEYUP :
HandleKeyReleaseEvent(& event.key.keysym) ; // callback for handling keystrokes, arg is key released
break;
case SDL_VIDEORESIZE : // if there is a resize event
// request SDL to resize the window to the size and depth etc. that we specify
MainWindow = SDL_SetVideoMode( event.resize.w, event.resize.h, SCREEN_DEPTH, VideoFlags );
SizeOpenGLScreen(event.resize.w, event.resize.h); // now resize the OpenGL viewport
if(MainWindow == NULL) // if window resize has failed
{
cerr << " Failed resizing SDL window : " << SDL_GetError() << endl; // report error
Quit(0);
}
break;
default: // any other event
break; // nothing to do
} // switch
} // while( SDL_ ...
//////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////
// Here we check for mouse and key movements every frame
g_Camera.SetViewByMouse(); // Move the camera by the mouse
CheckForMovement(); // Check if we pressed a key
RenderScene(); // Update the screen
//////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////
} // while( ! done)
}
void InitializeOpenGL(int width, int height)
{
glEnable( GL_DEPTH_TEST ); // Enables Depth Test i.e enables use of depth buffer for drawing
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// This allows us to use texture mapping, otherwise we just use colors.
glEnable(GL_TEXTURE_2D); // Enable Texture Mapping
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
SizeOpenGLScreen(width, height); // resize the OpenGL Viewport to the given height and width
}
void GameWindow::InitOpenGL()
{
GetClientRect(m_hwnd, &m_rDimensions);
m_hdc = GetDC(m_hwnd);
if (!SetupPixelFormat())
PostQuitMessage (0);
m_hrc = wglCreateContext(m_hdc);
wglMakeCurrent(m_hdc, m_hrc);
glEnable(GL_DEPTH_TEST);
glEnable(GL_NORMALIZE);
glEnable(GL_CULL_FACE);
SizeOpenGLScreen(m_rDimensions.right, m_rDimensions.bottom);
}
void InitializeOpenGL(int width, int height)
{
g_hDC = GetDC(g_hWnd); // This sets our global HDC
// We don't free this hdc until the end of our program
if (!bSetupPixelFormat(g_hDC)) // This sets our pixel format/information
PostQuitMessage (0); // If there's an error, quit
g_hRC = wglCreateContext(g_hDC); // This creates a rendering context from our hdc
wglMakeCurrent(g_hDC, g_hRC); // This makes the rendering context we just created the one we want to use
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// This allows us to use texture mapping, otherwise we just use colors.
glEnable(GL_TEXTURE_2D); // Enable Texture Mapping
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
SizeOpenGLScreen(width, height); // Setup the screen translations and viewport
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
case WM_KEYDOWN:
switch(wParam) // Check if we hit a key
{
case VK_ESCAPE: // If we hit the escape key
PostQuitMessage(0); // Send a QUIT message to the window
break;
}
break;
case WM_CLOSE: // If the window is being closes
PostQuitMessage(0); // Send a QUIT Message to the window
break;
default: // Return by default
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
void InitializeOpenGL(int width, int height)
{
g_hDC = GetDC(g_hWnd); // This sets our global HDC
// We don't free this hdc until the end of our program
if (!bSetupPixelFormat(g_hDC)) // This sets our pixel format/information
PostQuitMessage (0); // If there's an error, quit
g_hRC = wglCreateContext(g_hDC); // This creates a rendering context from our hdc
wglMakeCurrent(g_hDC, g_hRC); // This makes the rendering context we just created the one we want to use
//////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////
// Since we have more than ONE primative (shape), we need to do some depth testing.
// If we do NOT have this line, you will see through all the shapes when you go behind them.
// Comment out this line and then go behind all the triangles. It's a cool effect though :)
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
//////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////
SizeOpenGLScreen(width, height); // Setup the screen translations and viewport
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are in window mode
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
case WM_LBUTTONDOWN: // If we hit the left mouse button
g_bLightmaps = !g_bLightmaps; // Turn lightmaps on/off
if(!g_bLightmaps) // If we don't want lightmaps
{
glActiveTextureARB(GL_TEXTURE1_ARB); // Turn the second texture off
glDisable(GL_TEXTURE_2D);
}
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
case WM_RBUTTONDOWN: // If we hit the right mouse button
g_bTextures = !g_bTextures; // Turn texture mapping on/off
if(!g_bTextures) // If we don't want texture mapping
{
glActiveTextureARB(GL_TEXTURE0_ARB);
glDisable(GL_TEXTURE_2D); // Disable texture mapping
}
break;
case WM_KEYDOWN:
switch(wParam) { // Check if we hit a key
case VK_ESCAPE: // If we hit the escape key
PostQuitMessage(0); // Send a QUIT message to the window
break;
case VK_SPACE: // Check if we hit the space bar
g_RenderMode = !g_RenderMode; // Change the rendering mode
// Change the rendering mode to and from lines or triangles
if(g_RenderMode)
{
// Render the triangles in fill mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
else
{
// Render the triangles in wire frame mode
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
break;
}
break;
case WM_CLOSE: // If the window is being closes
PostQuitMessage(0); // Send a QUIT Message to the window
break;
default: // Return by default
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
case WM_LBUTTONDOWN:
g_bDetail = !g_bDetail;
break;
case WM_RBUTTONDOWN: // If the left mouse button was clicked
g_bRenderMode = !g_bRenderMode;
// Change the rendering mode to and from lines or triangles
if(g_bRenderMode)
{
// Render the triangles in fill mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
else
{
// Render the triangles in wire frame mode
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
break;
case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE: // Check if we hit the ESCAPE key.
PostQuitMessage(0); // Tell windows we want to quit
break;
case VK_SPACE: // Check if we hit the SPACE bar
// To get a few different ideas of what a detail texture
// could look like, we want to change it's scale value.
// Times the current scale value by 2 and loop when it gets to 128
g_DetailScale = (g_DetailScale * 2) % 128;
// If the scale value is 0, set it to 1 again
if(g_DetailScale == 0)
g_DetailScale = 1;
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// To make the tutorial more interesting, we add an option to increase
// and decrease the height of the fog by using the + and - keys.
case VK_ADD: // Check if we hit the + key
g_FogDepth += 1; // Increase the fog height
if(g_FogDepth > 200) // Make sure we don't go past 200
g_FogDepth = 200;
break;
case VK_SUBTRACT: // Check if we hit the - key
g_FogDepth -= 1; // Decrease the fog height
if(g_FogDepth < 0) // Make sure we don't go below 0
g_FogDepth = 0;
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
}
break;
case WM_CLOSE: // If the window is closed
PostQuitMessage(0); // Tell windows we want to quit
break;
}
return DefWindowProc (hWnd, uMsg, wParam, lParam); // Return the default
}
void InitializeGL(int width, int height)
{
SizeOpenGLScreen(width, height); // resize the OpenGL Viewport to the given height and width
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
int objectID = 0;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// If we click the left mouse button, we need to process our X and Y coordinates and
// see if we hit any objects. Remember, the LOWORD and HIWORD of the lParam are the (x,y)
// coordinates of the mouse. We call RetrieveObjectID() to get the object ID we clicked on.
case WM_LBUTTONDOWN: // If the left mouse button was clicked
// Here we pass in the cursors X and Y coordinates to test for an object under the mouse.
objectID = RetrieveObjectID(LOWORD(lParam), HIWORD(lParam));
// Now we just do a switch on our object ID's to see if we hit one.
switch(objectID) // Check the objectID passed back
{
case SUN: // We hit the Sun!
MessageBox(NULL, "The Sun!", "Click", MB_OK);
break;
case EARTH: // We hit the Earth!
MessageBox(NULL, "The Earth!", "Click", MB_OK);
break;
case PLUTO: // We hit Pluto!
MessageBox(NULL, "Pluto!", "Click", MB_OK);
break;
}
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE: // Check if we hit the ESCAPE key.
PostQuitMessage(0); // Tell windows we want to quit
break;
}
break;
case WM_CLOSE: // If the window is closed
PostQuitMessage(0); // Tell windows we want to quit
break;
default: // Return by default
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are in window mode
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
case WM_LBUTTONDOWN: // If we hit the left mouse button
g_bLightmaps = !g_bLightmaps; // Turn lightmaps on/off
if(!g_bLightmaps) // If we don't want lightmaps
{
glActiveTextureARB(GL_TEXTURE1_ARB); // Turn the second texture off
glDisable(GL_TEXTURE_2D);
}
break;
case WM_RBUTTONDOWN: // If we hit the right mouse button
g_bTextures = !g_bTextures; // Turn texture mapping on/off
if(!g_bTextures) // If we don't want texture mapping
{
glActiveTextureARB(GL_TEXTURE0_ARB);
glDisable(GL_TEXTURE_2D); // Disable texture mapping
}
break;
case WM_KEYDOWN:
switch(wParam) { // Check if we hit a key
case VK_ESCAPE: // If we hit the escape key
PostQuitMessage(0); // Send a QUIT message to the window
break;
case VK_F1: // Check if we hit the space bar
g_RenderMode = !g_RenderMode; // Change the rendering mode
// Change the rendering mode to and from lines or triangles
if(g_RenderMode)
{
// Render the triangles in fill mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
else
{
// Render the triangles in wire frame mode
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
case VK_SPACE: // Check if the user hits the space bar
// This is what will create our jump effect. Before we add our jump
// velocity, we make sure that we are on the ground. This makes it
// so we can't jump infinitely and keep ramming our head into the cieling.
// This type of realism depends on your project of course. If we are on
// the ground, we can then set our velocity.y value to our jump velocity
// which will be added to our camera (or player) every frame, until the
// gravity eventually cancels it out.
if(g_Level.IsOnGround())
g_vVelocity.y = kJumpAcceleration;
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
}
break;
case WM_CLOSE: // If the window is being closes
PostQuitMessage(0); // Send a QUIT Message to the window
break;
default: // Return by default
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
void InitializeGL(int width, int height)
{
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
SizeOpenGLScreen(width, height); // resize the OpenGL Viewport to the given height and width
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// Below we check what the user types in. If they use the arrow keys
// then we want to move the sphere around (LEFT RIGHT UP and DOWN keys)
// The UP/DOWN keys increase the radius it rotates around the line, where
// the LEFT/RIGHT keys move the sphere along the line.
case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE: // Check if we hit the ESCAPE key.
PostQuitMessage(0); // Tell windows we want to quit
break;
case VK_UP: // Check if we hit the UP ARROW key.
g_vPosition.y += 0.01f; // Increase the rotation radius
break;
case VK_DOWN: // Check if we hit the DOWN ARROW key.
g_vPosition.y -= 0.01f; // Decrease the rotation radius
break;
case VK_LEFT: // Check if we hit the LEFT ARROW key.
g_vPosition.x -= 0.01f; // Move the sphere left along the line
break;
case VK_RIGHT: // Check if we hit the RIGHT ARROW key.
g_vPosition.x += 0.01f; // Move the sphere right along the line
break;
}
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
break;
case WM_CLOSE: // If the window is closed
PostQuitMessage(0); // Tell windows we want to quit
break;
default: // Return by default
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
// Below we define our controls for this tutorial. The controls are:
// Right Mouse Click - Cycles through the upper (torso) animations
// Left Mouse Click - Cycles through the lower (legs) animations
// Left Arrow Key - Spins the model to the left
// Right Arrow Key - Spins the model to the right
// Up Arrow Key - Moves the camera closer to the model
// Right Arrow Key - Moves the camera farther away from the model
// W - Changes the Render mode from normal to wire frame.
// Escape - Quits
//////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////
case WM_LBUTTONDOWN: // If the left mouse button was clicked
// Increase the leg's current animation to the next animation
IncreaseCharacterAnimation( &g_Model, kLower);
break;
case WM_RBUTTONDOWN: // If the right mouse button was clicked
// Increase the torso's current animation to the next animation
IncreaseCharacterAnimation( &g_Model, kUpper );
break;
//////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////
case WM_KEYDOWN: // If we pressed a key
switch(wParam) // Check if we hit a key
{
case VK_ESCAPE: // If we hit the escape key
PostQuitMessage(0); // Send a QUIT message to the window
break;
case VK_LEFT: // If the LEFT arrow key was pressed
g_RotationSpeed -= 0.05f; // Decrease the rotation speed (eventually rotates left)
break;
case VK_RIGHT: // If the RIGHT arrow key is pressed
g_RotationSpeed += 0.05f; // Increase the rotation speed (rotates right)
break;
case VK_UP: // If the UP arrow key was pressed
g_TranslationZ += 2; // Move the camera position forward along the Z axis
break;
case VK_DOWN: // If the DOWN arrow key is pressed
g_TranslationZ -= 2; // Move the camera position back along the Z axis
break;
case 'W':
g_RenderMode = !g_RenderMode; // Change the rendering mode
// Change the rendering mode to and from lines or triangles
if(g_RenderMode)
{
// Render the triangles in fill mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
else
{
// Render the triangles in wire frame mode
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
break;
}
break;
case WM_CLOSE: // If the window is being closed
PostQuitMessage(0); // Send a QUIT Message to the window
break;
default: // Return by default
lRet = (LONG)DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
//////////// *** NEW *** ////////// *** NEW *** ///////////// *** NEW *** ////////////////////
// Below we define our controls for this simple tutorial.
// The controls are:
// Left Mouse Button - Changes the Render mode from normal to wireframe.
// Right Mouse Button - Turns lighting On/Off
// Left Arrow Key - Spins the model to the left
// Right Arrow Key - Spins the model to the right
// Escape - Quits
case WM_LBUTTONDOWN: // If the left mouse button was clicked
if(g_ViewMode == GL_TRIANGLES) { // We our drawing mode is at triangles
g_ViewMode = GL_LINE_STRIP; // Go to line stips
} else {
g_ViewMode = GL_TRIANGLES; // Go to triangles
}
break;
case WM_RBUTTONDOWN: // If the right mouse button was clicked.
g_bLighting = !g_bLighting; // Turn lighting ON/OFF
if(g_bLighting) { // If lighting is ON
glEnable(GL_LIGHTING); // Enable OpenGL lighting
} else {
glDisable(GL_LIGHTING); // Disable OpenGL lighting
}
break;
case WM_KEYDOWN: // If we pressed a key
switch(wParam) { // Check if we hit a key
case VK_ESCAPE: // If we hit the escape key
PostQuitMessage(0); // Send a QUIT message to the window
break;
case VK_LEFT: // If the LEFT arrow key was pressed
g_RotationSpeed += 0.01f; // Decrease the rotation speed (eventually rotates left)
break;
case VK_RIGHT: // If the RIGHT arrow key is pressed
g_RotationSpeed -= 0.01f; // Increase the rotation speed (rotates right)
break;
}
break;
case WM_CLOSE: // If the window is being closed
PostQuitMessage(0); // Send a QUIT Message to the window
break;
default: // Return by default
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
case WM_LBUTTONDOWN: // If we hit the left mouse button
// Change the rendering mode to lines or triangles depending on it's current status
g_bRenderMode = !g_bRenderMode;
// Change the rendering mode to and from lines or triangles
if(g_bRenderMode)
{
// Render the triangles in fill mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
else
{
// Render the triangles in wire frame mode
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
break;
case WM_RBUTTONDOWN: // If the right mouse button was clicked.
g_bLighting = !g_bLighting; // Turn lighting ON/OFF
if(g_bLighting) // If lighting is ON
{
glEnable(GL_LIGHTING); // Enable OpenGL lighting
}
else
{
glDisable(GL_LIGHTING); // Disable OpenGL lighting
}
break;
case WM_KEYDOWN: // If we hit a key
switch (wParam) // Check which key we hit
{
case VK_ESCAPE: // If we hit ESCAPE
PostQuitMessage(0); // Tell windows we want to quit
break;
case VK_ADD: // If we hit '+'
g_MaxSubdivisions += 1; // Increase the current max subdivisions
// Make sure we don't go over 10 subdivisions, otherwise it will get crazy
if(g_MaxSubdivisions > 10) g_MaxSubdivisions = 10;
// Destroy the octree and debug lines and create a new one with the new info
RecreateOctree();
break;
case VK_SUBTRACT: // If we hit '-'
g_MaxSubdivisions -= 1; // Decrease the current max subdivisions
// Make sure we don't go below zero subdivisions
if(g_MaxSubdivisions < 0) g_MaxSubdivisions = 0;
// Destroy the octree and debug lines and create a new one with the new info
RecreateOctree();
break;
case VK_F5: // If we hit F5
g_MaxTriangles += 20; // Increase the max triangle count by 20
// Make sure we don't go above 2000
if(g_MaxTriangles > 2000) g_MaxTriangles = 2000;
// Destroy the octree and debug lines and create a new one with the new info
RecreateOctree();
break;
case VK_F6: // If we hit F6
g_MaxTriangles -= 20; // Decrease the max triangle count by 20
// Make sure we don't go below 0 (0 would produce as many nodes as triangles)
if(g_MaxTriangles < 0) g_MaxTriangles = 0;
// Destroy the octree and debug lines and create a new one with the new info
RecreateOctree();
break;
}
break;
case WM_CLOSE: // If the window is closed
PostQuitMessage(0); // Tell windows we want to quit
break;
default: // Return by default
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// Below we check what the user types in. If they use the arrow keys
// then we want to move the triangle around (LEFT RIGHT UP and DOWN keys)
case WM_KEYDOWN:
switch(wParam)
{
case VK_ESCAPE: // Check if we hit the ESCAPE key.
PostQuitMessage(0); // Tell windows we want to quit
break;
case VK_UP: // Check if we hit the UP ARROW key.
vTriangle[0].x += 0.01f; // Move the left point of the triangle to the left
vTriangle[1].x += 0.01f; // Move the right point of the triangle to the left
vTriangle[2].x += 0.01f; // Move the top point of the triangle to the left
break;
case VK_DOWN: // Check if we hit the DOWN ARROW key.
vTriangle[0].x -= 0.01f; // Move the left point of the triangle to the left
vTriangle[1].x -= 0.01f; // Move the right point of the triangle to the left
vTriangle[2].x -= 0.01f; // Move the top point of the triangle to the left
break;
case VK_LEFT: // Check if we hit the LEFT ARROW key.
vTriangle[0].z -= 0.01f; // Move the left point of the triangle back
vTriangle[1].z -= 0.01f; // Move the right point of the triangle back
vTriangle[2].z -= 0.01f; // Move the top point of the triangle back
break;
case VK_RIGHT: // Check if we hit the RIGHT ARROW key.
vTriangle[0].z += 0.01f; // Move the left point of the triangle forward
vTriangle[1].z += 0.01f; // Move the right point of the triangle forward
vTriangle[2].z += 0.01f; // Move the top point of the triangle forward
break;
}
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
case WM_CLOSE: // If the window is closed
PostQuitMessage(0); // Tell windows we want to quit
break;
default: // Return by default
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
void InitializeOpenGL(int width, int height)
{
g_hDC = GetDC(g_hWnd); // This sets our global HDC
// We don't free this hdc until the end of our program
if (!bSetupPixelFormat(g_hDC)) // This sets our pixel format/information
PostQuitMessage (0); // If there's an error, quit
g_hRC = wglCreateContext(g_hDC); // This creates a rendering context from our hdc
wglMakeCurrent(g_hDC, g_hRC); // This makes the rendering context we just created the one we want to use
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// It's a good idea to have the color of our background the same color as our darkness.
// Since we are using white as our light color, we will set our background color to black.
glClearColor(0, 0, 0, 1); // Set our background color to black (0, 0, 0)
// Below we create 2 arrays of color. The first one, ambience[], is the default color
// when there is no light shinning on the polygon. If we didn't have an ambience, the
// polygon's would be extremely dark so you couldn't see them. Since we are using pure white
// as our light color, we will set the ambience half of that, so it's not TOO dark when the light
// isn't shinning on the surface of a polygon. The second array, "diffuse", is the color
// of the light that is shinning. We chose pure white. The first 3 are the R G B values.
// (0, 0, 0) is pure black, where (1, 1, 1) is pure white. The last index is the alpha value.
// Don't worry about that now. For our ambience color we choose a dark grey light source.
// For our diffuse color, we chose a half and half between full black light and full white.
float ambience[4] = {0.3f, 0.3f, 0.3f, 1.0}; // The color of the light in the world
float diffuse[4] = {0.5f, 0.5f, 0.5f, 1.0}; // The color of the positioned light
// To set the ambience of our world, we need to give OpenGL our array of values.
// OpenGL allows us to have multiple lights. The number of lights is dependant on GL_MAX_LIGHTS.
// We will use a OpenGL define for the first usable light, GL_LIGHT0. After we specify a
// light to use, we pass in the flag that tells OpenGL we are setting the ambience, followed
// by our ambience array. To set the diffuse color, we do the same thing but use GL_DIFFUSE
// and our diffuse array.
glLightfv( GL_LIGHT0, GL_AMBIENT, ambience ); // Set our ambience values (Default color without direct light)
glLightfv( GL_LIGHT0, GL_DIFFUSE, diffuse ); // Set our diffuse color (The light color)
// Next, we need to set the POSITION of our light. We can have many lights at many positions.
// In this tutorial, we will just do one light, but feel free to add more. Use GL_LIGHT1 next.
// We have our light position global so we can change it with the '+' and '-' keys.
// Our default posiiton stored in g_LightPosition is (0, 1, 0, 1). This should place our
// light position directly above the middle pyramid. The last value in the g_LightPosition array
// tells OpenGL if we want our light position to be a DIRECTION or a POSITION. If the
// value is a 1, that means it is just a position, otherwise it's a direction from our camera.
// If we have it a direction , it lights up everything in that direction (or vector) from
// our eye, or in other words our camera. If we say it's a position, it takes the values
// as an X Y and Z position in the world. Then it lights up everything around it. That is
// what we want, so we have a 1 to say that. Once again, we pass in the light we are setting,
// then GL_POSITION to let OpenGL we are setting the light position, the pass in our array
// holding the position values.
glLightfv( GL_LIGHT0, GL_POSITION, g_LightPosition ); // This Sets our light position
// After we initialize a particular light, we need to turn it on.
// We use the glEnable() function to do so, then pass in the light to turn on.
glEnable( GL_LIGHT0 ); // Turn this light on
// That is enough though, we still need to allow lighting to take place.
// Just because the light switch is on, doesn't mean we have power :)
// This works just like fog, once you init everything, you need to allow it to be displayed.
glEnable( GL_LIGHTING ); // This turns on lighting
// This next line allows us to use colors on our polygons during lighting.
// If we did not have this line it would turn our pyramids white.
glEnable(GL_COLOR_MATERIAL); // Allow color to show during lighting
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
SizeOpenGLScreen(width, height); // Setup the screen translations and viewport
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
case WM_KEYDOWN: // If we pressed a key
switch(wParam) // Check if we hit a key
{
case VK_ESCAPE: // If we hit the escape key
PostQuitMessage(0); // Send a QUIT message to the window
break;
case VK_LEFT: // If the LEFT arrow key was pressed
g_RotationSpeed -= 0.05f; // Decrease the rotation speed (eventually rotates left)
break;
case VK_RIGHT: // If the RIGHT arrow key is pressed
g_RotationSpeed += 0.05f; // Increase the rotation speed (rotates right)
break;
case VK_UP: // If the UP arrow key was pressed
g_TranslationZ += 2; // Move the camera position forward along the Z axis
break;
case VK_DOWN: // If the DOWN arrow key is pressed
g_TranslationZ -= 2; // Move the camera position back along the Z axis
break;
case 'W':
g_RenderMode = !g_RenderMode; // Change the rendering mode
// Change the rendering mode to and from lines or triangles
if(g_RenderMode)
{
// Render the triangles in fill mode
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
}
else
{
// Render the triangles in wire frame mode
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
}
break;
}
break;
case WM_CLOSE: // If the window is being closed
PostQuitMessage(0); // Send a QUIT Message to the window
break;
default: // Return by default
lRet = (LONG)DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
// We added some more controls to increase the spheres and turn frustum
// culling ON/OFF.
case WM_LBUTTONDOWN: // If the left mouse button was clicked
g_bIgnoreFrustum = !g_bIgnoreFrustum;
break;
case WM_KEYDOWN: // If we hit a key
switch (wParam) // Check which key we hit
{
case VK_ESCAPE: // If we hit ESCAPE
PostQuitMessage(0); // Tell windows we want to quit
break;
case VK_ADD: // If we hit '+'
g_MaxSpheres += 10; // Increase the amount of spheres
if(g_MaxSpheres > MAX_SPHERES) // If we went over the limit
{
g_MaxSpheres = MAX_SPHERES; // Set the max back to the limit
}
break;
case VK_SUBTRACT: // if we hit '-'
g_MaxSpheres -= 10; // Decrease the amount of spheres
if(g_MaxSpheres < 0) // If we went below zero
{
g_MaxSpheres = 0; // Set the amount of spheres back to zero
}
break;
case 'c':
case 'C':
case VK_SPACE: // If we hit 'C' or the Space bar
g_bIgnoreFrustum = !g_bIgnoreFrustum; // Turn frustum culling on and off
break;
}
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
case WM_CLOSE: // If the window is closed
PostQuitMessage(0); // Tell windows we want to quit
break;
default: // Return by default
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}
LRESULT CALLBACK WinProc(HWND hWnd,UINT uMsg, WPARAM wParam, LPARAM lParam)
{
LONG lRet = 0;
PAINTSTRUCT ps;
switch (uMsg)
{
case WM_SIZE: // If the window is resized
if(!g_bFullScreen) // Do this only if we are NOT in full screen
{
SizeOpenGLScreen(LOWORD(lParam),HIWORD(lParam));// LoWord=Width, HiWord=Height
GetClientRect(hWnd, &g_rRect); // Get the window rectangle
if(g_hDC) RenderScene(); // Redraw the scene if we have a valid hdc
}
break;
case WM_PAINT: // If we need to repaint the scene
BeginPaint(hWnd, &ps); // Init the paint struct
if(g_hDC) RenderScene(); // Redraw the scene
EndPaint(hWnd, &ps); // EndPaint, Clean up
break;
case WM_LBUTTONDOWN: // If we hit the left mouse button
g_RenderMode = !g_RenderMode; // Change the rendering mode
// Change the rendering mode to lines or triangles, depending on it's current status
if(g_RenderMode) {
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); // Render the triangles in fill mode
}
else {
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); // Render the triangles in wire frame mode
}
break;
case WM_RBUTTONDOWN: // If the right mouse button was clicked.
g_bLighting = !g_bLighting; // Turn lighting ON/OFF
if(g_bLighting) { // If lighting is ON
glEnable(GL_LIGHTING); // Enable OpenGL lighting
} else {
glDisable(GL_LIGHTING); // Disable OpenGL lighting
}
break;
case WM_KEYDOWN: // If we hit a key
switch (wParam) // Check which key we hit
{
case VK_ESCAPE: // If we hit ESCAPE
PostQuitMessage(0); // Tell windows we want to quit
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
case VK_SPACE: // If we hit the space bar
g_bDisplayNodes = !g_bDisplayNodes; // Turn the debug lines on/off
break;
case 'F': // Check if hit the 'F' key
g_bFog = !g_bFog; // Turn fog on/off
if( g_bFog ) // If fog is turned on
{
// Set the background color to grey and enable fog
glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
glEnable(GL_FOG);
}
else
{
// Turn the color back to blue'ish purple and disable fog
glClearColor(0.5f, 0.5f, 1.0f, 1.0f);
glDisable(GL_FOG);
}
break;
/////// * /////////// * /////////// * NEW * /////// * /////////// * /////////// *
}
break;
case WM_DESTROY: // If the window is destroyed
PostQuitMessage(0); // Tell windows we want to quit
break;
default: // Return by default
lRet = DefWindowProc (hWnd, uMsg, wParam, lParam);
break;
}
return lRet; // Return by default
}