004_olympic_logo

/*
    Lab Assignment: Olympic Logo
    Date:           February 22, 2015
*/
#include "stdafx.h"
#include <iostream>
#include <glut.h>  // GLUT, include glu.h and gl.h

using namespace std;

/* Global variables */
char title[] = "Olympic Logo";

/* Initialize OpenGL Graphics */
void initGL()
{
   glClearColor(0.40f, 0.612f, 0.94f, 1.0f); // Set background color to white and opaque
   glClearDepth(1.0f);                   // Set background depth to farthest
   glEnable(GL_DEPTH_TEST);   // Enable depth testing for z-culling
   glDepthFunc(GL_LEQUAL);    // Set the type of depth-test
   glShadeModel(GL_SMOOTH);   // Enable smooth shading
   glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);  // Nice perspective corrections
}

/* Handler for window-repaint event. Called back when the window first appears and
   whenever the window needs to be re-painted. */
void display()
{
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear color and depth buffers
   glMatrixMode(GL_MODELVIEW);     // To operate on model-view matrix

   // Render a color-cube consisting of 6 quads with different colors
   glLoadIdentity();                 // Reset the model-view matrix
   glTranslatef(-1.5f, 1.0f, -7.0f);  // Move right and into the screen

   // Your code here...
   const int totalNumberOfRing = 5;
   int breakingPoint = ceil(((float) totalNumberOfRing) / 2);

   float innerRadius = 0.05f,
         outerRadius = 0.50f,
         distance = (outerRadius / 100) * 60,
         x = 0.0f,
         y = 0.0f;

   float colors[totalNumberOfRing][3] = {
                                            {0, 0, 1},
                                            {0, 0, 0},
                                            {1, 0, 0},
                                            {1, 1, 0},
                                            {0, 1, 0}
                                       };

   for (int ringIndex = 1; ringIndex <= totalNumberOfRing; ringIndex++)
   {
        glTranslatef(x, y, 0.0f);
        glColor3f(colors[ringIndex - 1][0], colors[ringIndex - 1][1], colors[ringIndex - 1][2]);
        glutSolidTorus(0.05f, 0.50f, 32, 32);

        if (ringIndex == breakingPoint)
        {
            y -= (outerRadius * 2) - distance;
            x -= (ringIndex * (outerRadius * 2) - distance) - (outerRadius * 2);
        }
        else
        {
            y = 0;
            x = (outerRadius * 2) - distance;
        }
   }

   glutSwapBuffers();  // Swap the front and back frame buffers (double buffering)
}

/* Handler for window re-size event. Called back when the window first appears and
   whenever the window is re-sized with its new width and height */
void reshape(GLsizei width, GLsizei height)
{  // GLsizei for non-negative integer
   // Compute aspect ratio of the new window
   if (height == 0)
   {
       height = 1;                // To prevent divide by 0
   }

   GLfloat aspect = (GLfloat)width / (GLfloat)height;

   // Set the viewport to cover the new window
   glViewport(0, 0, width, height);

   // Set the aspect ratio of the clipping volume to match the viewport
   glMatrixMode(GL_PROJECTION);  // To operate on the Projection matrix
   glLoadIdentity();             // Reset
   // Enable perspective projection with fovy, aspect, zNear and zFar
   gluPerspective(45.0f, aspect, 0.1f, 100.0f);
}

/* Main function: GLUT runs as a console application starting at main() */
int main(int argc, char** argv)
{
   glutInit(&argc, argv);            // Initialize GLUT
   glutInitDisplayMode(GLUT_DOUBLE); // Enable double buffered mode
   glutInitWindowSize(640, 480);   // Set the window's initial width & height
   glutInitWindowPosition(50, 50); // Position the window's initial top-left corner
   glutCreateWindow(title);          // Create window with the given title
   glutDisplayFunc(display);       // Register callback handler for window re-paint event
   glutReshapeFunc(reshape);       // Register callback handler for window re-size event
   initGL();                       // Our own OpenGL initialization
   glutMainLoop();                 // Enter the infinite event-processing loop
   return 0;
}