These istructions are about setting the environment (compiler, libraries, etc.) to compile and execute OpenGL + Glut + Glew programs, with a final section about HW0 assignement of CS184.1x course on edX. They have been tested using CodeBlocks 10.05 on Windows 8 platform, but they should work on any flauvor of Windows. CodeBlocks is already able to compile OpenGL programs, but if you need to use Glut + Glew utility libraries you have to add these libraries to the system and modify the options of the project.

Steps to do:

• Download GLUT library (I used the FreeGlut 2.8.1 MingW version, because is more upated and it is fully compatible with the original one): inside the zip file there are some folders. Copy the content of the include/GL folder inside "\MinGW\include\GL", the content of the lib folder inside "\MinGW\lib" and the content of the bin folder (the DLL) inside your system folder (usually C:\Windows\System32)
• Download Glew library: inside the zip file there are some folders, as in the previous library, make the same steps as before.

Now that we have the libraries installed, we have to create a new project with the right settings.

• Create a new Console Application project as usual
• Go to the Build Options and add the following libraries inside the Linker settings panel on the Link libraries column: glew32s, freeglut, glu32, opengl32, user32, kernel32 (obviously every library stays in a different row)
• In the Compiler settings panel, go to the Other options subpanel and add -DGLEW_STATIC. Then in the #defines subpanel add GLEW_STATIC

At this point you have to write some OpenGL + Glut + Glew code and all should work correctly.

This is an example

                    /*
                     * GLUT Shapes Demo
                     *
                     * Written by Nigel Stewart November 2003
                     *
                     * This program is test harness for the sphere, cone
                     * and torus shapes in GLUT.
                     *
                     * Spinning wireframe and smooth shaded shapes are
                     * displayed until the ESC or q key is pressed.  The
                     * number of geometry stacks and slices can be adjusted
                     * using the + and - keys.
                     */
                    
                    #include 
                    
                    #include 
                    
                    static int slices = 16;
                    static int stacks = 16;
                    
                    /* GLUT callback Handlers */
                    
                    static void resize(int width, int height)
                    {
                        const float ar = (float) width / (float) height;
                    
                        glViewport(0, 0, width, height);
                        glMatrixMode(GL_PROJECTION);
                        glLoadIdentity();
                        glFrustum(-ar, ar, -1.0, 1.0, 2.0, 100.0);
                    
                        glMatrixMode(GL_MODELVIEW);
                        glLoadIdentity() ;
                    }
                    
                    static void display(void)
                    {
                        const double t = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
                        const double a = t*90.0;
                    
                        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
                        glColor3d(1,0,0);
                    
                        glPushMatrix();
                            glTranslated(-2.4,1.2,-6);
                            glRotated(60,1,0,0);
                            glRotated(a,0,0,1);
                            glutSolidSphere(1,slices,stacks);
                        glPopMatrix();
                    
                        glPushMatrix();
                            glTranslated(0,1.2,-6);
                            glRotated(60,1,0,0);
                            glRotated(a,0,0,1);
                            glutSolidCone(1,1,slices,stacks);
                        glPopMatrix();
                    
                        glPushMatrix();
                            glTranslated(2.4,1.2,-6);
                            glRotated(60,1,0,0);
                            glRotated(a,0,0,1);
                            glutSolidTorus(0.2,0.8,slices,stacks);
                        glPopMatrix();
                    
                        glPushMatrix();
                            glTranslated(-2.4,-1.2,-6);
                            glRotated(60,1,0,0);
                            glRotated(a,0,0,1);
                            glutWireSphere(1,slices,stacks);
                        glPopMatrix();
                    
                        glPushMatrix();
                            glTranslated(0,-1.2,-6);
                            glRotated(60,1,0,0);
                            glRotated(a,0,0,1);
                            glutWireCone(1,1,slices,stacks);
                        glPopMatrix();
                    
                        glPushMatrix();
                            glTranslated(2.4,-1.2,-6);
                            glRotated(60,1,0,0);
                            glRotated(a,0,0,1);
                            glutWireTorus(0.2,0.8,slices,stacks);
                        glPopMatrix();
                    
                        glutSwapBuffers();
                    }
                    
                    
                    static void key(unsigned char key, int x, int y)
                    {
                        switch (key)
                        {
                            case 27 :
                            case 'q':
                                exit(0);
                                break;
                    
                            case '+':
                                slices++;
                                stacks++;
                                break;
                    
                            case '-':
                                if (slices>3 && stacks>3)
                                {
                                    slices--;
                                    stacks--;
                                }
                                break;
                        }
                    
                        glutPostRedisplay();
                    }
                    
                    static void idle(void)
                    {
                        glutPostRedisplay();
                    }
                    
                    const GLfloat light_ambient[]  = { 0.0f, 0.0f, 0.0f, 1.0f };
                    const GLfloat light_diffuse[]  = { 1.0f, 1.0f, 1.0f, 1.0f };
                    const GLfloat light_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
                    const GLfloat light_position[] = { 2.0f, 5.0f, 5.0f, 0.0f };
                    
                    const GLfloat mat_ambient[]    = { 0.7f, 0.7f, 0.7f, 1.0f };
                    const GLfloat mat_diffuse[]    = { 0.8f, 0.8f, 0.8f, 1.0f };
                    const GLfloat mat_specular[]   = { 1.0f, 1.0f, 1.0f, 1.0f };
                    const GLfloat high_shininess[] = { 100.0f };
                    
                    /* Program entry point */
                    
                    int main(int argc, char *argv[])
                    {
                        glutInit(&argc, argv);
                        glutInitWindowSize(640,480);
                        glutInitWindowPosition(10,10);
                        glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
                    
                        glutCreateWindow("GLUT Shapes");
                    
                        glutReshapeFunc(resize);
                        glutDisplayFunc(display);
                        glutKeyboardFunc(key);
                        glutIdleFunc(idle);
                    
                        glClearColor(1,1,1,1);
                        glEnable(GL_CULL_FACE);
                        glCullFace(GL_BACK);
                    
                        glEnable(GL_DEPTH_TEST);
                        glDepthFunc(GL_LESS);
                    
                        glEnable(GL_LIGHT0);
                        glEnable(GL_NORMALIZE);
                        glEnable(GL_COLOR_MATERIAL);
                        glEnable(GL_LIGHTING);
                    
                        glLightfv(GL_LIGHT0, GL_AMBIENT,  light_ambient);
                        glLightfv(GL_LIGHT0, GL_DIFFUSE,  light_diffuse);
                        glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
                        glLightfv(GL_LIGHT0, GL_POSITION, light_position);
                    
                        glMaterialfv(GL_FRONT, GL_AMBIENT,   mat_ambient);
                        glMaterialfv(GL_FRONT, GL_DIFFUSE,   mat_diffuse);
                        glMaterialfv(GL_FRONT, GL_SPECULAR,  mat_specular);
                        glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);
                    
                        glutMainLoop();
                    
                        return EXIT_SUCCESS;
                      }
                      
                      

Compile the example in HW0 assignement for CS184.1x course on edX

Now I'm attending the CS184.1x course (Foundation on Computer Graphics) on edX, so I need to compile some examples and assignements with CodeBlocks, but they are provided in Visual Studio format and it is not possible to import in an easy way. If you want to compile you need to set up your environmente as I explained above, then you have to download the Visual Studio HW0 assignement. Then extract all the contents of the folder hw0-windows inside the zip in your CodeBlocks project folder. Add the .cpp files to your project, eventually remove the main.cpp file from the template created by CodeBlocks. As the last step is necessary to copy the FreeImage.h in "\MinGW\include", FreeImage.lib in "\MinGW\lib" and FreeImage.dll in your system folder. Finally go to the Buld Option and add the FreeImage library in Linker setting as done with the previous library.