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();

}

Move figure across arrow keys OpenGL(GLUT)

Código Fuente:

#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;

void display()

{

glClearColor(0,0,0,0);

glClear(GL_COLOR_BUFFER_BIT);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

glPushMatrix();

glTranslatef(valor_x,valor_y,0);

glColor3f(1,0,0);

glRotatef(70,0,1,1);

glutWireCube(0.1);

glPopMatrix();

glFlush();

}

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

{

    switch(key)

    {

 case 'q':

    exit(0);

    break;

 case 'r':

    glutPostRedisplay();

    break;

    }

}

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

{

    if(key==GLUT_KEY_DOWN)

    {

        valor_y-=0.2;

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

         valor_y=1.0;

        glutPostRedisplay();

    }

    if(key==GLUT_KEY_UP)

    {

        valor_y+=0.2;

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

         valor_y=-1.0;

        glutPostRedisplay();

    }

    if(key==GLUT_KEY_LEFT)

    {

        valor_x-=0.2;

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

         valor_x=1.0;

        glutPostRedisplay();

    }

    if(key==GLUT_KEY_RIGHT)

    {

        valor_x+=0.2;

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

         valor_x=-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();

}

Figures predesigned of OpenGL(glut)

Código Fuente:

#ifdef __APPLE__

#include <GLUT/glut.h>

#else

#include <GL/gl.h>

#include <GL/glut.h>

#endif

#include <stdlib.h>

#include <iostream>

using namespace std;

void display()

{

cerr << "display() \n";

glClearColor(0,0,0,0);

glClear(GL_COLOR_BUFFER_BIT);

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

glPushMatrix();

glTranslatef(-0.8,0.8,0.0);

glColor3f(1,0,1);

glScalef(0.8,0.8,0.8);

glRotatef(45,0,1,1);

glutWireSphere(0.2,15,15);

glPopMatrix();

glPushMatrix();

glTranslatef(-0.4,0.8,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();

glPushMatrix();

glTranslatef(0,0.8,0.0);

glColor3f(0,1,1);

glScalef(0.8,0.8,0.8);

glRotatef(60,0,1,1);

glutWireCube(0.2);

glPopMatrix();

glPushMatrix();

glTranslatef(-0.8,0.2,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();

glPushMatrix();

glTranslatef(-0.5,0.2,0.0);

glColor3f(1,1,1);

glScalef(0.2,0.2,0.2);

glRotatef(30,0,1,1);

glutWireOctahedron();

glPopMatrix();

glPushMatrix();

glTranslatef(-0.1,0.2,0.0);

glColor3f(0,0,1);

glScalef(0.1,0.1,0.1);

glRotatef(30,0,1,1);

glutWireDodecahedron();

glPopMatrix();

glPushMatrix();

glTranslatef(0.3,0.2,0.0);

glColor3f(1,0,0);

glScalef(0.2,0.2,0.2);

glRotatef(60,0,1,1);

glutWireIcosahedron();

glPopMatrix();

glPushMatrix();

glTranslatef(0.7,0.2,0.0);

glColor3f(0,1,1);

glScalef(0.2,0.2,0.2);

glRotatef(60,0,1,1);

glutWireOctahedron();

glPopMatrix();

glPushMatrix();

glTranslatef(0.5,0.75,0.0);

glColor3f(1,1,0);

glScalef(0.8,0.8,0.8);

glRotatef(60,0,1,1);

glutSolidTeapot(0.2);

glPopMatrix();

glFlush();

}

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

{

  cerr << "main () \n";

  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);

  glutInitWindowSize(550,450);

  glutCreateWindow("");

  glutDisplayFunc(display);

  glutMainLoop();

}

Lines Matrix and points Matrix with OpenGL(GLUT)

Matriz De Lineas

Código fuente:

/*

 * GLUT Shapes Demo

 *

 * Written by Nigel Stewart November 2003

 *

 * This program is test harness for the sphere, cone

 * and torus shapes in GLUT.

 *

 * Spinning wireframe and smooth shaded shapes are

 * displayed until the ESC or q key is pressed.  The

 * number of geometry stacks and slices can be adjusted

 * using the + and - keys.

 */

#ifdef __APPLE__

#include <GLUT/glut.h>

#else

#include <GL/gl.h>

#include <GL/glut.h>

#endif

#include <stdlib.h>

static void display(void)

{

 glMatrixMode(GL_PROJECTION);

 glLoadIdentity();

 glClear(GL_COLOR_BUFFER_BIT);

 glPointSize(10);

 glLineWidth(5);

 glColor3f(1.0,0.0,0.0);

 glBegin(GL_LINES);

    for(double i=-1;i<=1;i+=0.1)

      {

        glVertex2d(-1,-i);

        glVertex2d(1,-i);

        glVertex2d(i,-1);

        glVertex2d(i,1);

      }

     glEnd();

     glFlush();

}

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

{

  glutInit(&argc,argv);

  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

  glutInitWindowSize(300,300);

  glutInitWindowPosition(0,0);

  glutCreateWindow("Matriz de Lineas");

  glutDisplayFunc(display);

  glutMainLoop();

}

Resultado:

Matriz de Puntos 

Código Fuente:

/*

 * GLUT Shapes Demo

 *

 * Written by Nigel Stewart November 2003

 *

 * This program is test harness for the sphere, cone

 * and torus shapes in GLUT.

 *

 * Spinning wireframe and smooth shaded shapes are

 * displayed until the ESC or q key is pressed.  The

 * number of geometry stacks and slices can be adjusted

 * using the + and - keys.

 */

#ifdef __APPLE__

#include <GLUT/glut.h>

#else

#include <GL/gl.h>

#include <GL/glut.h>

#endif

#include <stdlib.h>

static void display(void)

{

 glMatrixMode(GL_PROJECTION);

 glLoadIdentity();

 glClear(GL_COLOR_BUFFER_BIT);

 glPointSize(10);

 glLineWidth(5);

 glColor3f(1.0,0.0,0.0);

 glBegin(GL_POINTS);

    for(double x=-1; x<=1;x+=0.1)

    {

        for(double y=1;y>=-1;y-=0.1)

        {

            glVertex2f(x,y);

        }

    }

     glEnd();

     glFlush();

}

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

{

  glutInit(&argc,argv);

  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

  glutInitWindowSize(300,300);

  glutInitWindowPosition(0,0);

  glutCreateWindow("Matriz de Puntos");

  glutDisplayFunc(display);

  glutMainLoop();

}

Resultado:

Nested Triangles OpenGL (GLUT)

Código Fuente

#ifdef __APPLE__

#include <GLUT/glut.h>

#else

#include <GL/gl.h>

#include <GL/glut.h>

#endif

#include <stdlib.h>

static void display(void)

{

 glMatrixMode(GL_PROJECTION);

 glLoadIdentity();

 glClear(GL_COLOR_BUFFER_BIT);

 glPointSize(10);

 glLineWidth(5);

 glColor3f(1.0,0.0,0.0);

 glBegin(GL_TRIANGLES);

for(double i=1;i>0.1;i-=0.1)

{

    glColor3f(-i,i,-i);

    glVertex2f(-i,-i);

    glVertex2f(i,-i);

    glVertex2f(0,i);

}

     glEnd();

     glFlush();

}

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

{

  glutInit(&argc,argv);

  glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

  glutInitWindowSize(200,200);

  glutInitWindowPosition(0,0);

  glutCreateWindow("Triangulos");

  glutDisplayFunc(display);

  glutMainLoop();

}

Resultado

Drawing nested squares OpenGL(GLUT)

Código Fuente

#ifdef __APPLE__

#include <GLUT/glut.h>

#else

#include <GL/gl.h>

#include <GL/glut.h>

#endif

#include <stdlib.h>

static void display(void)

{

glMatrixMode(GL_PROJECTION);

glLoadIdentity();

glClear(GL_COLOR_BUFFER_BIT);

glPointSize(10);

glLineWidth(5);

glBegin(GL_QUADS);

for(double i=1;i>=0;i-=0.1)

{

glColor3f(i,-i,-i);

glVertex2f(-i,i);

glVertex2f(i,i);

glVertex2f(i,-i);

glVertex2f(-i,-i);

}

glEnd();

glFlush();

}

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

{

glutInit(&argc,argv);

glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);

glutInitWindowSize(200,200);

glutInitWindowPosition(0,0);

glutCreateWindow("Cuadros");

glutDisplayFunc(display);

glutMainLoop();

}

Resultado

Software Elements GUI

Historia de la GUI

Precursores

Los investigadores del Stanford Research Institute liderados por Douglas Engelbart, desarrollaron una interfaz de hipervínculos en modo texto gobernada por un ratón, que también inventaron. Este concepto fue ampliado y trasladado al entorno gráfico por los investigadores del Xerox PARC en la ciudad estadounidense de Palo Alto. El entorno se denominó PARC User Interface y en él se definieron los conceptos de ventanas, casilla de verificación, botones de radio, menús y puntero del ratón. La interfaz fue implementada comercialmente en el computador Xerox Star 8010.

Xerox Alto

El Xerox Alto, desarrollado en el Xerox PARC en 1973, fue el primer ordenador personal, así como el primero que utilizó la metáfora de escritorio y una interfaz gráfica de usuario.

Xerox Star 8010

La estación de trabajo Xerox Star, conocida oficialmente como el "8010 Star Information System" (Sistema de Información Estrella 8010) fue introducida por Xerox Corporation en 1981. Fue el primer sistema comercial en incorporar varias tecnologías que han llegado a ser hoy en día corrientes en computadores personales, incluyendo la pantalla con bitmaps en lugar de solo texto, una interfaz gráfica de usuario basada en ventanas, iconos, carpetas, ratón, red Ethernet, servidores de archivos, servidores de impresoras y e-mail.

Apple Lisa, Macintosh, Apple II GS

Tras una visita al Xerox PARC en 1979, el equipo de Apple encabezado por Jef Raskin se concentra en diseñar un entorno gráfico para su nueva generación de 16 bits, que se verá plasmado en el Apple Lisa en 1983. Ese sistema gráfico es portado al sucesor del Apple II, el Apple II GS. Un segundo equipo trabaja en el Apple Macintosh que verá la luz en 1984 con una versión mejorada del entorno gráfico del Lisa (pretendimos hacer un ordenador tan simple de manejar como una tostadora). Desde ese momento el Mac reinará como paradigma de usabilidad de un entorno gráfico; pese a que por debajo el sistema operativo sufra cambios radicales, los usuarios no avanzados no son conscientes de ello y no sufren los problemas de otras plataformas.

Workbench

Workbench es el nombre dado por Commodore a la interfaz gráfica del AmigaOS, el sistema operativo del Commodore Amiga lanzado en 1985. A diferencia de los sistemas más populares (GEM, Mac OS, MS Windows...) es un verdadero entorno multitarea sólo rivalizado por la interfaz X Window System de los diferentes sabores de Unix. La frase más repetida por un "amiguero" es: "para masacrar marcianos, formatear un diskette y enviar o recibir un Fax todo a la vez y sin colgarse, necesitas un 386 con disco duro, 16 MB de RAM y OS/2; un Amiga 500 con disquete y sólo su memoria base (512 KB de RAM y 512 KB de ROM) es capaz de todo eso". Aunque muy popular por los espectaculares (para entonces) gráficos de la máquina y su gran plantel de videojuegos, será la negligencia de sus sucesivos propietarios la principal causa de que acabe restringido a sólo la plataforma Amiga.

GEOS

Para el Commodore 64 y su sucesor el Commodore 128 se desarrolló el entorno gráfico GEOS en 1986. Este entorno se portó al IBM PC, fue utilizado en varias PDA y Nokia lo usó como base de su actual sistema operativo.

GEM

GEM (Graphical Environment Manager) es un GUI diseñado por Digital Research en 1988 para ejecutarse sobre varios sistemas operativos de línea de comandos del IBM PC y compatibles: funciona tanto sobre IBM DOS /MS-DOS como sobre CP/M 86. Su máxima popularidad en el PC llega de la mano del Amstrad PC1512 y del Amstrad PC1640, los clónicos que rompieron en Europa la barrera del precio popularizando el PC, hasta ese momento relegado mayoritariamente a oficinas. Aunque se incorpora en su primera generación de portátiles y en el Sinclair PC200, será sustituido en la siguiente generación de PCs Amstrad por Microsoft Windows 2.xx. En el PC vivirá una segunda juventud al venir de serie con DR-DOS como TaskMax.

Pero será en los Atari ST y sucesores donde se convertirá en el entorno gráfico oficial de la plataforma, alcanzando gran popularidad, tanto por ser en principio una alternativa barata al MAC en autoedición, como por hacerse con el nicho de mercado de la música profesional.

Apple y Microsoft

A principios de los años ochenta (en 1982) Apple, que había comenzado como una micro-empresa formada por dos empleados (Steve Jobs y Steve Wozniak) había crecido hasta convertirse en una empresa de 300 millones de dólares.

En el año 1983 Apple ya se había convertido en una empresa de 1000 millones de dólares, el mismo valor que IBM.

En 1987 IBM se vio obligada a entrar en el mercado de los ordenadores personales con entorno gráfico con su modelo PS/2, aliándose con Bill Gates (Microsoft), que había desarrollado el OS/2. La interfaz gráfica de este sistema operativo era muy similar a la de Apple.

Principales Elementos de GUI

• La ventana es el área sobre la pantalla sobre la que se muestra información, con su contenido siendo mostrada independientemente del resto de la pantalla. Un ejemplo de ventana es la que aparece en la pantalla cuando haces click en el icono de tu navegador de internet favorito. Es fácil manipular una ventana: puede ser abierta o cerrada con un simple click; pude moverse a cualquier área mediante arrastrarla; puede cambiarse su tamaño o minimizarse; puede colocarse enfrente o detrás de otra ventana, como las molestas ventanas en esos sitios que visitas; sus barras de desplazamiento pueden ser usadas para navegar las secciones que contiene; múltiples ventanas pueden ser abiertas al mismo tiempo con diferentes aplicaciones, etc

• Los menús permiten al usuario ejecutar comandos seleccionándolos de una lista de opciones. Las opciones disponibles pueden seleccionarse usando el ratón o el teclado. El uso de menús acelera la curva de aprendizaje de un nuevo usuario para entender una aplicación.

• La barra de menú es mostrada horizontalmente a lo largo de la parte superior de la ventana. El menú desplegable es comúnmente asociado con este tipo de menús. Cuando el usuario hace click sobre la opción el menú desplegable aparece.
• La barra de herramientas es un tipo de menú que muestra mayormente iconos en vez de texto.
• El menú tiene un título visible dentro de la barra de menú. Su contenido solo es mostrado cuando el usuario lo selecciona con un click. El usuario puede seleccionar los elementos dentro del menú desplegable. Normalmente, cuando el usuario hace click en cualquier otra parte del contenido el menu desaparece.
• El menú contextual es invisible hasta que el usuario hace click derecho sobre el objeto, o al mover el cursor sobre el objeto y presionar la tecla de menú contextual del teclado, entonces el menú contextual aparecerá cerca del cursor.
• Los extras son elementos individuales dentro o al lado de un menú.
• Un icono es una pequeña imagen que representa objetos como archivos, programas, páginas web, o comandos. Estos son una manera rápida de ejecutar comandos, abrir documentos, ejecutar programas, etc. Los iconos están diseñados de tal manera que no se requiera mayor explicación para entender que significa la pequeña imagen. 

Ver Presentación en Prezi

Computer Graphic Applications

APLICACIONES GRÁFICAS POR COMPUTADORA

u  La computación gráfica o gráficos por ordenador es el campo de la informática visual, donde se utilizan computadoras tanto para generar imágenes sintéticamente como integrar o cambiar la información visual y especial probada del mundo real.

Aplicaciones de la graficación

u  Interpretando en 3D en tiempo real (usado en juegos de vídeo).

u  Animación por computadora.

u  Captura de vídeo y creación de vídeo interpretado.

u  Edición de efectos especiales (a menudo usado para películas y televisión).

u  Edición de imagen y modelo (usado para ingeniería y objetivos médicos).

¿Qué es el CAD?

El diseño asistido por computadora en siglas DAO o mejor conocido como CAD (Computer Aided Desing) se trata básicamente de una base de datos de entidades geométricas como puntos, líneas o arcos, etc. Con el CAD se puede operar una interfaz gráfica para diseñar lo que se pida
.

Ventajas del CAD

u  En general los sistemas CAD mejoran la calidad del diseño y dan como resultado menor tiempo de realización de proyectos, a continuación se mencionan algunas de sus ventajas

u  La calidad de los dibujos, así como su manejo: los sistemas CAD/CAM operan a su máxima efectividad cuando los detalles estándar de los dibujos y los procedimientos de operación están en todo momento presentes. El software CAD requiere de entradas de información precisas, forzando al usuario a ser explícito en cuanto a acotaciones o datos del proyecto.

u  Diseño integrado: una base de datos, que es usada para diseño y análisis resulta en una relación de datos cohesiva, en vez de un diseño fragmentado, por lo tanto esto causa la ventaja de no repetir detalles en diseño y otros más en análisis al utilizar los dos en el mismo software.

u  Simulación: muchos sistemas de CAD, poseen la capacidad de modelar piezas en 3-D, al mostrar las piezas en forma isométrica ya no se requiere presentarlas en forma física.

u  Reducción de tiempo: la productividad (eficiencia) se logra a través de la automatización, en vez de los métodos manuales, al aplicar este tipo de programas, estos poseen librerías y dan a conocer detalles que facilitan el proyecto, por lo tanto existen menos demoras y se pueden terminar en menos tiempo.
Descargar Presentación