NOTE: You might find it helpful to do a web search on Visual C++
and GLUT to find step by step instructions for a particular version
of VC++. Each version of VC++ seems to move around some standard files
and change the menus. I've been doing my testing with Visual Studio 
Express 10 which can be downloaded for free.


Assuming that you are using GLUT as in the textbook and the 
examples you have the chice of using the old standard version glut 3.7
which is widely available on the web but has not been changed in
many years. Freeglut is a more up to date version and should be code
compatible with any application using the original GLUT. Freeglut adds
some additional functionality most of which we wiil not discuss here. 
However if you use freeglut the two lines of code can be added to your
application

    glutInitContextVersion( 3, 2 );
	glutInitContextProfile( GLUT_CORE_PROFILE );

The first let's you check if your implementation supports a particular
level of OpenGL (in this case OpenGL 3.2). THe second allows you to chose
to use the CORE or COMPATIBILITY profiles. In this example, by specifiying the 
core profile, the program will not compile and link unless it is pure 3.2. Using
the COMPATIBILITY profile, if it is supported on your system, you can compile and
run applications containing legacy functions.

Here's a standard installation for OpenGL using VC:

Download both GLEW and GLUT or freeglut from the Web. All are available as either
source or Windows binaries. If you use VC, you only need the binaries. 

The Opengl32.dll file should already be under Windows/System32.
Opengl32.lib should already be in the lib folder
for VC++.  The oinclude file gl.h should be in a folder called GL under the
include folder for VC++ All the above files come with Windows and VC++.
The location of these folders should be somewhere like (depending on
your version of VC)

Program Files/Miicrosoft Visual Studion 10.0/VC/lib
Program Files/Miicrosoft Visual Studion 10.0/VC/include/GL

In the distribtions for GLEW, GLUT and freeglut, you will find
one or more dll files, .h files and .lib files. Each of these files
should be copied to the corresponding directories where you found
opengl32.dll, opengl.lib and gl.h.

Now you are ready to create an application.

You want to create an empty  application. On older versions of 
VC++, you created a console application.

Under project properties, click on linker and then on inputs.
Add glew32.lib and either glut32.lib or freeglut.lib to the end
of the list. Don't forget to put a ; at the end of each name.

Now you can build an application. 

If you are using examples from the book, you need the include files Angel.h, vector.h, matrix.h 
and CheckError.h and the .cpp file InitShader.cpp. You can put them in the same directory as 
your project code or in one of the standard locations VC will search. Once you do this you
can just add your application code to the project and build it.

Be careful as to where you put your shaders. Generally, you will have the shaders in the same
directory as your executable.

Notes:

1. The reason we need GLEW is that the version of OpenGL provided by Windows is very old
and your graphics card is almost certainly more advanced. GLEW (the OpenGL Extension Wrangler)
will determine which functions are supported by your hardware and get their entry points.
All you need do is add the include

#include <GL/glew.h>

before the include for GLUT and execute

glewInit();

after glutCreateWindow. The include is taken care of for you if you use Angel.h.

2. The version of GLSL that we have in our examples (1.5) may be past the version supported by your graphics card.
You may have to one or more of the following:

(a) remove the #version line from each shader
(2) replace the in qualifier on a vertex shader with the attribute qaulifer.
(3) replave out qualifiers on a vertex shader and in qualifiers in a fragment shader with the varying qualifier
(4) use gl_FragColor (a built in variable) for the output of the fragment shader

On my system (an iMac running Windwos XP under Bootcamp) all I had to do was (a). However, for reasons I still don't
understand, I had to make my vertex shader (bit not my fragment shader) a single line by removing all the end of lines/returns.