// OPEN_GL_test.cpp : Defines the entry point for the console application.
//
// OPEN_GL_test.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#define GL_PI 3.1415f

GLfloat xRot = 0.45f;
GLfloat yRot = 0.35f;
GLboolean bCull = glIsEnabled(GL_CULL_FACE);
GLboolean bDepth= glIsEnabled(GL_DEPTH_TEST);
GLboolean bOutline=(GLboolean)true;

// Keep track of windows changing width and height
GLfloat windowWidth;
GLfloat windowHeight;

///////////////////////////////////////////////////////////

// Called to draw scene

/**/
// This function does any needed initialization on the rendering
// context.

void SetupRC()
    {
    // Black background
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f );

    // Set drawing color to green
    glColor3f(0.0f, 1.0f, 0.0f);

    // Set color shading model to flat
    glShadeModel(GL_FLAT);

    // Clockwise-wound polygons are front facing; this is reversed
    // because we are using triangle fans
    glFrontFace(GL_CW);
    }

// Called to draw scene

void RenderScene(void)
    {
    GLfloat x,y,angle;         // Storage for coordinates and angles
    int iPivot = 1;            // Used to flag alternating colors

    // Clear the window and the depth buffer
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    // Turn culling on if flag is set
    if(bCull)
        glEnable(GL_CULL_FACE);
    else
        glDisable(GL_CULL_FACE);

    // Enable depth testing if flag is set
    if(bDepth)
        glEnable(GL_DEPTH_TEST);
    else
        glDisable(GL_DEPTH_TEST);

    // Draw the back side as a wireframe only, if flag is set
    if(bOutline)
        glPolygonMode(GL_BACK,GL_LINE);
    else
        glPolygonMode(GL_BACK,GL_FILL);

    // Save matrix state and do the rotation
    glPushMatrix();
    glRotatef(xRot, 1.0f, 0.0f, 0.0f);
    glRotatef(yRot, 0.0f, 1.0f, 0.0f);

    // Begin a triangle fan
    glBegin(GL_TRIANGLE_FAN);

    // Pinnacle of cone is shared vertex for fan, moved up z-axis
    // to produce a cone instead of a circle
    glVertex3f(0.0f, 0.0f, 75.0f);

    // Loop around in a circle and specify even points along the circle
    // as the vertices of the triangle fan

    for(angle = 0.0f; angle < (2.0f*GL_PI); angle += (GL_PI/8.0f))

        {
        // Calculate x and y position of the next vertex
        x = 50.0f*sin(angle);
        y = 50.0f*cos(angle);

        // Alternate color between red and green

        if((iPivot %2) == 0)
            glColor3f(0.0f, 1.0f, 0.0f);
        else
            glColor3f(1.0f, 0.0f, 0.0f);

        // Increment pivot to change color next time
        iPivot++;

        // Specify the next vertex for the triangle fan
        glVertex2f(x, y);
        }

    // Done drawing fan for cone
    glEnd();

    // Begin a new triangle fan to cover the bottom
    glBegin(GL_TRIANGLE_FAN);

    // Center of fan is at the origin
    glVertex2f(0.0f, 0.0f);

    for(angle = 0.0f; angle < (2.0f*GL_PI); angle += (GL_PI/8.0f))
        {
        // Calculate x and y position of the next vertex
        x = 50.0f*sin(angle);
        y = 50.0f*cos(angle);

        // Alternate color between red and green
        if((iPivot %2) == 0)
            glColor3f(0.0f, 1.0f, 0.0f);
        else
            glColor3f(1.0f, 0.0f, 0.0f);

		// Increment pivot to change color next time
        iPivot++;

        // Specify the next vertex for the triangle fan
        glVertex2f(x, y);
        }

    // Done drawing the fan that covers the bottom
    glEnd();

    // Restore transformations
    glPopMatrix();

    // Flush drawing commands
    glFlush();
    }

/**/


// Called by GLUT library when the window has changed size

void ChangeSize(GLsizei w, GLsizei h)
    {
    GLfloat aspectRatio;
    // Prevent a divide by zero
    if(h == 0)
	        h = 1;
    // Set Viewport to window dimensions
    glViewport(0, 0, w, h);

	// Reset coordinate system
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    // Establish clipping volume (left, right, bottom, top, near, far)
    aspectRatio = (GLfloat)w / (GLfloat)h;
    if (w <= h)
        {      windowWidth = 200;
		        windowHeight = 200 / aspectRatio;
						gluLookAt (0.25, -0.25, -1.5, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
	        glOrtho (-200.0, 200.0, -windowHeight, windowHeight, 1.0, -270.0);
        }
    else
        {       windowWidth = 200 * aspectRatio;
	        windowHeight = 200;
			gluLookAt (0.25, -0.25, -1.5, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
        glOrtho (-windowWidth, windowWidth, -200.0, 200.0, 1.0, -270.0);
        }

    /*glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();*/
    }

///////////////////////////////////////////////////////////



int main(int argc, char** argv)
{
glutInit(&argc, argv);
 glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (200, 200);
glutInitWindowPosition (100, 100);
 glutCreateWindow (argv[0]);
 glutDisplayFunc(RenderScene);
    glutReshapeFunc(ChangeSize);
  /*  glutTimerFunc(33, TimerFunction, 1);*/
    SetupRC();
    glutMainLoop();
return 0;
}