Draw Figures with GLUT using mouse buttons

Para poder dibujar las figuras predeterminadas de "glut" haremos clic izquierdo sobre queramos dibujar la figura y paso siguiente al presionar el botón secundario se desplegará un menú de las figuras y haremos clic en la figura que queramos dibujar.

Código Fuente:

#include <GL/gl.h>
#include <GL/glut.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>

using namespace std;

#define NP 4000
#define AGE 200

float winWid = 600.0,winHeight = 400.0;
float rx=winWid/2,ry=winHeight/2;
float Arreglo[3][500]={0.0};
int cont=0;
int a;

void redraw( void ){
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();


for(int i=0;i<cont;i++)
{
    a=Arreglo[2][i];
switch(a)
{

case 1:
glPushMatrix();
glTranslatef(Arreglo[0][i],Arreglo[1][i],0.0);
glColor3f(0,1,1);
glScalef(0.8,0.8,0.8);
glRotatef(60,0,1,1);
glutWireCube(0.2);
glPopMatrix();
break;

case 2:
glPushMatrix();
glTranslatef(Arreglo[0][i],Arreglo[1][i],0.0);
glColor3f(1,1,0);
glScalef(0.8,0.8,0.8);
glRotatef(90,1,0,1);
glutWireCone(0.2,0.5,10,10);
glPopMatrix();
break;

case 3:
glPushMatrix();
glTranslatef(Arreglo[0][i],Arreglo[1][i],0.0);
glColor3f(1,1,0);
glScalef(0.8,0.8,0.8);
glRotatef(60,0,1,1);
glutSolidTeapot(0.2);
glPopMatrix();
break;

case 4:
glPushMatrix();
glTranslatef(Arreglo[0][i],Arreglo[1][i],0.0);
glColor3f(1,0,1);
glScalef(0.8,0.8,0.8);
glRotatef(45,0,1,1);
glutWireSphere(0.2,15,15);
glPopMatrix();
break;

case 5:
glPushMatrix();
glTranslatef(Arreglo[0][i],Arreglo[1][i],0.0);
glColor3f(0,0,1);
glScalef(0.8,0.8,0.8);
glRotatef(60,0,1,1);
glutWireTorus(0.1,0.1,10,10);
glPopMatrix();
break;


case 6:
glPushMatrix();
glTranslatef(Arreglo[0][i],Arreglo[1][i],0.0);
glColor3f(1,1,1);
glScalef(0.2,0.2,0.2);
glRotatef(30,0,1,1);
glutWireOctahedron();
glPopMatrix();
break;


case 7:
glPushMatrix();
glTranslatef(Arreglo[0][i],Arreglo[1][i],0.0);
glColor3f(0,0,1);
glScalef(0.1,0.1,0.1);
glRotatef(30,0,1,1);
glutWireDodecahedron();
glPopMatrix();
break;


case 8:
glPushMatrix();
glTranslatef(Arreglo[0][i],Arreglo[1][i],0.0);
glColor3f(1,0,0);
glScalef(0.2,0.2,0.2);
glRotatef(60,0,1,1);
glutWireIcosahedron();
glPopMatrix();
break;

}

}
glutSwapBuffers();
}


void motion(int x, int y){
    cerr << "motion. x:" << x << ", y:" << y << " \n";
     rx = float(x);
     ry = winHeight - float(y);
}


void mousebutton(int button, int state, int x, int y){
    cerr << "mousebutton. x:" << x << ", y:" << y << " \n";
    if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN){
        rx = float(x);
        ry = winHeight - float(y);
        redraw();
    }
}

void menu(int opc)
{


    switch(opc)
    {
    case 1:
    Arreglo[0][cont]=(rx/(winWid/2))-1;
    Arreglo[1][cont]=(ry/(winHeight/2))-1;
    Arreglo[2][cont]=1;
    cont+=1;
    redraw();
     break;

     case 2:
     Arreglo[0][cont]=(rx/(winWid/2))-1;
     Arreglo[1][cont]=(ry/(winHeight/2))-1;
     Arreglo[2][cont]=2;
     cont+=1;
     redraw();
     break;

     case 3:
     Arreglo[0][cont]=(rx/(winWid/2))-1;
     Arreglo[1][cont]=(ry/(winHeight/2))-1;
     Arreglo[2][cont]=3;
     cont+=1;
     redraw();
     break;

     case 4:
     Arreglo[0][cont]=(rx/(winWid/2))-1;
     Arreglo[1][cont]=(ry/(winHeight/2))-1;
     Arreglo[2][cont]=4;
     cont+=1;
     redraw();
     break;

     case 5:
     Arreglo[0][cont]=(rx/(winWid/2))-1;
     Arreglo[1][cont]=(ry/(winHeight/2))-1;
     Arreglo[2][cont]=5;
     cont+=1;
     redraw();
     break;

     case 6:
     Arreglo[0][cont]=(rx/(winWid/2))-1;
     Arreglo[1][cont]=(ry/(winHeight/2))-1;
     Arreglo[2][cont]=6;
     cont+=1;
     redraw();
     break;


     case 7:
     Arreglo[0][cont]=(rx/(winWid/2))-1;
     Arreglo[1][cont]=(ry/(winHeight/2))-1;
     Arreglo[2][cont]=7;
     cont+=1;
     redraw();
     break;

     case 8:
     Arreglo[0][cont]=(rx/(winWid/2))-1;
     Arreglo[1][cont]=(ry/(winHeight/2))-1;
     Arreglo[2][cont]=8;
     cont+=1;
     redraw();
     break;
    }
}



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

    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
    glutCreateWindow("");
    glutPositionWindow(200,100);

    glutReshapeWindow(int(winWid),int(winHeight));
    glClearColor(0.0,0.0,0.0,1.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0.0,winWid,0.0,winHeight, -100.0, 100.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glutDisplayFunc(redraw);
    glutIdleFunc(redraw);
    glutMotionFunc(motion);
    glutMouseFunc(mousebutton);
    glutCreateMenu(menu);
    glutAddMenuEntry("Cube",1);
    glutAddMenuEntry("Cone",2);
    glutAddMenuEntry("Teapot",3);
    glutAddMenuEntry("Sphere",4);
    glutAddMenuEntry("Torus",5);
    glutAddMenuEntry("Octahedron",6);
    glutAddMenuEntry("Dodecahedron",7);
    glutAddMenuEntry("Icosahedron",8);
    glutAttachMenu(GLUT_RIGHT_BUTTON);

    glutMainLoop();
    return 0;
}

Mouse Button y Motion in OpenGL(glut)

Código Fuente:

#include <GL/gl.h>
#include <GL/glut.h>
#include <iostream>
#include <math.h>
#include <stdlib.h>

using namespace std;

#define NP 4000
#define AGE 200

float winWid,winHeight;
float rx,ry;

void redraw( void ){
    glClear(GL_COLOR_BUFFER_BIT);
    glColor3f(1.0,1.0,0.0); //Función para seleccionar el color
    glRectf(-10.0+rx,-10.0+ry,10.0+rx,10.0+ry);
    glutSwapBuffers(); //Realiza un intercambio en la capa en uso para la ventana actual.
                       //Específicamente, glutSwapBuffers promueve el contenido de la memoria
                       //intermedia posterior de la capa en el uso de la ventana actual para convertirse
                       // en el contenido del búfer frontal.
}

void motion(int x, int y){
    cerr << "motion. x:" << x << ", y:" << y << " \n";
     rx = float(x);
     ry = winHeight - float(y);
}


void mousebutton(int button, int state, int x, int y){
    cerr << "mousebutton. x:" << x << ", y:" << y << " \n";
    if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN){
        rx = float(x);
        ry = winHeight - float(y);
        redraw();
    }
}



int main(int argc, char *argv[]){
    winWid = 600.0;
    winHeight = 400.0;

    glutInit(&argc, argv);/*glutInit inicializará la biblioteca GLUT y negociar una sesión con el
     sistema de ventanas. Durante este proceso, glutInit puede causar la terminación del programa de
      GLUT con un mensaje de error al usuario si GLUT no puede ser inicializado correctamente. Ejemplos
      de esta situación son la falta de conexión con el sistema de ventanas, la falta de apoyo del sistema
       de ventanas para OpenGL y las opciones de línea de comandos no válidos.
    */

    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
    glutCreateWindow(" "); //Crea la ventana, entre las comillas puedes incluir un titulo de la ventana.
    glutPositionWindow(200,100); //Posición inicial de la ventana.

    glutReshapeWindow(int(winWid),int(winHeight));/*glutReshapeWindow solicita un cambio en el tamaño de la
    ventana actual. Los parámetros width y height son las extensiones de tamaño en píxeles. La anchura y la
    altura deben ser valores positivos.
    */

    glClearColor(0.0,0.0,0.0,1.0);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    glOrtho(0.0,winWid,0.0,winHeight, -100.0, 100.0);/*glOrtho describe una transformación que produce una proyección paralela.
     La matriz actual (ver glMatrixMode) se multiplica por esta matriz y el resultado reemplaza la matriz actual.
    */


    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glutDisplayFunc(redraw);


    glutIdleFunc(redraw);/*glutIdleFunc establece la devolución de llamada ociosa mundial que se FUNC así que un programa GLUT
     pueda realizar tareas de procesamiento de fondo o la animación continua cuando no se están recibiendo los eventos del
     sistema de la ventana. Si se habilita, el callback de inactividad se llama continuamente cuando no se reciben eventos.
    */


    glutMotionFunc(motion);/*glutMotionFunc y glutPassiveMotionFunc establecen el
    movimiento y la devolución de llamada de movimiento pasivo, respectivamente, para la ventana actual.
    La devolución de llamada propuesta de la ventana se llama cuando el ratón se mueve dentro de la ventana,
     mientras que uno o más botones del ratón se presionan. La devolución de llamada de movimiento pasivo de una
     ventana se llama cuando el ratón se mueve dentro de la ventana, mientras que no hay botones del ratón se presionan.
    */


    glutMouseFunc(mousebutton);/*glutMouseFunc establece la devolución de llamada del ratón para la ventana actual.
     Cuando un usuario pulsa y botones de comunicados de ratón en la ventana, cada pulsación y cada versión genera
     una devolución de llamada de ratón. El parámetro de botón es uno de GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON o
     GLUT_RIGHT_BUTTON. Para los sistemas con sólo dos botones del ratón, puede no ser posible generar GLUT_MIDDLE_BUTTON
      devolución de llamada.
    */


    glutMainLoop();
    return 0;
}

Coordinates with GLUT OpenGL (DRAW FIGURES)

Código Fuente:

//Las figuras se dibujan presionando la tecla d;

#ifdef __APPLE__

#include <GLUT/glut.h>

#else

#include <GL/gl.h>

#include <GL/glut.h>

#endif

#include <stdlib.h>

#include <iostream>

using namespace std;

float valor_x=0.0,valor_y=0.0;

float x1=0.0,y1=1.0,x2=0.0,y2=-1.0,x3=-1.0,y3=0.0,x4=1.0,y4=0.0;

int cont=0,i=0;

float Arreglo[2][200]={0.0};

void display()

{

glClearColor(0,0,0,0);

glClear(GL_COLOR_BUFFER_BIT);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

        glPushMatrix();

        glPointSize(10);

        glLineWidth(2);

        glColor3f(0.0,0.0,1.0);

        glBegin(GL_LINES);

        glVertex2d(x1,y1);

        glVertex2d(x2,y2);

        glVertex2d(x3,y3);

        glVertex2d(x4,y4);

        glEnd();

        glPopMatrix();

     i=0;

    while(i<cont)

    {

     glPushMatrix();

     glTranslatef(Arreglo[0][i],Arreglo[1][i],0);

     glColor3f(1,0,0);

     glRotatef(70,0,1,1);

     glutWireCube(0.1);

     glPopMatrix();

     i+=1;

     }

        glFlush();

}

void keyinput(unsigned char key, int x, int  y)

{

    switch(key)

    {

 case 'q':

    exit(0);

    break;

 case 'd':

     Arreglo[0][cont]=valor_x;

     Arreglo[1][cont]=valor_y;

     cont+=1;

     glutPostRedisplay();

        break;

    }

}

void  specialKeyInput(int key,int x,int y)

{

    if(key==GLUT_KEY_DOWN)

    {

        valor_y-=0.2;

         y3-=0.2;

         y4-=0.2;

         y2-=0.2;

        if(valor_y<=float(-1.1) and valor_y>float(-1.3))

        {

         valor_y=1.0;

         y3=1;

         y4=1;

        }

        glutPostRedisplay();

    }

    if(key==GLUT_KEY_UP)

    {

        valor_y+=0.2;

         y3+=0.2;

         y4+=0.2;

         y1+=0.2;

        if(valor_y>=float(1.1) and valor_y<float(1.3))

        {

         valor_y=-1.0;

         y3=-1.0;

         y4=-1.0;

        }

        glutPostRedisplay();

    }

    if(key==GLUT_KEY_LEFT)

    {

        valor_x-=0.2;

         x1-=0.2;

         x2-=0.2;

         x3-=0.2;

        if(valor_x<=float(-1.1) and valor_x>float(-1.3))

        {

         valor_x=1.0;

         x1=1.0;

         x2=1.0;

        }

        glutPostRedisplay();

    }

    if(key==GLUT_KEY_RIGHT)

    {

        valor_x+=0.2;

         x1+=0.2;

         x2+=0.2;

         x4+=0.2;

        if(valor_x>=float(1.1) and valor_x<float(1.3))

        {

         valor_x=-1.0;

         x1=-1.0;

         x2=-1.0;

        }

        glutPostRedisplay();

    }

}

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

{

  cerr << "main () \n";

  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);

  glutInitWindowSize(500,500);

  glutCreateWindow("");

  glutDisplayFunc(display);

  glutKeyboardFunc(keyinput);

  glutSpecialFunc(specialKeyInput);

  glutMainLoop();

}