cg lab3 alomst (array rdy)

// glfw_30.cpp : Defines the entry point for the console application.
//  http://www.glfw.org/docs/latest/quick.html

#include "stdafx.h"
#include <time.h>
#define _USE_MATH_DEFINES
#include <cmath>
#include <GL/glew.h>
#include <GLFW/glfw3.h>

#define SCREEN_WIDTH 1000
#define SCREEN_HEIGHT 1000
#define PC_MODE 16
#define CONSOLE_MODE 0

#define MAXRAD 4
#define MINRAD 1
#define MAXHEIGHT 8
#define MINHEIGHT 1
#define MAXFREQ_X 40
#define MINFREQ_X 3

#define MAXNUM 1000
#define ANGLE 2

struct coord
{
    float x, y, z;
};

struct coord coord_top[MAXNUM];
struct coord coord_bot[MAXNUM];
struct coord coord_side[MAXNUM][MAXNUM];

static float h, r;
int type, stop_i, stop_j;

void controls(GLFWwindow* window, int key, int scancode, int action, int mods)
{
    if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
        glfwSetWindowShouldClose(window, GL_TRUE);
}

static void error_callback(int error, const char* description)
{
    fputs(description, stderr);
}

void draw_cube(
    int type,
    int size,
    int angle_x, int angle_y, int angle_z
    )
{
    glRotatef(angle_x, 1, 0, 0);
    glRotatef(angle_y, 0, 1, 0);
    glRotatef(angle_z, 0, 0, 1);
    type > 0 ? glBegin(GL_QUADS) : glBegin(GL_LINE_LOOP);
    //BOTTOM
    glColor3f(0, 0, 0);
    glVertex3f(-size, -size, size);
    glVertex3f(size, -size, size);
    glVertex3f(size, -size, -size);
    glVertex3f(-size, -size, -size);
    glEnd();
    type > 0 ? glBegin(GL_QUADS) : glBegin(GL_LINE_LOOP);
    //TOP
    glColor3f(0, 0, 1);
    glVertex3f(-size, size, size);
    glColor3f(1, 0, 0);
    glVertex3f(size, size, size);
    glColor3f(0, 0, 0);
    glVertex3f(size, size, -size);
    glColor3f(0, 0, 1);
    glVertex3f(-size, size, -size);
    glEnd();
    type > 0 ? glBegin(GL_QUADS) : glBegin(GL_LINE_LOOP);
    //BACK
    glColor3f(1, 0, 1);
    glVertex3f(-size, -size, -size);
    glVertex3f(size, -size, -size);
    glVertex3f(size, size, -size);
    glVertex3f(-size, size, -size);
    glEnd();
    type > 0 ? glBegin(GL_QUADS) : glBegin(GL_LINE_LOOP);
    //FRONT
    glColor3f(0, 0, 1);
    glVertex3f(-size, -size, size);
    glColor3f(0, 1, 0);
    glVertex3f(size, -size, size);
    glColor3f(1, 0, 0);
    glVertex3f(size, size, size);
    glColor3f(0, 0, 1);
    glVertex3f(-size, size, size);
    glEnd();
    type > 0 ? glBegin(GL_QUADS) : glBegin(GL_LINE_LOOP);
    //LEFT
    glColor3f(1, 1, 0);
    glVertex3f(-size, -size, size);
    glVertex3f(-size, -size, -size);
    glVertex3f(-size, size, -size);
    glVertex3f(-size, size, size);
    glEnd();
    type > 0 ? glBegin(GL_QUADS) : glBegin(GL_LINE_LOOP);
    //RIGHT
    glColor3f(0, 1, 0);
    glVertex3f(size, -size, size);
    glColor3f(0, 0, 1);
    glVertex3f(size, -size, -size);
    glColor3f(0, 0, 0);
    glVertex3f(size, size, -size);
    glColor3f(1, 0, 0);
    glVertex3f(size, size, size);
    glEnd();
}

void count_vertex(int freq_x, int freq_y)
{
    int i, j, top_rad = r, bot_rad = r * 2;
    float angle, dangle, height, dheight, drad;

    height = h;
    dangle = 2 * M_PI / freq_x;
    dheight = height / freq_y;
    drad = (bot_rad - top_rad) / (float)freq_y;

    for (j = 0, angle = 0; angle <= 2 * M_PI + dangle; j += 1, angle += dangle) {
        coord_top[j].x = top_rad*cos(angle);
        coord_top[j].y = height;
        coord_top[j].z = top_rad*sin(angle);

        coord_bot[j].x = bot_rad*cos(angle);
        coord_bot[j].y = 0;
        coord_bot[j].z = bot_rad*sin(angle);
    }

    /*
    int freq_rad = 4;
    float circle_rad = top_rad / (float)freq_rad;
    printf("circle rad:%f\n", circle_rad);
    for (i = 0; i < freq_rad; i += 1) {
        for (j = 0, angle = 0; angle <= 2 * M_PI + dangle; j += 1, angle += dangle) {
            coord_top[i][j].x = (circle_rad + freq_rad*i)*cos(angle);
            coord_top[i][j].y = height;
            coord_top[i][j].z = (circle_rad + freq_rad*i)*sin(angle);

            coord_top[i][j + 1].x = (circle_rad + freq_rad*i)*cos(angle + dangle);
            coord_top[i][j + 1].y = height;
            coord_top[i][j + 1].z = (circle_rad + freq_rad*i)*sin(angle + dangle);

            coord_top[i + 1][j + 1].x = (circle_rad + freq_rad*(i + 1))*cos(angle + dangle);
            coord_top[i + 1][j + 1].y = height;
            coord_top[i + 1][j + 1].z = (circle_rad + freq_rad*(i + 1))*sin(angle + dangle);

            coord_top[i + 1][j].x = (circle_rad + freq_rad*(i + 1))*cos(angle);
            coord_top[i + 1][j].y = height;
            coord_top[i + 1][j].z = (circle_rad + freq_rad*(i + 1))*sin(angle);
        }
    }
    */

    for (i = 0; i < freq_y; i += 1) {
        for (j = 0, angle = 0; angle <= 2 * M_PI + dangle; j += 1, angle += dangle) {
            coord_side[i][j].x = (top_rad + drad*i)*cos(angle);
            coord_side[i][j].y = height - dheight*i;
            coord_side[i][j].z = (top_rad + drad*i)*sin(angle);

            coord_side[i][j + 1].x = (top_rad + drad*i)*cos(angle + dangle);
            coord_side[i][j + 1].y = height - dheight*i;
            coord_side[i][j + 1].z = (top_rad + drad*i)*sin(angle + dangle);

            coord_side[i + 1][j + 1].x = (top_rad + drad*(i + 1))*cos(angle + dangle);
            coord_side[i + 1][j + 1].y = height - dheight*(i + 1);
            coord_side[i + 1][j + 1].z = (top_rad + drad*(i + 1))*sin(angle + dangle);

            coord_side[i + 1][j].x = (top_rad + drad*(i + 1))*cos(angle);
            coord_side[i + 1][j].y = height - dheight*(i + 1);
            coord_side[i + 1][j].z = (top_rad + drad*(i + 1))*sin(angle);
        }
    }
    stop_i = i;
    stop_j = j;
    printf("coordinates renewed: h=%.2f, top_r=%d, fr_x=%d, fr_y=%d\n", height, top_rad, freq_x, freq_y);
}

void draw_cone(
    int type,
    int top_rad, int bot_rad,
    int height,
    int freq_x, int freq_y,
    int angle_x, int angle_y, int angle_z
    )
{
    glRotatef(angle_x, 1, 0, 0);
    glRotatef(angle_y, 0, 1, 0);
    glRotatef(angle_z, 0, 0, 1);

    if (freq_x <= 3) freq_x = 3;

    int i, j;

    //top
    type > 0 ? glBegin(GL_POLYGON) : glBegin(GL_LINE_LOOP);
    glColor3f(0.1, 0.1, 0.1);
    for (j = 0; j < stop_j; j++) {
        glVertex3f(coord_top[j].x, coord_top[j].y, coord_top[j].z);
    }
    glEnd();
    /*
    //top
    type > 0 ? glBegin(GL_POLYGON) : glBegin(GL_LINE_LOOP);
        for (i = 0; i < stop_i; i += 1) {
            for (j = 0; j < stop_j; j += 1) {
                type > 0 ? glBegin(GL_POLYGON) : glBegin(GL_LINE_LOOP);
                glColor3f(1, 1, 0);
                glVertex3f(coord_top[i][j].x, coord_top[i][j].y, coord_top[i][j].z);
                glColor3f(0, 0, 0);
                glVertex3f(coord_top[i][j + 1].x, coord_top[i][j + 1].y, coord_top[i][j + 1].z);
                glColor3f(1, 1, 1);
                glVertex3f(coord_top[i + 1][j + 1].x, coord_top[i + 1][j + 1].y, coord_top[i + 1][j + 1].z);
                glColor3f(0, 1, 1);
                glVertex3f(coord_top[i + 1][j].x, coord_top[i + 1][j].y, coord_top[i + 1][j].z);
                glEnd();
            }
        }
    glEnd();
    */

    //bot
    type > 0 ? glBegin(GL_POLYGON) : glBegin(GL_LINE_LOOP);
    glColor3f(0, 0, 0);
    for (j = 0; j < stop_j; j++) {
        glVertex3f(coord_bot[j].x, coord_bot[j].y, coord_bot[j].z);
    }
    glEnd();

    //sidelines
    for (i = 0; i < stop_i; i += 1) {
        for (j = 0; j < stop_j; j += 1) {
            type > 0 ? glBegin(GL_POLYGON) : glBegin(GL_LINE_LOOP);
            glColor3f(0, 0, 0);
            glVertex3f(coord_side[i][j].x, coord_side[i][j].y, coord_side[i][j].z);
            glColor3f(0.8, 0, 0);
            glVertex3f(coord_side[i][j + 1].x, coord_side[i][j + 1].y, coord_side[i][j + 1].z);
            glColor3f(0, 0.8, 0);
            glVertex3f(coord_side[i + 1][j + 1].x, coord_side[i + 1][j + 1].y, coord_side[i + 1][j + 1].z);
            glColor3f(0, 0, 0.8);
            glVertex3f(coord_side[i + 1][j].x, coord_side[i + 1][j].y, coord_side[i + 1][j].z);
            glEnd();
        }
    }
}

void draw_axis()
{
    glBegin(GL_LINES);
    //X
    glColor3f(1, 0, 0);
    glVertex3f(-100, 0, 0);
    glVertex3f(100, 0, 0);
    //Y
    glColor3f(0, 1, 0);
    glVertex3f(0, -3, 0);
    glVertex3f(0, 100, 0);
    //Z
    glColor3f(0, 0, 1);
    glVertex3f(0, 0, -1);
    glVertex3f(0, 0, 100);
    glEnd();
}

void draw_net()
{
    int i;
    float j;

    for (i = 0; i < 20; i++) {
        glColor3f(0, 0.7, 0);
        for (j = -10; j <= 10; j++) {
            glBegin(GL_LINES);
            glVertex3f(j, -3, 10);
            glVertex3f(j, -3, -10);
            glEnd();
        }
        for (j = -10; j <= 10; j += 2) {
            glBegin(GL_LINES);
            glVertex3f(10, -3, j);
            glVertex3f(-10, -3, j);
            glEnd();
        }
    }
}

void display(GLFWwindow* window)
{
    int freq_x, freq_y;
    static float alpha = 0, beta = 0, gamma = 0, a, b, c;

    freq_x = 3;
    freq_y = 3;
    type = -1;
    h = 3;
    r = 1;

    GLfloat cabinet_view_matrix[] = {
        1, 0, 0, 0,
        0, 1, 0, 0,
        -0.5*cos(M_PI / 6), -0.5*sin(M_PI / 6), -1, 0,
        0, 0, 0, 1
    };      //0.5*cos(M_PI/6), 0.5*sin(M_PI/6), 0, 0,

    count_vertex(freq_x, freq_y);
    while (!glfwWindowShouldClose(window))
    {
        glClearColor(0.4, 0.4, 0.4, 1.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        if (glfwGetKey(window, GLFW_KEY_SPACE) == GLFW_PRESS) {
            alpha = 0;
            beta = 0;
            gamma = 0;
            h = 2;
            r = 1;
            freq_x = 3;
            freq_y = 3;
            count_vertex(freq_x, freq_y);
        }
        if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS) alpha -= ANGLE;
        if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS) alpha += ANGLE;
        if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS) beta -= ANGLE;
        if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS) beta += ANGLE;
        if (glfwGetKey(window, GLFW_KEY_E) == GLFW_PRESS) gamma -= ANGLE;
        if (glfwGetKey(window, GLFW_KEY_Q) == GLFW_PRESS) gamma += ANGLE;

        if (glfwGetKey(window, GLFW_KEY_UP) == GLFW_PRESS) {
            if (h <= MAXHEIGHT) {
                h++;
                freq_y++;
                count_vertex(freq_x, freq_y);
            }
        }
        if (glfwGetKey(window, GLFW_KEY_DOWN) == GLFW_PRESS) {
            if (h > MINHEIGHT) {
                h--;
                freq_y--;
                count_vertex(freq_x, freq_y);
            }
        }
        if (glfwGetKey(window, GLFW_KEY_RIGHT) == GLFW_PRESS) {
            if (r < MAXRAD) {
                r++;
                count_vertex(freq_x, freq_y);
            }
        }
        if (glfwGetKey(window, GLFW_KEY_LEFT) == GLFW_PRESS) {
            if (r > MINRAD) {
                r--;
                count_vertex(freq_x, freq_y);
            }
        }
        if (glfwGetKey(window, GLFW_KEY_R) == GLFW_PRESS) {
            if (freq_x <= MAXFREQ_X) {
                count_vertex(++freq_x, freq_y);
            }
        }
        if (glfwGetKey(window, GLFW_KEY_F) == GLFW_PRESS) {
            if (freq_x > MINFREQ_X) {
                count_vertex(--freq_x, freq_y);
            }
        }
        if (glfwGetKey(window, GLFW_KEY_V) == GLFW_PRESS) {
            type = -type;
        }

        glMatrixMode(GL_PROJECTION);
        glLoadIdentity();
        glLoadMatrixf(cabinet_view_matrix);
        //gluPerspective(60, SCREEN_WIDTH / SCREEN_HEIGHT, 0, 100);
        glOrtho(-10, 10, -10, 10, 10, -10);

        //gluLookAt(5, 5, 5, 0, 0, 0, 0, 1, 0);

        //glMatrixMode(GL_MODELVIEW);
        //glLoadIdentity();

        draw_net();
        draw_axis();

        glTranslatef(-4, 0, 0);

        draw_cube(type, 2, 0, 0, 0);

        glTranslatef(8, 0, 0);

        //draw_cube(type, 2, alpha, beta, gamma);
        draw_cone(type, r, r * 2, h, freq_x, freq_y, alpha, beta, gamma);

        glfwSwapBuffers(window);
        glfwWaitEvents();
    }
}

int main(int argc, char** argv)
{
    // initialise GLFW
    if (!glfwInit())
    {
        printf("glfwInit failed\n");
        return -1;
    }
    glfwWindowHint(GLFW_SAMPLES, PC_MODE);
    glfwSetErrorCallback(error_callback);

    //glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 1);
    //glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
    //glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE);
    GLFWwindow* window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Test app", NULL, NULL);

    if (window == NULL)
    {
        printf("glfwOpenWindow failed.\n");
        glfwTerminate();
        return -2;
    }

    int attrib;
    attrib = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MAJOR);
    attrib = glfwGetWindowAttrib(window, GLFW_CONTEXT_VERSION_MINOR);
    attrib = glfwGetWindowAttrib(window, GLFW_OPENGL_PROFILE);

    glfwMakeContextCurrent(window);
    glfwSetKeyCallback(window, controls);

    //glDepthFunc(GL_LEQUAL);
    glEnable(GL_DEPTH_TEST);

    if (NULL != window)
    {
        display(window);
    }
    glfwDestroyWindow(window);
    glfwTerminate();
    return 0;
}