class triangle {
public:	GLuint VAO, shaderProgram;
		GLuint VBO, EBO;
		GLfloat tVertices[18] = {0.5f, 0.5f, 1.0f, 0.7f, 0.7f, 0.7f
								 0.5f, -0.5f, 1.0f, 0.5f, 0.5f, 0.5f
								 -0.5f, -0.5f, 1.0f, 0.3f, 0.3f, 0.3f};
		GLuint vIndices[3] = {0, 1, 2};
		triangle() {
			try {
				//инициализация VAO
				glGenVertexArrays(1, &this->VAO);
				glBindVertexArray(VAO);
				//инициализация VBO
				glGenBuffers(1, &this->VBO);
				glBindBuffer(GL_ARRAY_BUFFER, this->VBO);

				glBufferData(GL_ARRAY_BUFFER, sizeof(this->tVertices), this->tVertices, GL_DYNAMIC_DRAW);
				//инициализация EBO
				glGenBuffers(1, &this->EBO);
				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, this->EBO);
				glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(this->vIndices), this->vIndices, GL_DYNAMIC_DRAW);
				//передача вершин на layout 0
				glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)0);
				glEnableVertexAttribArray(0);
				//передача цветов на layout 1
				glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(GLfloat), (GLvoid*)(3 * sizeof(GLfloat)));
				glEnableVertexAttribArray(1);

				shaderInit();

				glBindBuffer(GL_ARRAY_BUFFER, 0);
				glBindVertexArray(0);
			}
			catch (char* s) {
				std::cout << s << std::endl;
				system("pause");
				abort();
			}
		}
		~triangle() {
			glDeleteVertexArrays(1, &VAO);
			glDeleteBuffers(1, &VBO);
			glDeleteBuffers(1, &EBO);
		}
		void shaderInit() {
			try {
				GLint compile_ok = GL_FALSE, link_ok = GL_FALSE;
				GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
				const char* vertexShader_source = "#version 330 core
												   layout(location = 0) in vec3 vertexPos;
												   layout(location = 1) in vec3 inColor;
												   out vec4 outColor;
												   void main(){gl_Position = vec4(vertexPos, 1.0); outColor = vec4(inColor, 1.0);}"
				glShaderSource(vertexShader, 1, &vertexShader_source, NULL);
				glCompileShader(vertexShader);
				glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &compile_ok);
				if (0 == compile_ok) { throw "Error in vertex shader"; }
				GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
				const char* fragmentShader_source = "#version 330 core
													in vec4 outColor;
													out vec4 color;
													void main(){color = outColor;}";
				glShaderSource(fragmentShader, 1, &fragmentShader_source, NULL);
				glCompileShader(fragmentShader);
				glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &compile_ok);
				if (0 == compile_ok) { throw "Error in fragment shader"; }
				glAttachShader(this->shaderProgram, vertexShader);
				glAttachShader(this->shaderProgram, fragmentShader);
				glLinkProgram(this->shaderProgram);
				glGetProgramiv(this->shaderProgram, GL_COMPILE_STATUS, &compile_ok);
				if (0 == compile_ok) { throw "Error while linking program"; }
				glDeleteShader(vertexShader);
				glDeleteShader(fragmentShader);
			}
			catch (char* s) {
				std::cout << s << std::endl;
				system("pause");
				abort();
			}
		}
		void draw() {
			glUseProgram(this->shaderProgram);
			glBindVertexArray(this->VAO);
			glDrawElements(GL_TRIANGLES, ArraySize(this->vIndices), GL_UNSIGNED_INT, 0);
			glBindVertexArray(0);
			glUseProgram(0);
		}
};

GLFWwindow *window;

void render(GLFWwindow *window, triangle &t) {
	glfwPollEvents();

	glClearColor(0.5f, 0.5f, 0.5f, 1.0f);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	t.draw();

	glfwSwapBuffers(window);
};

int main() {
	if (!glfwInit()) { std::cout << "Failed to initialize GLFW" << std::endl;	return -1; }
	glfwWindowHint(GLFW_SAMPLES, 4);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // нам нужен OpenGL 3.3
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); //нам не нужен старый OpenGL
	glfwWindowHint(GLFW_RESIZABLE, GL_FALSE);
	window = glfwCreateWindow(480, 640, "GLFW: Getting Started", 0, 0);
	glfwMakeContextCurrent(window);

	glfwSetKeyCallback(window, key_callback);
	glfwSetMouseButtonCallback(window, mouse_button_callback);

	glewExperimental = true;
	if (glewInit() != GLEW_OK) { std::cout << "Failed to initialize GLEW" << std::endl; system("pause");	glfwTerminate(); return -1; }
	if (window == NULL) { std::cout << "Failed to initialize window" << std::endl; system("pause"); glfwTerminate();	return -1; }

	int width, height;
	glfwGetFramebufferSize(window, &width, &height);
	glViewport(0, 0, width, height);

	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();

	triangle t1;
	glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
	while (glfwWindowShouldClose(window) == 0) {render(window, t1);}
	glfwTerminate();
	return 0;
}