4

#include <iostream>
#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <chrono>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtx/transform.hpp>
#include <glm/vec3.hpp> // vec3
#include <glm/vec4.hpp> // vec4
#include <glm/mat4x4.hpp>

#include <glm/gtc/type_ptr.hpp>

#include <iostream>

#pragma comment(lib, "glfw3.lib")
#pragma comment(lib, "glew32.lib")
#pragma comment(lib, "opengl32.lib")

using namespace std;
using namespace glm;

mat4 ModelObj = mat4(1.0f);
//размерность n x n
GLint n_size = 10;
//Точка отсчета
GLfloat x0 = -(GLfloat)n_size / 2.0; //x
GLfloat z0 = x0;//z
//Шаг
GLfloat dx = 0.01; //по x
GLfloat dz = dx; //по z
//Количество ячеек
GLint Tess_N = n_size / dx;

GLFWwindow* g_window;

GLuint g_shaderProgram;
GLint g_uMVP;
GLint g_uMV;

chrono::time_point<chrono::system_clock> g_callTime;
class MyMatrix {
    float m_mat[16];
public:
    void translation( float x, float y, float z) { //матрица переноса

        m_mat[0] = 1.0f; m_mat[1] = 0.0f; m_mat[2] = 0.0f; m_mat[3] = 0.0f;
        m_mat[4] = 0.0f; m_mat[5] = 1.0f; m_mat[6] = 0.0f; m_mat[7] = 0.0f;
        m_mat[8] = 0.0f; m_mat[9] = 0.0f; m_mat[10] = 1.0f; m_mat[11] = 0.0f;
        m_mat[12] = x; m_mat[13] = y; m_mat[14] = z; m_mat[15] = 1.0f;

    }
    void rotate(float angle, float x, float y, float z) {
        // Вычисляем тригонометрические функции угла поворота
        float c = cos(angle);
        float s = sin(angle);
        float t = 1.0f - c;
        float len = sqrt(x * x + y * y + z * z);

        // Нормализуем вектор оси поворота
        if (len != 0.0f) {
            x /= len;
            y /= len;
            z /= len;
        }

        // Заполняем матрицу поворота
        m_mat[0] = c + x * x * t;
        m_mat[1] = y * x * t + z * s;
        m_mat[2] = z * x * t - y * s;
        m_mat[3] = 0.0f;

        m_mat[4] = x * y * t - z * s;
        m_mat[5] = c + y * y * t;
        m_mat[6] = z * y * t + x * s;
        m_mat[7] = 0.0f;

        m_mat[8] = x * z * t + y * s;
        m_mat[9] = y * z * t - x * s;
        m_mat[10] = c + z * z * t;
        m_mat[11] = 0.0f;

        m_mat[12] = 0.0f;
        m_mat[13] = 0.0f;
        m_mat[14] = 0.0f;
        m_mat[15] = 1.0f;
    }

    MyMatrix operator * (const MyMatrix& m) {
        MyMatrix mat;
        const float* a = m_mat;
        const float* b = m.m_mat;
        float* result = mat.m_mat;
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                result[i * 4 + j] =
                    a[i * 4] * b[j] +
                    a[i * 4 + 1] * b[j + 4] +
                    a[i * 4 + 2] * b[j + 8] +
                    a[i * 4 + 3] * b[j + 12];
            }
        }
        return mat;
    }
    friend MyMatrix operator*(const mat4& left, const MyMatrix& right) {
        MyMatrix mat;
        const float* b = right.m_mat;
        float a[16]; int k = 0;
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                a[k] = left[j][i]; k++;
            }
            std::cout << std::endl;
        }
        //const float* b = value_ptr(m);
        float* result = mat.m_mat;
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                result[i * 4 + j] =
                    a[i * 4] * b[j] +
                    a[i * 4 + 1] * b[j + 4] +
                    a[i * 4 + 2] * b[j + 8] +
                    a[i * 4 + 3] * b[j + 12];
            }
        }
        return mat;
    }
    MyMatrix operator * (const mat4& m) {
        MyMatrix mat;
        const float* a = m_mat;
        float b[16]; int k = 0;
        for (int i = 0; i < 4; i++) {
            for (int j = 0; j < 4; j++) {
                b[k] = m[j][i]; k++;
            }
            std::cout << std::endl;
        }
        //const float* b = value_ptr(m);
        float* result = mat.m_mat;
        for (int i = 0; i < 4; ++i) {
            for (int j = 0; j < 4; ++j) {
                result[i * 4 + j] =
                    a[i * 4] * b[j] +
                    a[i * 4 + 1] * b[j + 4] +
                    a[i * 4 + 2] * b[j + 8] +
                    a[i * 4 + 3] * b[j + 12];
            }
        }
        return mat;
    }
    void  scale( float x, float y, float z) {

        m_mat[0] = x;
        m_mat[1] = 0.0f;
        m_mat[2] = 0.0f;
        m_mat[3] = 0.0f;
        m_mat[4] = 0.0f;
        m_mat[5] = y;
        m_mat[6] = 0.0f;
        m_mat[7] = 0.0f;
        m_mat[8] = 0.0f;
        m_mat[9] = 0.0f;
        m_mat[10] = z;
        m_mat[11] = 0.0f;
        m_mat[12] = 0.0f;
        m_mat[13] = 0.0f;
        m_mat[14] = 0.0f;
        m_mat[15] = 1.0f;

    }

     void Projection(float n, float r, float t, float l, float b, float f) {

        m_mat[0] = 2 * n / (r - l);
        m_mat[1] = 0.0f;
        m_mat[2] = (r + l) / (r - l);
        m_mat[3] = 0.0f;
        m_mat[4] = 0.0f;
        m_mat[5] = 2 * n / (t - b);
        m_mat[6] = (t + b) / (t - b);
        m_mat[7] = 0.0f;
        m_mat[8] = 0.0f;
        m_mat[9] = 0.0f;
        m_mat[10] = -(f + n) / (f - n);
        m_mat[11] = -2 * f * n / (f - n);
        m_mat[12] = 0.0f;
        m_mat[13] = 0.0f;
        m_mat[14] = -1.0f;
        m_mat[15] = 0.0f;

    }
     void View() {
         m_mat[0] =
             0.514496;
         m_mat[1] = 0.0;
         m_mat[2] = -0.857493;
         m_mat[3] = 9.53674e-07;
         m_mat[4] = -0.392299;
         m_mat[5] = 0.889212;
         m_mat[6] = -0.23538;
         m_mat[7] = -4.76837e-07;
         m_mat[8] = 0.762493;
         m_mat[9] = 0.457496;
         m_mat[10] = 0.457496;
         m_mat[11] = -32.7872;
         m_mat[12] = 0.0;
         m_mat[13] = 0.0;
         m_mat[14] = 0.0;
         m_mat[15] = 1.0;

     }
     MyMatrix() {
         m_mat[0] =
             1.0f;
         m_mat[1] = 0.0f;
         m_mat[2] = 0.0f;
         m_mat[3] = 0.0f;
         m_mat[4] = 0.0f;
         m_mat[5] = 1.0f;
         m_mat[6] = 0.0f;
         m_mat[7] = 0.0f;
         m_mat[8] = 0.0f;
         m_mat[9] = 0.0f;
         m_mat[10] = 1.0f;
         m_mat[11] = 0.0f;
         m_mat[12] = 0.0f;
         m_mat[13] = 0.0f;
         m_mat[14] = 0.0f;
         m_mat[15] = 1.0f;
     }
     void Model() {
         m_mat[0] =
             1.0f;
         m_mat[1] = 0.0f;
         m_mat[2] = 0.0f;
         m_mat[3] = 0.0f;
         m_mat[4] = 0.0f;
         m_mat[5] = 1.0f;
         m_mat[6] = 0.0f;
         m_mat[7] = 0.0f;
         m_mat[8] = 0.0f;
         m_mat[9] = 0.0f;
         m_mat[10] = 1.0f;
         m_mat[11] = 0.0f;
         m_mat[12] = 0.0f;
         m_mat[13] = 0.0f;
         m_mat[14] = 0.0f;
         m_mat[15] = 1.0f;
     }

     float* get()  { return m_mat; };
};
MyMatrix *M = new MyMatrix();


class Model
{
public:
    GLuint vbo;
    GLuint ibo;
    GLuint vao;
    GLsizei indexCount;
};

Model g_model;

GLuint createShader(const GLchar* code, GLenum type)
{
    GLuint result = glCreateShader(type);

    glShaderSource(result, 1, &code, NULL);
    glCompileShader(result);

    GLint compiled;
    glGetShaderiv(result, GL_COMPILE_STATUS, &compiled);

    if (!compiled)
    {
        GLint infoLen = 0;
        glGetShaderiv(result, GL_INFO_LOG_LENGTH, &infoLen);
        if (infoLen > 0)
        {
            char* infoLog = (char*)alloca(infoLen);
            glGetShaderInfoLog(result, infoLen, NULL, infoLog);
            cout << "Shader compilation error" << endl << infoLog << endl;
        }
        glDeleteShader(result);
        return 0;
    }

    return result;
}

GLuint createProgram(GLuint vsh, GLuint fsh)
{
    GLuint result = glCreateProgram();

    glAttachShader(result, vsh);
    glAttachShader(result, fsh);

    glLinkProgram(result);

    GLint linked;
    glGetProgramiv(result, GL_LINK_STATUS, &linked);

    if (!linked)
    {
        GLint infoLen = 0;
        glGetProgramiv(result, GL_INFO_LOG_LENGTH, &infoLen);
        if (infoLen > 0)
        {
            char* infoLog = (char*)alloca(infoLen);
            glGetProgramInfoLog(result, infoLen, NULL, infoLog);
            cout << "Shader program linking error" << endl << infoLog << endl;
        }
        glDeleteProgram(result);
        return 0;
    }

    return result;
}

bool createShaderProgram() {
    g_shaderProgram = 0;

    const GLchar vsh[] =
        "#version 330\n"
        ""
        "layout(location = 0) in vec2 a_position;"
        ""
        "uniform mat4 u_mv;"
        "uniform mat4 u_mvp;"
        ""
        "out vec3 v_p;"
        "out vec3 v_normal;"
        ""
        "void main()"
        "{"
        "    float x = a_position[0];"
        "    float z = a_position[1];"
        "    float func =0.25 *(1-x* z)* sin(1-x *z); "
        "    vec4 pos = vec4(a_position[0], func, a_position[1], 1.0);"
        "    gl_Position = u_mvp*pos;"
        "    v_p = (u_mv*pos).xyz;"
        "    float g_x = -0.25*z*sin(1 - x*z) - 0.25*z*(1 - x*z)*cos(-1 + x*z);"
        "    float g_z = -0.25*x*sin(1 - x*z) - 0.25*x*(1 - x*z)*cos(-1 + x*z);"
        //"    float x = a_position[0];"
        //"    float z = a_position[1];"
        //"    float func =x+z; "
        //"    vec4 pos = vec4(a_position[0], func, a_position[1], 1.0);"
        //"    gl_Position = u_mvp*pos;"
        //"    v_p = (u_mv*pos).xyz;"
        //"    float g_x = 1;"
        //"    float g_z = 1;"
        "    v_normal = normalize(transpose(inverse(mat3(u_mv)))*vec3(g_x, 1.0, g_z));"
        "}"
        ;

    const GLchar fsh[] =
        "#version 330\n"
        ""
        "in vec3 v_p;"
        "in vec3 v_normal;"
        ""
        "layout(location = 0) out vec4 o_color;"
        ""
        "void main()"
        "{"
        "   vec3 u_l = vec3(5.0, 10.0, 0.0);" //Положение источника света
        "   vec3 n = normalize(v_normal);" //нормировка нормали
        "   vec3 l = normalize(v_p-u_l);"
        "   float a = dot(-l, n);"
        "   float d = max(a, 0.1);" //диффузное освещение
        "   vec3 r = reflect(l, n);" //вектор отражения
        "   vec3 e = normalize(-v_p);"
        "   float s = pow(max(dot(r, e), 0.0), 5.0)*int(a >= 0);" //компонент зеркального блика
        "   o_color = vec4(d*vec3(1.0, 0.0, 0.0)+s*vec3(1.0), 1.0);" //цвет поверхности
        "}"
        ;

    GLuint vertexShader, fragmentShader;

    vertexShader = createShader(vsh, GL_VERTEX_SHADER);
    fragmentShader = createShader(fsh, GL_FRAGMENT_SHADER);

    g_shaderProgram = createProgram(vertexShader, fragmentShader);

    //Матрицы
    g_uMV = glGetUniformLocation(g_shaderProgram, "u_mv");
    g_uMVP = glGetUniformLocation(g_shaderProgram, "u_mvp");
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    return g_shaderProgram != 0;
}

//Получение порядкового номера вершины по индексам i, j
GLint getNumVertex(int j, int i, int n) {
    return (GLint)(i + j * (n + 1));
}
void generateMesh(GLfloat* vertices, GLuint* indices, int Tess_N) {
    int index = 0;

    GLfloat* arr_x = new GLfloat[Tess_N + 1];//координаты x
    GLfloat* arr_z = new GLfloat[Tess_N + 1];//координаты z
    //Заполнение массива с координатами x
    for (int i = 0; i <= Tess_N; i++) {
        arr_x[i] = x0 + i * dx;
    }

    //Заполнение массива с координатами z
    for (int i = 0; i <= Tess_N; i++) {
        arr_z[i] = z0 + i * dz;
    }

    /*Заполнение итогового массива с вершинами*/
    int k = 0;
    for (int j = 0; j <= Tess_N; j++) {
        for (int i = 0; i <= Tess_N; i++) {
            //Координаты
            vertices[k] = arr_x[i];
            k++;
            vertices[k] = arr_z[j];
            k++;
        }
    }
    //for (int x = 0; x <= Tess_N; x++) {
    //  for (int y = 0; y <= Tess_N; y++) {
    //      float f_x = x / (GLfloat)Tess_N;
    //      float f_y = y / (GLfloat)Tess_N;

    //      vertices[(x * Tess_N + y) * 2 + 0] = f_x;
    //
    //      vertices[(x * Tess_N + y) * 2 + 1] = f_y;

    //
    //  }
    //}


     //Заполняем массив индексов
      k = 0;
    int j = 0;
    while (j < Tess_N) {
        for (int i = 0; i <= Tess_N; i++) {
            indices[k] = getNumVertex(j, i, Tess_N);
            k++;
            indices[k] = getNumVertex(j + 1, i, Tess_N);
            k++;
        }
        if (j < Tess_N - 1) {
            indices[k] = getNumVertex(j + 1, Tess_N, Tess_N);
            k++;
        }
        j++;
        if (j < Tess_N) {
            for (int i = Tess_N; i >= 0; i--) {
                indices[k] = getNumVertex(j, i, Tess_N);
                k++;
                indices[k] = getNumVertex(j + 1, i, Tess_N);
                k++;
            }
            if (j < Tess_N - 1) {
                indices[k] = getNumVertex(j + 1, 0, Tess_N);
                k++;
            }
            j++;
        }
    }
    /*for (int x = 0; x < Tess_N; x++) {
        for (int y = 0; y < Tess_N ; y++) {
            indices[(x * (Tess_N - 1) + y) * 2 * 3 + 0] = (x + 0) * Tess_N + y + 0;
            indices[(x * (Tess_N - 1) + y) * 2 * 3 + 1] = (x + 1) * Tess_N + y + 1;
            indices[(x * (Tess_N - 1) + y) * 2 * 3 + 2] = (x + 1) * Tess_N + y + 0;

            indices[(x * (Tess_N - 1) + y) * 2 * 3 + 3] = (x + 0) * Tess_N + y + 0;
            indices[(x * (Tess_N - 1) + y) * 2 * 3 + 4] = (x + 0) * Tess_N + y + 1;
            indices[(x * (Tess_N - 1) + y) * 2 * 3 + 5] = (x + 1) * Tess_N + y + 1;
        }
    }*/
}
bool createModel() {
    GLint arr_vertex_size = (Tess_N+1)  * (Tess_N +1)  * 2; //Размерность одномерного массива с вершинами
    GLint arr_index_size = 2 * (Tess_N + 1) * Tess_N + (Tess_N - 1); //Размерность одномерного массива с индексами


    GLfloat* vertices = (GLfloat*)malloc(arr_vertex_size * sizeof(GLfloat));; //Создали массив с координатами вершин x, y, z
    GLuint* indices = (GLuint*)malloc(
        arr_index_size * sizeof(GLuint)
    ); //Создали массив с индексами обхода

    /*for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            GLfloat x = (GLfloat)i / n;
            GLfloat z = (GLfloat)j / n;
            vertices[(i * n + j) * 2] = x;
            vertices[(i * n + j) * 2 + 1] = z;
        }
    }
    */
    generateMesh(vertices, indices, Tess_N);

    glGenVertexArrays(1, &g_model.vao);
    glBindVertexArray(g_model.vao);

    glGenBuffers(1, &g_model.vbo);
    glBindBuffer(GL_ARRAY_BUFFER, g_model.vbo);
    glBufferData(GL_ARRAY_BUFFER, arr_vertex_size * sizeof(GLfloat), vertices, GL_STATIC_DRAW);

    glGenBuffers(1, &g_model.ibo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, g_model.ibo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, arr_index_size * sizeof(GLint), indices, GL_STATIC_DRAW);

    g_model.indexCount = arr_index_size;

    glEnableVertexAttribArray(0);
    glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(GLfloat), (const GLvoid*)0);
    /*delete(indices);
    delete(vertices);*/
    free(indices);
    free(vertices);

    return g_model.vbo != 0 && g_model.ibo != 0 && g_model.vao != 0;
}

bool init() {
    // Set initial color of color buffer to white.
    glClearColor(1.0f, 1.0f, 1.0f, 1.0f);

    glEnable(GL_DEPTH_TEST);

    return createShaderProgram() && createModel();
}

void reshape(GLFWwindow* window, int width, int height) {
    glViewport(0, 0, width, height);
}
float max(float a, float b) {
    return a > b ? a : b;
}
void draw(GLfloat delta_draw)
{ // Clear color buffer.
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glUseProgram(g_shaderProgram);
    glBindVertexArray(g_model.vao);
    /*float fov = pi<float>()/4;
    float width = 4.0f;
    float height = 3.0f;
    float n = x0;
    float f = abs(x0);
    float r = n * tanf(fov / 2.0f);
    float l = -r;
    float t = n*(width / height)* tanf(fov / 2.0f);
    float b = -t;
    MyMatrix Projection;
    Projection.Projection( n, r, t, l, b, f);

    for (int i = 0; i < 16; i++)
    {
        cout << Projection.get()[i] << endl;
    }cout << endl;*/

    /*Проекционная матрица: 45 градусов, соотношение 4:3*/
    mat4 Projection = perspective(radians(45.0f), 4.0f / 3.0f, x0, abs(x0));
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            std::cout << Projection[j][i] << " ";
        }
        std::cout << std::endl;
    }



    MyMatrix R;
    if (glfwGetKey(g_window, GLFW_KEY_LEFT) || glfwGetKey(g_window, GLFW_KEY_RIGHT)) {
        /*ModelObj = rotate(ModelObj, delta_draw, vec3(0.0, 1.0, 0.0));*/
        R.rotate(delta_draw, 0, 1, 0);
        *M =R*(*M)   ;

    }
    else if (glfwGetKey(g_window, GLFW_KEY_UP) || glfwGetKey(g_window, GLFW_KEY_DOWN))
    {
        /* ModelObj = rotate(ModelObj, delta_draw, vec3(0.0, 0.0, 1.0));*/
        R.rotate(delta_draw, 0, 0, 1);
        *M = R*(*M)  ;
    }



    //mat4 View = lookAt(
    //    vec3(-5, -5, -5) * x0, //Положение камеры
    //    vec3(0, 0, 0), //Направление камеры в точку
    //    vec3(0, 1, 0)  //Наблюдатель
    //);

    /*GLfloat a = delta_draw;*/


    //mat4 View = lookAt(
    //  vec3(5, 3, 3) * abs(x0), //Положение камеры
    //  vec3(0, 0, 0), //Направление камеры в точку
    //  vec3(0, 1, 0)  //Наблюдатель
    //);
    /*for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            std::cout << View[j][i] << " ";
        }
        std::cout << std::endl;
    }*/
    /*cout << endl;
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            std::cout << ModelObj[j][i] << " ";
        }
        std::cout << std::endl;
    }
    /*cout << endl;*/
    /*MyMatrix V;
    V.View();*/

    //////Матрица MV
    //MyMatrix MV = View * (*M);
    ////
    //for (int i = 0; i < 16; i++)
    //{
    //  cout << (*M).get()[i] << endl;
    //}cout << endl;
    /*mat4 MV = View * ModelObj;*/
    /*for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            std::cout << MV[j][i] << " ";
        }
        std::cout << std::endl;
    }
    cout << endl;*/
    /*Матрица MVP*/
    MyMatrix MVP =  Projection * (*M);
    for (int i = 0; i < 16; i++)
    {
        cout << MVP.get()[i] << endl;
    }cout << endl;


    /*mat4 MVP = Projection * MV;
    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            std::cout << MVP[j][i] << " ";
        }
        std::cout << std::endl;
    }*/

    //Передача данных в шейдер
    glUniformMatrix4fv(g_uMV, 1, GL_TRUE, (*M).get());
    glUniformMatrix4fv(g_uMVP, 1, GL_TRUE, MVP.get());
    glDrawElements(GL_TRIANGLE_STRIP, g_model.indexCount, GL_UNSIGNED_INT, NULL);








    //// Clear color buffer.
    //glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    //glUseProgram(g_shaderProgram);
    //glBindVertexArray(g_model.vao);

    ////Проекционная матрица: 45 градусов, соотношение 4:3
    //mat4 Projection = perspective(radians(45.0f), 4.0f / 3.0f, x0, abs(x0));
    //for (int i = 0; i < 4; i++) {
    //  for (int j = 0; j < 4; j++) {
    //      std::cout << Projection[j][i] << " ";
    //  }
    //  std::cout << std::endl;
    //}


    //mat4 View = lookAt(
    //  vec3(5, 3, 3) * abs(x0), //Положение камеры
    //  vec3(0, 0, 0), //Направление камеры в точку
    //  vec3(0, 1, 0)  //Наблюдатель
    //);
    //for (int i = 0; i < 4; i++) {
    //  for (int j = 0; j < 4; j++) {
    //      std::cout << View[j][i] << " ";
    //  }
    //  std::cout << std::endl;
    //}
    //GLfloat a = delta_draw;

    //if (glfwGetKey(g_window, GLFW_KEY_LEFT) || glfwGetKey(g_window, GLFW_KEY_RIGHT)) {
    //  ModelObj = rotate(ModelObj, delta_draw, vec3(0.0, 1.0, 0.0));
    //}
    //else if (glfwGetKey(g_window, GLFW_KEY_UP) || glfwGetKey(g_window, GLFW_KEY_DOWN))
    //{
    //  ModelObj = rotate(ModelObj, delta_draw, vec3(0.0, 0.0, 1.0));
    //}

    ////Матрица MV
    //mat4 MV = View * ModelObj;
    //for (int i = 0; i < 4; i++) {
    //  for (int j = 0; j < 4; j++) {
    //      std::cout << MV[j][i] << " ";
    //  }
    //  std::cout << std::endl;
    //}
    ////Матрица MVP
    //mat4 MVP = Projection * MV;
    //for (int i = 0; i < 4; i++) {
    //  for (int j = 0; j < 4; j++) {
    //      std::cout << MVP[j][i] << " ";
    //  }
    //  std::cout << std::endl;
    //}

    ////Передача данных в шейдер
    //glUniformMatrix4fv(g_uMV, 1, GL_FALSE, &MV[0][0]);
    //glUniformMatrix4fv(g_uMVP, 1, GL_FALSE, &MVP[0][0]);
    //glDrawElements(GL_TRIANGLE_STRIP, g_model.indexCount, GL_UNSIGNED_INT, NULL);
}

void cleanup()
{
    if (g_shaderProgram != 0)
        glDeleteProgram(g_shaderProgram);
    if (g_model.vbo != 0)
        glDeleteBuffers(1, &g_model.vbo);
    if (g_model.ibo != 0)
        glDeleteBuffers(1, &g_model.ibo);
    if (g_model.vao != 0)
        glDeleteVertexArrays(1, &g_model.vao);
}

bool initOpenGL()
{
    // Initialize GLFW functions.
    if (!glfwInit())
    {
        cout << "Failed to initialize GLFW" << endl;
        return false;
    }

    // Request OpenGL 3.3 without obsoleted functions.
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    // Create window.
    g_window = glfwCreateWindow(800, 600, "OpenGL Test", NULL, NULL);
    if (g_window == NULL)
    {
        cout << "Failed to open GLFW window" << endl;
        glfwTerminate();
        return false;
    }

    // Initialize OpenGL context with.
    glfwMakeContextCurrent(g_window);

    // Set internal GLEW variable to activate OpenGL core profile.
    glewExperimental = true;

    // Initialize GLEW functions.
    if (glewInit() != GLEW_OK)
    {
        cout << "Failed to initialize GLEW" << endl;
        return false;
    }

    // Ensure we can capture the escape key being pressed.
    glfwSetInputMode(g_window, GLFW_STICKY_KEYS, GL_TRUE);

    // Set callback for framebuffer resizing event.
    glfwSetFramebufferSizeCallback(g_window, reshape);

    return true;
}

void tearDownOpenGL()
{
    // Terminate GLFW.
    glfwTerminate();
}

int main()
{
    //cout << Tess_N << ", " << x0 << ", " << dx;
    // Initialize OpenGL
    if (!initOpenGL())
        return -1;
    MyMatrix T;
    T.translation(-15, 0, 40);
    MyMatrix S;
    float x = x0;
    float z = z0;
    MyMatrix  R;
    S.scale(1/40.0f, 1, 1 / 40.0f);

    R.rotate(radians(10.0), 1, 0, 0);


    (*M) =  T * S*(*M);
    // Initialize graphical resources.
    bool isOk = init();

    if (isOk)
    {
        GLfloat lastTime = glfwGetTime();

        // Main loop until window closed or escape pressed.
        while (glfwGetKey(g_window, GLFW_KEY_ESCAPE) != GLFW_PRESS && glfwWindowShouldClose(g_window) == 0)
        {
            GLfloat currentTime = glfwGetTime();
            GLfloat deltaTime = GLfloat(currentTime - lastTime);
            lastTime = currentTime;

            GLfloat delta = 0;
            GLfloat angle = 200.0;
            if (glfwGetKey(g_window, GLFW_KEY_LEFT) || glfwGetKey(g_window, GLFW_KEY_UP)) {
                delta = radians(angle) * deltaTime;
            }
            else if (glfwGetKey(g_window, GLFW_KEY_RIGHT) || glfwGetKey(g_window, GLFW_KEY_DOWN)) {
                delta = -radians(angle) * deltaTime;
            }
            draw(delta);
            // Swap buffers.
            glfwSwapBuffers(g_window);
            // Poll window events.
            glfwPollEvents();
        }
    }

    // Cleanup graphical resources.
    cleanup();

    // Tear down OpenGL.
    tearDownOpenGL();
    /*system("pause");*/
    return isOk ? 0 : -1;
}