//AUTORES : NEIRA PAUCAR HENRY

// OBREGON CASTRO JAIRO

#include <iostream>

#include <stdlib.h>
#include<stdio.h>
#include <string.h>
//using std::exit;
#include <GL/glut.h> // GLUT stuff, includes OpenGL headers as well DEBE ESTAR EN
UN PROJECT YA QUE NECESITA EL OPENGL
#include <windows.h>
#include <math.h>
#include <gl/Gl.h>
#include <gl/Glu.h>
using namespace std;
int SCREEN_HEIGHT = 480;
// Keep track of times clicked, on 3 clicks draw.
int NUMPOINTS = 0;
int paso=0;
unsigned int LOD=20;
int estado=0;
int estado2=0;

int numPuntos=0;
int dibujar=0;
int numVector1=0;
int numVector2=0;
int valVector1=0;
int valVector2=0;
// Point class to keep it a little cleaner.
class Point {
public:
float x, y, z;
void setxy(float x2, float y2) { x = x2; y = y2; }
const Point & operator=(const Point &rPoint) {
x = rPoint.x;
y = rPoint.y;
z = rPoint.z;

return *this;
}

};

double v1_x=50;
double v1_y=50;
double v2_x=40;
double v2_y=10;

double vector_1[2];
double vector_2[2];

Point abc[2];
Point mod;
Point puntero;

double Punto_1[2][9];
double Punto_2[2][9];
void calcular_x()
{
v1_x=vector_1[0]-abc[0].x;
v1_y=abc[0].y-vector_1[1];
}

void calcular_y()
{
v2_x=vector_2[0]-abc[1].x;
v2_y=abc[1].y-vector_2[1];
}

void myInit() {

glPointSize(4.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0,640.0,0.0,480.0);
glClearColor(1.0,1.0,1.0,0.0);

void drawDot(int x, int y) {

glColor3f(0.7,0.3,0.5);
glBegin(GL_POINTS);
glVertex2i(x,y);
glEnd();
glFlush();
}

void drawLine(Point p1, Point p2) {

glBegin(GL_LINES);
glVertex3f(p1.x, p1.y, p1.z);
glVertex3f(p2.x, p2.y, p2.z);

glEnd();
glFlush();
}

// Calculate the next bezier point.

Point hermite(Point A1, Point B1, double t) {

Point P ;

float b0 = 2*t*t*t - 3*t*t + 1;

float b1 = -2*t*t*t + 3*t*t;
float b2 = t*t*t - 2*t*t + t;
float b3 = t*t*t - t*t;

P.x=b0*A1.x +
b1*B1.x +
+b2*v1_x+b3*v2_x;

P.y = b0*A1.y +
b1*B1.y +
+b2*-v1_y+b3*-v2_y;
 P.z = b0*A1.z +
b1*B1.z +
b2*0 +
b3*0 ;
return P;
}
void drawVector1()
{

glBegin(GL_LINES);
glVertex2i(abc[0].x,abc[0].y);
glVertex2i(abc[0].x+v1_x,abc[0].y-v1_y);
glEnd();
glFlush();

}
void drawVector1ROJO()
{

glColor3f(1.,0.0,0.0);
glBegin(GL_LINES);
glVertex2i(abc[0].x,abc[0].y);
glVertex2i(abc[0].x+v1_x,abc[0].y-v1_y);
glEnd();
glFlush();

}
void drawVector1AZUL()
{

glColor3f(0.0,1.0,0.0);
glBegin(GL_LINES);
glVertex2i(abc[0].x,abc[0].y);
glVertex2i(abc[0].x+v1_x,abc[0].y-v1_y);
glEnd();
glFlush();

}
void drawVector1VERDE()
{

glColor3f(0.0,0.0,1.0);
glBegin(GL_LINES);
glVertex2i(abc[0].x,abc[0].y);
glVertex2i(abc[0].x+v1_x,abc[0].y-v1_y);
glEnd();
glFlush();

}
void drawVector2()
{

glBegin(GL_LINES);
glVertex2i(abc[1].x,abc[1].y);
glVertex2i(abc[1].x+v2_x,abc[1].y-v2_y);
glEnd();
 glFlush();

}
void drawVector2ROJO()
{

glColor3f(1.0,0.0,0.0);

glBegin(GL_LINES);
glVertex2i(abc[1].x,abc[1].y);
glVertex2i(abc[1].x+v2_x,abc[1].y-v2_y);
glEnd();
glFlush();

}
void drawVector2AZUL()
{

glColor3f(0.0,1.0,0.0);

glBegin(GL_LINES);
glVertex2i(abc[1].x,abc[1].y);
glVertex2i(abc[1].x+v2_x,abc[1].y-v2_y);
glEnd();
glFlush();

}
void drawVector2VERDE()
{

glColor3f(0.0,0.0,1.0);

glBegin(GL_LINES);
glVertex2i(abc[1].x,abc[1].y);
glVertex2i(abc[1].x+v2_x,abc[1].y-v2_y);
glEnd();
glFlush();

void Linea_Hermite()
{
drawVector1();
drawVector2();
drawDot(abc[0].x, abc[0].y);
drawDot(abc[1].x, abc[1].y);

Point POld = abc[0];

/* Draw each segment of the curve. Make t increment in
smaller amounts for a more detailed curve. */
for(double i = 0.0;i < LOD; i += 0.1) {
float t = (float)i/(LOD-1);
Point P = hermite(abc[0], abc[1] , t);
drawLine(POld, P);
POld = P;
}
//glColor3f(1.0,0.0,0.0);
}
void Linea_HermiteOsucuro()
{
drawVector1();
drawVector2();
drawDot(abc[0].x, abc[0].y);
drawDot(abc[1].x, abc[1].y);
glColor3f(0.0,0.0,0.0);
Point POld = abc[0];
/* Draw each segment of the curve. Make t increment in
smaller amounts for a more detailed curve. */
for(double i = 0.0;i < LOD; i += 0.1) {
float t = (float)i/(LOD-1);
Point P = hermite(abc[0], abc[1] , t);
drawLine(POld, P);
POld = P;
}
glColor3f(1.0,1.0,1.0);
}

void Linea_HermiteROJO()
{
// drawVector1();
// drawVector2();
drawDot(abc[0].x, abc[0].y);
drawDot(abc[1].x, abc[1].y);
glColor3f(1.0,0.0,0.0);
Point POld = abc[0];
/* Draw each segment of the curve. Make t increment in
smaller amounts for a more detailed curve. */
for(double i = 0.0;i < LOD; i += 0.1) {
float t = (float)i/(LOD-1);
Point P = hermite(abc[0], abc[1] , t);
drawLine(POld, P);
POld = P;
}
glColor3f(1.0,1.0,1.0);
}
void Linea_HermiteAZUL()
{
// drawVector1();
// drawVector2();
drawDot(abc[0].x, abc[0].y);
drawDot(abc[1].x, abc[1].y);
glColor3f(0.0,1.0,0.0);
Point POld = abc[0];
/* Draw each segment of the curve. Make t increment in
smaller amounts for a more detailed curve. */
for(double i = 0.0;i < LOD; i += 0.1) {
float t = (float)i/(LOD-1);
Point P = hermite(abc[0], abc[1] , t);
drawLine(POld, P);
POld = P;
}
glColor3f(1.0,1.0,1.0);
}
void Linea_HermiteVERDE()
{
// drawVector1();
// drawVector2();
drawDot(abc[0].x, abc[0].y);
 drawDot(abc[1].x, abc[1].y);
glColor3f(0.0,0.0,1.0);
Point POld = abc[0];
/* Draw each segment of the curve. Make t increment in
smaller amounts for a more detailed curve. */
for(double i = 0.0;i < LOD; i += 0.1) {
float t = (float)i/(LOD-1);
Point P = hermite(abc[0], abc[1] , t);
drawLine(POld, P);
POld = P;
}
glColor3f(1.0,1.0,1.0);
}

void myMouse(int button, int state, int x, int y) {

// If left button was clicked
if(paso==0){
drawDot(abc[0].x, abc[0].y);
drawDot(abc[1].x, abc[1].y);

}
if(paso==1){
if(button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
if(numPuntos<2)
{
// Store where the user clicked, note Y is backwards.
abc[NUMPOINTS].setxy((float)x,(float)(SCREEN_HEIGHT - y));
NUMPOINTS++;

// Draw the red dot.

drawDot(x, SCREEN_HEIGHT - y);

// If 2 points are drawn do the curve.

if(NUMPOINTS == 2) {
NUMPOINTS = 0;
}
numPuntos++;
}
if(numPuntos==1||numPuntos==0)
{
dibujar=0;
}
if(numPuntos>=2)
{
numPuntos=0;
dibujar=1;
}

}
if(paso==4){
if(button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
glColor3f(0.7,0.3,0.5);
Linea_Hermite();
}
}
if(paso==3)
{
if(button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
// Linea_Hermite();
int numX_1=abc[0].x+v1_x-5;
int numY_1=abc[0].y-v1_y-5;
int numX_2=abc[1].x+v2_x-5;
int numY_2=abc[1].y-v2_y-5;

int numX_11=abc[0].x-5;
int numY_11=abc[0].y-5;
int numX_22=abc[1].x-5;
int numY_22=abc[1].y-5;

if(estado2==1)
{
if(estado==1)
{
glClear(GL_COLOR_BUFFER_BIT);
vector_1[0]=x;
vector_1[1]=SCREEN_HEIGHT - y;
calcular_x();
drawDot(x, SCREEN_HEIGHT - y);
drawVector1();
estado=0;
Linea_Hermite();
}
if(estado==2)
{
glClear(GL_COLOR_BUFFER_BIT);
vector_2[0]=x;
vector_2[1]=SCREEN_HEIGHT - y;
calcular_y();
drawDot(x, SCREEN_HEIGHT - y);
drawVector2();
estado=0;
Linea_Hermite();
}
if(estado==3)
{
glClear(GL_COLOR_BUFFER_BIT);
abc[0].setxy((float)x,(float)(SCREEN_HEIGHT - y));
drawDot(x, SCREEN_HEIGHT - y);
drawVector1();
estado=0;
Linea_Hermite();
}
if(estado==4)
{
glClear(GL_COLOR_BUFFER_BIT);
abc[1].setxy((float)x,(float)(SCREEN_HEIGHT - y));
drawVector2();
estado=0;
Linea_Hermite();
}
estado2=2;
}
if(estado2==0)
{
bool bandera=false;
for(int k=0;k<11;k++)
 {
for(int j=0;j<11;j++)
{
if((x==numX_1+j)&&((SCREEN_HEIGHT - y)==numY_1+k))
{
glColor3f(0.7,0.3,0.5);
estado=1;
drawDot(x, SCREEN_HEIGHT - y);
bandera=true;
estado2=1;
break;
}
if((x==numX_2+j)&&((SCREEN_HEIGHT - y)==numY_2+k))
{
glColor3f(0.7,0.3,0.5);
estado=2;
estado2=1;
drawDot(x, SCREEN_HEIGHT - y);
bandera=true;
break;
}
if((x==numX_11+j)&&((SCREEN_HEIGHT - y)==numY_11+k))
{
glColor3f(0.7,0.3,0.5);
estado=3;
estado2=1;
drawDot(x, SCREEN_HEIGHT - y);
bandera=true;
break;
}
if((x==numX_22+j)&&((SCREEN_HEIGHT - y)==numY_22+k))
{
glColor3f(0.7,0.3,0.5);
estado=4;
estado2=1;
drawDot(x, SCREEN_HEIGHT - y);
bandera=true;
break;
}
}
if(bandera==true)
{
break;
bandera=false;
}
}
}
if(estado2==2)
{
estado2=0;
}

}
}
if(paso==2)
{
if(numPuntos==1)
{
 dibujar=0;
}
if(numPuntos==1)
{
numPuntos=0;
dibujar=1;
}

}
if(paso==5)
{
if(button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
//Linea_Hermite();
if(dibujar==1)
{
int numX_1=abc[0].x+v1_x-5;
int numY_1=abc[0].y-v1_y-5;
int numX_2=abc[1].x+v2_x-5;
int numY_2=abc[1].y-v2_y-5;

int numX_11=abc[0].x-5;
int numY_11=abc[0].y-5;
int numX_22=abc[1].x-5;
int numY_22=abc[1].y-5;

if(estado2==1)
{
if(estado==3||estado==4)
{
if(estado==3)
{
glClear(GL_COLOR_BUFFER_BIT);
vector_1[0]=x;
vector_1[1]=SCREEN_HEIGHT - y;
calcular_x();
drawDot(x, SCREEN_HEIGHT - y);
// drawVector1();
estado=0;
// Linea_Hermite();
numVector1++;
}
if(estado==4)
{
glClear(GL_COLOR_BUFFER_BIT);
vector_2[0]=x;
vector_2[1]=SCREEN_HEIGHT - y;
calcular_y();
drawDot(x, SCREEN_HEIGHT - y);
// drawVector2();
estado=0;
// Linea_Hermite();
numVector2++;
}
if(numVector2>0&&numVector1>0)
{
drawVector1();
drawVector2();
}
else if(numVector2>0)
 {
drawVector2();
}
else if(numVector1>0)
{
drawVector1();
}
/*if(estado==3)
{
glClear(GL_COLOR_BUFFER_BIT);
abc[0].setxy((float)x,(float)(SCREEN_HEIGHT - y));
drawDot(x, SCREEN_HEIGHT - y);
drawVector1();
estado=0;
Linea_Hermite();
}
if(estado==4)
{
glClear(GL_COLOR_BUFFER_BIT);
abc[1].setxy((float)x,(float)(SCREEN_HEIGHT - y));
drawVector2();
estado=0;
Linea_Hermite();
}*/
estado2=2;

}
if(estado2==0)
{
bool bandera=false;
for(int k=0;k<11;k++)
{
for(int j=0;j<11;j++)
{
if((x==numX_11+j)&&((SCREEN_HEIGHT - y)==numY_11+k))
{
glColor3f(0.7,0.3,0.5);
estado=3;
estado2=1;
drawDot(x, SCREEN_HEIGHT - y);
bandera=true;
break;
}
if((x==numX_22+j)&&((SCREEN_HEIGHT - y)==numY_22+k))
{
glColor3f(0.7,0.3,0.5);
estado=4;
estado2=1;
drawDot(x, SCREEN_HEIGHT - y);
bandera=true;
break;
}
}
if(bandera==true)
{
break;
bandera=false;
 }
}
}
if(estado2==2)
{
estado2=0;
}

glColor3f(1.0,0.0,0.0);
drawDot(abc[0].x, abc[0].y);
drawDot(abc[1].x, abc[1].y);
}

void myDisplay() {
glClear(GL_COLOR_BUFFER_BIT);
glFlush();
}

void menu_PtsCurva(int opcion){

switch(opcion){
case 1: paso=1; break;
case 2: paso=2; break;

}
void menu_Vectores(int opcion){
switch(opcion)
{
case 1: paso=5; break;
case 2: paso=2; break;

}
void menu_dibuja(int opcion){
if(numVector1>0&&numVector2>0)
{
switch(opcion){
case 1:Linea_Hermite(); break;
case 2: Linea_HermiteOsucuro();break;
}

}
}
void menu_modifica(int opcion){
if(numVector1>0&&numVector2>0)
 {
switch(opcion){
case 1:paso=3;
//glutPostRedisplay() ;
// Linea_Hermite();
break;
case 2: paso=0;
Linea_Hermite();break;

}
void menu_curvaVector(int opcion){

}
////////////
void menu_colorCurva(int opcion){
if(numVector1>0&&numVector2>0)
{
switch(opcion){
case 1: Linea_HermiteROJO(); break;
case 2: Linea_HermiteAZUL(); break;
case 3: Linea_HermiteVERDE(); break;
}
}
}

void menu_colorVector(int opcion){

if(numVector1>0&&numVector2>0)
{
switch(opcion){
case 1: drawVector1ROJO();drawVector2ROJO(); break;
case 2: drawVector1AZUL(); drawVector2AZUL();break;
case 3: drawVector1VERDE(); drawVector2VERDE();break;
}
}
}
void menu_principal(int op){}

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

cout<<"============================================================================
=============="<<endl;
cout<<"PARA MODIFICAR LOS PUNTOS DE LA CURVA "<<endl;
cout<<"SOLO DEBE HACER CLICK EN CUALQUIER EXTREMO DE LA CURVA Y SELECCIONAR UN
NUEVO PUNTO EN LA PANTALLA CON UN CLICK DEL MOUSE"<<endl;

cout<<"============================================================================
=============="<<endl;
cout<<"PARA MODIFICAR LA DIRECCION DEL VECTOR "<<endl;
cout<<"SOLO DEBE HACER CLICK EN UN EXTREMO DE CUALQUIER VECTOR Y SELECCIONAR UN
NUEVO PUNTO EN LA PANTALLA CON UN CLICK DEL MOUSE"<<endl;
cout<<"============================================================================
=============="<<endl;
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE|GLUT_RGB);
glutInitWindowSize(640,480);
glutInitWindowPosition(100,150);
myInit();
glutCreateWindow("Bezier Curve");
int submenu_glut=glutCreateMenu(menu_PtsCurva);
glutAddMenuEntry("Activado",1);
glutAddMenuEntry("Desactivado",2);

int submenu_Vectores=glutCreateMenu(menu_Vectores);
glutAddMenuEntry("Activado",1);
glutAddMenuEntry("Desactivado",2);

int submenu_Dibuja=glutCreateMenu(menu_dibuja);
glutAddMenuEntry("Activado",1);
glutAddMenuEntry("Desactivado",2);

int submenu_modifica=glutCreateMenu(menu_modifica);
glutAddMenuEntry("Activado",1);
glutAddMenuEntry("Desactivado",2);

int submenu_colorCurva=glutCreateMenu(menu_colorCurva);
glutAddMenuEntry("Rojo",1);
glutAddMenuEntry("Verde",2);
glutAddMenuEntry("Azul",3);

int submenu_colorVectores=glutCreateMenu(menu_colorVector);
glutAddMenuEntry("Rojo",1);
glutAddMenuEntry("Verde",2);
glutAddMenuEntry("Azul",3);

int submenu_CurvaVector=glutCreateMenu(menu_curvaVector);
glutAddSubMenu("Curva",submenu_colorCurva);
glutAddSubMenu("Vector",submenu_colorVectores);

int menu=glutCreateMenu(menu_principal);
glutAddSubMenu("Ingresar Puntos de Curva",submenu_glut);
glutAddSubMenu("Ingresar Vectores",submenu_Vectores);
glutAddSubMenu("Dibujar",submenu_Dibuja);
glutAddSubMenu("Modificar Curva y Vector",submenu_modifica);
glutAddSubMenu("Color",submenu_CurvaVector);
glutAddMenuEntry("Esc",6);

glutAttachMenu(GLUT_RIGHT_BUTTON);
// glutKeyboardFunc(keyboard);
glutMouseFunc(myMouse);
glutDisplayFunc(myDisplay);
myInit();
glutMainLoop();

return 0;
}