Light not apearing?

I want a light in the middle of that square and i want it to stay there when i move the camera… but why wont it apear where i put it?

  
#include <windows.h>		
#include <gl\gl.h>			
#include <gl\glu.h>		
#include <gl\glaux.h>		

HDC			hDC=NULL;		
HGLRC		hRC=NULL;		
HWND		hWnd=NULL;		
HINSTANCE	hInstance;		

bool	keys[256];			
bool	active=TRUE;		
bool	fullscreen=TRUE;	

GLfloat		yrot;

GLfloat		tranx;	

GLfloat LightAmbient[]= { 0.3f, 0.3f, 0.3f, 1.0f }; 			
GLfloat LightDiffuse[]= { 0.8f, 1.0f, 0.8f, 1.0f };				
GLfloat LightPosition[]= { 0.0f, 2.0f, 0.0f, 1.0f };

LRESULT	CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);	

GLvoid ReSizeGLScene(GLsizei width, GLsizei height)		
{
	if (height==0)										
	{
		height=1;									
	}

	glViewport(0,0,width,height);						

	glMatrixMode(GL_PROJECTION);						
	glLoadIdentity();									

	// Calculate The Aspect Ratio Of The Window
	gluPerspective(45.0f,(GLfloat)width/(GLfloat)height,0.1f,100.0f);

	glMatrixMode(GL_MODELVIEW);							
	glLoadIdentity();									
}

int InitGL(GLvoid)										
{
	glShadeModel(GL_SMOOTH);							
	glClearColor(0.0f, 0.0f, 0.2f, 0.5f);				
	glClearDepth(1.0f);									
	glEnable(GL_DEPTH_TEST);							
	glDepthFunc(GL_LEQUAL);								
	glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
   	glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient);				
    glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);				
    glLightfv(GL_LIGHT1, GL_POSITION,LightPosition);			
    glEnable(GL_LIGHT1);
    glEnable(GL_LIGHTING);							
	return TRUE;										
}

int DrawGLScene(GLvoid)									
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);	
	glLoadIdentity();									
	gluLookAt(0.0f, 3.0f, -40.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f);

	glBegin(GL_QUADS);						
		glVertex3f(-20.0f, -1.0f, -20.0f);				
		glVertex3f(-20.0f, -1.0f, 20.0f);				
		glVertex3f(20.0f, -1.0f, 20.0f);				
		glVertex3f(20.0f, -1.0f, -20.0f);				
	glEnd();
    yrot += 5.0f;							
    if (keys[VK_RIGHT])							
    {
	yrot += 5.0f;							
    }

    if (keys[VK_LEFT])							
    {
	yrot -= 5.0f;							
    }
    if (keys[VK_UP])							
    {
	tranx -= 2.0f;							
    }

	return TRUE;										
}

GLvoid KillGLWindow(GLvoid)							
{
	if (fullscreen)										
	{
		ChangeDisplaySettings(NULL,0);				
		ShowCursor(TRUE);								
	}

	if (hRC)											
	{
		if (!wglMakeCurrent(NULL,NULL))				
		{
			MessageBox(NULL,"Release Of DC And RC Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		}

		if (!wglDeleteContext(hRC))					
		{
			MessageBox(NULL,"Release Rendering Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		}
		hRC=NULL;									
	}

	if (hDC && !ReleaseDC(hWnd,hDC))					
	{
		MessageBox(NULL,"Release Device Context Failed.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		hDC=NULL;									
	}

	if (hWnd && !DestroyWindow(hWnd))				
	{
		MessageBox(NULL,"Could Not Release hWnd.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		hWnd=NULL;									
	}

	if (!UnregisterClass("OpenGL",hInstance))		
	{
		MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
		hInstance=NULL;								
	}
}

BOOL CreateGLWindow(char* title, int width, int height, int bits, bool fullscreenflag)
{
GLuint PixelFormat;
WNDCLASS wc;
DWORD dwExStyle;
DWORD dwStyle;
RECT WindowRect;
WindowRect.left=(long)0;
WindowRect.right=(long)width;
WindowRect.top=(long)0;
WindowRect.bottom=(long)height;

fullscreen=fullscreenflag;

hInstance = GetModuleHandle(NULL);
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wc.lpfnWndProc = (WNDPROC) WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO);
wc.hCursor = LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = “OpenGL”;

if (!RegisterClass(&wc))
{
MessageBox(NULL,“Failed To Register The Window Class.”,“ERROR”,MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}

if (fullscreen)
{
DEVMODE dmScreenSettings;
memset(&dmScreenSettings,0,sizeof(dmScreenSettings));
dmScreenSettings.dmSize=sizeof(dmScreenSettings);
dmScreenSettings.dmPelsWidth = width;
dmScreenSettings.dmPelsHeight = height;
dmScreenSettings.dmBitsPerPel = bits;
dmScreenSettings.dmFields=DM_BITSPERPEL|DM_PELSWIDTH|DM_PELSHEIGHT;

  if (ChangeDisplaySettings(&dmScreenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL)
  {
  
  	if (MessageBox(NULL,"The Requested Fullscreen Mode Is Not Supported By

Your Video Card. Use Windowed Mode Instead?",“NeHe GL”,MB_YESNO|MB_ICONEXCLAMATION)==IDYES)
{
fullscreen=FALSE;
}
else
{

  		MessageBox(NULL,"Program Will Now Close.","ERROR",MB_OK|MB_ICONSTOP);
  		return FALSE;								
  	}
  }

}

if (fullscreen)
{
dwExStyle=WS_EX_APPWINDOW;
dwStyle=WS_POPUP;
ShowCursor(FALSE);
}
else
{
dwExStyle=WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
dwStyle=WS_OVERLAPPEDWINDOW;
}

AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle);

// Create The Window
if (!(hWnd=CreateWindowEx( dwExStyle,
“OpenGL”,
title,
dwStyle |
WS_CLIPSIBLINGS |
WS_CLIPCHILDREN,
0, 0,
WindowRect.right-WindowRect.left,
WindowRect.bottom-WindowRect.top,
NULL,
NULL,
hInstance,
NULL)))
{
KillGLWindow();
MessageBox(NULL,“Window Creation Error.”,“ERROR”,MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}

static PIXELFORMATDESCRIPTOR pfd=
{
sizeof(PIXELFORMATDESCRIPTOR),
1,
PFD_DRAW_TO_WINDOW |
PFD_SUPPORT_OPENGL |
PFD_DOUBLEBUFFER,
PFD_TYPE_RGBA,
bits,
0, 0, 0, 0, 0, 0,
0,
0,
0,
0, 0, 0, 0,
16,
0,
0,
PFD_MAIN_PLANE,
0,
0, 0, 0
};

if (!(hDC=GetDC(hWnd)))
{
KillGLWindow();
MessageBox(NULL,“Can’t Create A GL Device Context.”,“ERROR”,MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}

if (!(PixelFormat=ChoosePixelFormat(hDC,&pfd)))
{
KillGLWindow();
MessageBox(NULL,“Can’t Find A Suitable PixelFormat.”,“ERROR”,MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}

if(!SetPixelFormat(hDC,PixelFormat,&pfd))
{
KillGLWindow();
MessageBox(NULL,“Can’t Set The PixelFormat.”,“ERROR”,MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}

if (!(hRC=wglCreateContext(hDC)))
{
KillGLWindow();
MessageBox(NULL,“Can’t Create A GL Rendering Context.”,“ERROR”,MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}

if(!wglMakeCurrent(hDC,hRC))
{
KillGLWindow();
MessageBox(NULL,“Can’t Activate The GL Rendering Context.”,“ERROR”,MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}

ShowWindow(hWnd,SW_SHOW);
SetForegroundWindow(hWnd);
SetFocus(hWnd);
ReSizeGLScene(width, height);

if (!InitGL())
{
KillGLWindow();
MessageBox(NULL,“Initialization Failed.”,“ERROR”,MB_OK|MB_ICONEXCLAMATION);
return FALSE;
}

return TRUE;
}

LRESULT CALLBACK WndProc( HWND hWnd,
UINT uMsg,
WPARAM wParam,
LPARAM lParam)
{
switch (uMsg)
{
case WM_ACTIVATE:
{
if (!HIWORD(wParam))
{
active=TRUE;
}
else
{
active=FALSE;
}

  	return 0;								
  }

  case WM_SYSCOMMAND:							
  {
  	switch (wParam)							
  	{
  		case SC_SCREENSAVE:					
  		case SC_MONITORPOWER:				
  		return 0;						
  	}
  	break;								
  }

  case WM_CLOSE:								
  {
  	PostQuitMessage(0);					
  	return 0;							
  }

  case WM_KEYDOWN:						
  {
  	keys[wParam] = TRUE;					
  	return 0;								
  }

  case WM_KEYUP:							
  {
  	keys[wParam] = FALSE;				
  	return 0;								
  }

  case WM_SIZE:								
  {
  	ReSizeGLScene(LOWORD(lParam),HIWORD(lParam));  
  	return 0;							
  }

}

// Pass All Unhandled Messages To DefWindowProc
return DefWindowProc(hWnd,uMsg,wParam,lParam);
}

int WINAPI WinMain( HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
MSG msg;
BOOL done=FALSE;

// 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;
}

// Create Our OpenGL Window
if (!CreateGLWindow(“NeHe’s OpenGL Framework”,640,480,16,fullscreen))
{
return 0;
}

while(!done)
{
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
if (msg.message==WM_QUIT)
{
done=TRUE;
}
else
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
else
{

  	if (active)								
  	{
  		if (keys[VK_ESCAPE])				
  		{
  			done=TRUE;						
  		}
  		else								
  		{
  			DrawGLScene();					
  			SwapBuffers(hDC);				
  		}
  	}

  	if (keys[VK_F1])						
  	{
  		keys[VK_F1]=FALSE;				
  		KillGLWindow();						
  		fullscreen=!fullscreen;				
  		// Recreate Our OpenGL Window
  		if (!CreateGLWindow("NeHe's OpenGL Framework",640,480,16,fullscreen))
  		{
  			return 0;						
  		}
  	}
  }

}

// Shutdown
KillGLWindow();
return (msg.wParam);
}

Position the light each frame after you call glulookat

You should also be aware that OpenGL lighting is a per-vertex operation. This means that the color of each vertex of a face will be computed based on how the light will affect that location, and then the color of the rest of the face is interpolated from those vertices.

So for example say you have a large quad, and the light shines in the center in such a way that none of the four vertices are affected by the light. In this example, you won’t see any lighting effects at all.