include stdafx include windows include iostream include stdlib include

#include "stdafx.h"
#include <windows.h>
#include <iostream>
#include <stdlib.h>
#include "stdafx.h"
#include <fstream>
#include <iomanip>
#define _USE_MATH_DEFINES
#include <math.h>
using namespace std;

#define SCREEN_WIDTH 800
#define SCREEN_HEIGHT 600

#define angle 10

int  GW, GH;
int N,s=0,f=0;

float S = 0, L = 0;
float Ln = 0;//расстояние до источника света
GLbyte *image=NULL;

int Texture_mod = 0;
float Texture_height = 2;
float Texture_width = 2;
int TR = 0; // флаг старт анимации
float Kc = 1, Kl = 0, Kq = 0; // коэффициенты ослабления света
float GY=0, GV=0, GA=(float)0.01; // координата скорость ускорение

struct Point { float x; float y; float z; };
struct rebro { float bx; float by; float ex; float ey; };

byte *data=NULL;
struct Point **tor;

struct Point **torn;



struct list { int value; float x; struct list * next; int flag; } typedef List;





static void resize_callback(GLFWwindow* window, int width, int height)
{
	GW = width;
	GH = height;
	glViewport(0, 0, width, height);
	glMatrixMode(GL_PROJECTION);
	glLoadIdentity();
	glOrtho(-(GLdouble)width, (GLdouble)width, -(GLdouble)height, (GLdouble)height, -400, 400);

	glMatrixMode(GL_MODELVIEW);
	glLoadIdentity();


	printf("Reshape occured\n");

}

static void mouse_callback(GLFWwindow* window, int button, int action, int mods)
{

}

static void keyboard_callback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
	if (key == GLFW_KEY_TAB && action == GLFW_PRESS)
	{
		if (TR == 0) TR = 1;
		else TR = 0;
	}
	if (key == GLFW_KEY_P)
	{
		S -= 10;
	}

	if (key == GLFW_KEY_Q)
	{
		glRotatef(10, 1, 0, 0);
	}
	if (key == GLFW_KEY_Q)
	{
		glRotatef(10, 1, 0, 0);
	}
	if (key == GLFW_KEY_W)
	{
		glRotatef(10, 0, 1, 0);
	}

	if (key == GLFW_KEY_E)
	{
		glRotatef(10, 0, 0, 1);
	}



	if (key == GLFW_KEY_K)
	{
		Ln += 10;
		cout << Ln << "\n";
	}

	if (key == GLFW_KEY_I)
	{
		Ln -= 10;
		cout << Ln << "\n";
	}

	if (key == GLFW_KEY_Z)
	{
		Kc += (float)0.1;
		cout << Kc << "\n";
	}

	if (key == GLFW_KEY_X)
	{
		Kl += (float)0.1;
		cout << Kl << "\n";
	}

	if (key == GLFW_KEY_C)
	{
		Kq += (float)0.1;
		cout << Kq << "\n";
	}

	if (key == GLFW_KEY_A)
	{
		Kc -= (float)0.1;
		cout << Kc << "\n";
	}

	if (key == GLFW_KEY_S)
	{
		Kl -= (float)0.1;
		cout << Kl << "\n";
	}

	if (key == GLFW_KEY_D)
	{
		Kq -= (float)0.1;
		cout << Kq << "\n";
	}

	if (key == GLFW_KEY_L && action == GLFW_PRESS)
	{

		if (L == 0) L = 1;
		else
		{
			L = 0;
			glDisable(GL_LIGHTING);
			glDisable(GL_LIGHT0);
		}
	}
	if (key == GLFW_KEY_T && action == GLFW_PRESS)
	{
		if (Texture_mod == 0)
		{
			Texture_mod = 1;

		}
		else {
			glDisable(GL_TEXTURE_2D);
			Texture_mod = 0;
		}
	}


	if (key == GLFW_KEY_Y)
	{

		setlocale(LC_ALL, "RUS");
		int i;
		double a;
		//описывает поток для записи данных в файл
		ofstream f;
		//открываем файл в режиме записи,
		//режим ios::out устанавливается по умолчанию
		f.open("C:\\Users\\Asus-Pc\\Desktop\\info.txt", ios::out);
		f << Ln << "\n";
		f << TR << "\n";
		f << S << "\n";
		f << GY << "\n";
		f << GV << "\n";
		f << GA << "\n";
		f << Texture_mod << "\n";
		f << L << "\n";
		//закрытие потока
		f.close();
	}
	if (key == GLFW_KEY_U)
	{
		setlocale(LC_ALL, "RUS");
		fstream F;
		F.open("C:\\Users\\Asus-Pc\\Desktop\\info.txt");
		if (F)
		{
			F >> Ln;
			F >> TR;
			F >> S;
			F >> GY;
			F >> GV;
			F >> GA;
			F >> Texture_mod;
			F >> L ;
			//закрытие потока
			F.close();
		}
	}
}




int mod(int num) {

	if (num >= angle) return num - angle;
	if (num < 0) return num + angle;
	return num;
}
void CountTor() {
	//Оптимизация
	glEnable(GL_COLOR_MATERIAL);
	glShadeModel(GL_FLAT);
	glEnable(GL_CULL_FACE);
	glEnable(GL_DEPTH_TEST);
	glEnable(GL_NORMALIZE);
	///
	int i = 0;
	data = (byte*)malloc(sizeof(byte)* Texture_height * Texture_width * 3);

	//Освещение
	int t = 0, d = 0;
	float fi = 0, csi = 0;
	int r = 200, a = 50, b = 50;

	tor = (struct Point**)malloc(sizeof(struct Point*)*angle);
	torn = (struct Point**)malloc(sizeof(struct Point*)*angle);


	for (d = 0; d < angle ; d++) {
		tor[d] = (struct Point*)malloc(sizeof(struct Point)*(angle ));
		torn[d] = (struct Point*)malloc(sizeof(struct Point)*(angle ));
		for (t = 0; t < angle ; t++)
		{
			csi = (float)(360 * d * M_PI) / (angle * 180);
			fi = (float)(360 * t * M_PI) / (angle * 180);

			tor[d][t].x = (r + a*cos(fi))*cos(csi);
			tor[d][t].y = (r + a*cos(fi))*sin(csi);
			tor[d][t].z = (float)a * sin(fi);

		}
	}

	for (d = 0; d < angle ; d++) {

		for (t = 0; t < angle ; t++) {

			struct Point vec1;
			struct Point vec2;

			vec1.x = tor[mod(d + 1)][mod(t)].x - tor[mod(d)][mod(t)].x;
			vec1.y = tor[mod(d + 1)][mod(t)].y - tor[mod(d)][mod(t)].y;
			vec1.z = tor[mod(d + 1)][mod(t)].z - tor[mod(d)][mod(t)].z;

			vec2.x = tor[mod(d)][mod(t + 1)].x - tor[mod(d)][mod(t)].x;
			vec2.y = tor[mod(d)][mod(t + 1)].y - tor[mod(d)][mod(t)].y;
			vec2.z = tor[mod(d)][mod(t + 1)].z - tor[mod(d)][mod(t)].z;
			struct Point n;
			n.x = (vec1.y * vec2.z - vec1.z * vec2.y);
			n.y = (vec1.z * vec2.x - vec1.x * vec2.z);
			n.z = (vec1.x * vec2.y - vec1.y * vec2.x);
			torn[mod(d)][mod(t)] = n;
		}
	}

}
double PCFreq = 0.0;
__int64 CounterStart = 0;

void StartCounter()
{
	LARGE_INTEGER li;
	if (!QueryPerformanceFrequency(&li))
		cout << "QueryPerformanceFrequency failed!\n";

	PCFreq = double(li.QuadPart) / 1000.0;

	QueryPerformanceCounter(&li);
	CounterStart = li.QuadPart;
}
double GetCounter()
{
	LARGE_INTEGER li;
	QueryPerformanceCounter(&li);
	return double(li.QuadPart - CounterStart) / PCFreq;
}

void DrawTor() {
	StartCounter();

	float RED=1, GREEN=0, BLUE=0;
	int t = 0, d = 0;

	//Анимация
	if (TR == 1) {
		GY -= GV;
		GV += GA;
		if (GY <= -500) GV = -GV;
		S = GY;
	}
	int T_flag = 0;
	for (d = 0; d < angle ; d++) {
		
		for (t = 0; t < angle ; t++) {
			glColor3f(RED, GREEN, BLUE);
			glBegin(GL_POLYGON);

			if (L) glNormal3f(torn[mod(d)][mod(t)].x, torn[mod(d)][mod(t)].y, torn[mod(d)][mod(t)].z);
			if (Texture_mod) glTexCoord2f(0, 0);
			glVertex3f(tor[mod(d)][mod(t)].x, tor[mod(d)][mod(t)].y + S, tor[mod(d)][mod(t)].z);

			if (L) glNormal3f(torn[mod(d + 1)][mod(t)].x, torn[mod(d + 1)][mod(t)].y, torn[mod(d + 1)][mod(t)].z);
			if (Texture_mod) glTexCoord2f(0, 1);
			glVertex3f(tor[mod(d + 1)][mod(t)].x, tor[mod(d + 1)][mod(t)].y + S, tor[mod(d + 1)][mod(t)].z);

			if (L) glNormal3f(torn[mod(d + 1)][mod(t + 1)].x, torn[mod(d + 1)][mod(t + 1)].y, torn[mod(d + 1)][mod(t + 1)].z);
			if (Texture_mod) glTexCoord2f(1, 0);
			glVertex3f(tor[mod(d + 1)][mod(t + 1)].x, tor[mod(d + 1)][mod(t + 1)].y + S, tor[mod(d + 1)][mod(t + 1)].z);

			if (L) glNormal3f(torn[mod(d)][mod(t + 1)].x, torn[mod(d)][mod(t + 1)].y, torn[mod(d)][mod(t + 1)].z);
			if (Texture_mod) glTexCoord2f(1, 1);
			glVertex3f(tor[mod(d)][mod(t + 1)].x, tor[mod(d)][mod(t + 1)].y + S, tor[mod(d)][mod(t + 1)].z);

			glEnd();
			
		}

	}
	if (L == 1) {
		glEnable(GL_LIGHTING);
		glEnable(GL_LIGHT0);

		float v[4] = { 0, 0, Ln, 1 };
		glLineWidth(10);
		glBegin(GL_LINE_LOOP);
		glVertex3f(0, 0, 0);
		glVertex3f(0, 0, Ln);
		glEnd();
		glLightfv(GL_LIGHT0, GL_POSITION, v);

		float c1[4] = { 0.5, 0.5, 0.5, 1 };
		glLightfv(GL_LIGHT0, GL_AMBIENT, c1);
		float c2[4] = { 0.5, 0.5, 0.5, 1 };
		glLightfv(GL_LIGHT0, GL_DIFFUSE, c2);
		float c3[4] = { 0.5, 0.5, 0.5, 1 };
		glLightfv(GL_LIGHT0, GL_SPECULAR, c3);

		glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, Kc);
		glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, Kl);
		glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, Kq);

		float c[4] = { 0, 0, 0, 1 };
		glLightModelfv(GL_LIGHT_MODEL_AMBIENT, c);
		glLightModelf(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
		glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);
		float d[4] = { 0.5, 0.5, 0.5, 1 };
		glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, d);

	}

	if (Texture_mod == 1) {
		int i = 0,local_flag=0;
		glEnable(GL_TEXTURE_2D);

		for (i = 0; i < Texture_height * Texture_width; i++) {
			if (local_flag == 0) local_flag = 1; else local_flag = 0;
			if (local_flag == 0) {
				data[i * 3] = 0x0;
				data[i * 3 + 1] = 0x0;
				data[i * 3 + 2] = 0x0;
			}
			else {
				data[i * 3] = 0xFF;
				data[i * 3 + 1] = 0xFF;
				data[i * 3 + 2] = 0xFF;
			}
		}
		
		
		glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
		glTexImage2D(GL_TEXTURE_2D, 0, 3, Texture_width, Texture_height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_REPEAT);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_REPEAT);	
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,GL_LINEAR);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,GL_LINEAR);
		//glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
		glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
	}

	cout << "TIME " << GetCounter() << "\n";
}
void draw(void)
{

	glClearColor(1.0, 1.0, 1.0, 0.0);
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
	DrawTor();

}

int main(int argc, _TCHAR* argv[])
{


	int i = 0;
	if (!glfwInit())
	{
		printf("glfwInit failed\n");
		return -1;
	}


	GLFWwindow* window;
	window = glfwCreateWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Test app", NULL, NULL);
	if (window == NULL)
	{
		printf("glfwOpenWindow failed. Can your hardware handle OpenGL 3.2?\n");
		glfwTerminate();
		return -2;
	}

	glfwMakeContextCurrent(window);

	glfwSetKeyCallback(window, keyboard_callback);
	glfwSetFramebufferSizeCallback(window, resize_callback);
	glfwSetMouseButtonCallback(window, mouse_callback);

	resize_callback(window, SCREEN_WIDTH, SCREEN_HEIGHT);

	CountTor();
	while (!glfwWindowShouldClose(window))
	{
		draw();
		glfwSwapBuffers(window);
		//glfwWaitEvents();
		glfwPollEvents();
	}

	glfwDestroyWindow(window);
	glfwTerminate();	

	for (i = 0; i < angle; i++) free(tor[i]);
	free(tor);
	for (i = 0; i < angle; i++) free(torn[i]);
	free(torn);

	free(data);
	return 0;
}