sábado, 22 de marzo de 2014

Dibujar al dar clic secundario con el Mouse

En esta práctica hacemos uso del ratón mediante las instrucciones mousebutton() que nos permite obtener las coordenadas donde se realiza el clic y dibujar la figura seleccionada implementando el uso de un menú desplegable utilizando el clic secundario mediante glutAttachMenu y las funciones glutCreateMenu para crear el menú y con glutAddMenuEntry sus opciones.


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

using namespace std; //Pues para mandar mensajes a pantala

#define NP 4000
#define AGE 200

float winWid,winHeight;
int rx,ry;//Declaracion de variables
float valores[30];
int count=0;
int countfig=0;
int figure[15];

//permitirá dibujar y recuperar la matriz 
void redraw(void){

    glClear(GL_COLOR_BUFFER_BIT);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();


    for(int i=0,j=0;i<count;i++,j++){
    glPushMatrix();
      double x=valores[i];
        i++;
      double y=valores[i];
        x=(x-250)/250;
        y=(y-250)/250;

      glTranslatef(x,y,0); //Mueve el punto de origen

      glColor3f(0.0,1.0,1.0);//Color

      if(figure[j]==1){
          glRotatef(55,9,22,0);
          glutWireCube(0.2);
       }
      if(figure[j]==2){
        glRotatef(45,0,1,1);
        glutWireSphere(.2,16,16);
      }
      if(figure[j]==3){
        glRotatef(60,1,0,0);
        glutWireTorus(0.05,0.15,12.0,32.0);
     }
     if(figure[j]==4)
       glutWireTeapot(0.2);

     if(figure[j]==5){
       glRotatef(60,1,0,0);
       glutWireCone(0.2,0.5,22.0,5.0);
     }
     if(figure[j]==6){
          glScalef(0.3,0.3,0.3);
          glRotatef(55,9,22,0);
          glutWireDodecahedron();
     }
     if(figure[j]==7){
            glScalef(0.2,0.2,0.1);
            glRotatef(45,0,1,1);
            glutWireIcosahedron();
     }

      glPopMatrix();

    }
    glFlush();
}



//metodo que nos permite obeter las coordenadas al dar clic izquierdo
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);//debuelve el valor de donde se dio clic en el eje x
        ry = winHeight - float(y);//debuelve el valor donde se dio clic en el eje y

    }
}

//programar menu
void menu(int opc){
   switch(opc){
    case 1:
      valores[count]=rx;
      count++;
      valores[count]=ry;
      count++;
        figure[countfig]=1;
        countfig++;
        redraw();
    break;
    case 2:
      valores[count]=rx;
      count++;
      valores[count]=ry;
      count++;
        figure[countfig]=2;
        countfig++;
        redraw();
        break;
    case 3:
      valores[count]=rx;
      count++;
      valores[count]=ry;
      count++;
        figure[countfig]=3;
        countfig++;
        redraw();
    break;
    case 4:
      valores[count]=rx;
      count++;
      valores[count]=ry;
      count++;
        figure[countfig]=4;
        countfig++;
        redraw();
        break;
    case 5:
      valores[count]=rx;
      count++;
      valores[count]=ry;
      count++;
       figure[countfig]=5;
       countfig++;
       redraw();
    break;

    case 6:
      valores[count]=rx;
      count++;
      valores[count]=ry;
      count++;
        figure[countfig]=6;
        countfig++;
        redraw();
    break;

    case 7:
     valores[count]=rx;
     count++;
     valores[count]=ry;
     count++;
        figure[countfig]=7;
        countfig++;
        redraw();
    break;

     }

}


main(int argc, char *argv[]){
    winWid = 590.0;
    winHeight = 550.0;
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
    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();

    glutCreateMenu(menu);//crear menu
    glutAddMenuEntry("Cubo",1);//opcion del menú
    glutAddMenuEntry("Esfera",2);
    glutAddMenuEntry("Dona",3);
    glutAddMenuEntry("Tetera",4);
    glutAddMenuEntry("Cono",5);
    glutAddMenuEntry("Dodecaedro",6);
    glutAddMenuEntry("Icosaedro",7);

    glutAttachMenu(GLUT_RIGHT_BUTTON);//al presionar clic secundario

    glutDisplayFunc(redraw);
    glutMouseFunc(mousebutton);
    glutMainLoop();

}

Mover y dibujar

En esta ocasión se realizó un programa que permitiera mover la cruz y al momento de presionar un tecla especifica dibujará la figura programada y así sucesivamente. Esto se logra mediante el uso de la funciones anteriormente utilizadas glTranslate, glMatrixMode(GL_PROJECTION) y las instrucciones specialKeyInput y keyInput.


#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <iostream>
#endif

#include <stdlib.h>

using namespace std;
float radio=0.0;
float valor_x=0.0;
float valor_y=0.0;
int contador=0;
float posx[30];
float posy[30];
int cont=0;
int entra=0;


//La función que nos va estar dibujando
void Dib(){
    //if(entra==1){
    for(int cont=0;cont<contador;cont++){
        glTranslatef(posx[cont],posy[cont],0.0);
        glPushMatrix();
        glLineWidth(1);
        glRotatef(45,0,1,1);
        glColor3f(1.0,1.0,0.0);
        glutWireSphere(0.2,15,15);
        glPopMatrix();
        glFlush();
        //glutPostRedisplay();
        cerr <<" cont:" <<cont;
    }

    //}
   // entra=0;

    //glutPostRedisplay();
}

void Dibuja(){
    cerr << "Dibuja() " << " valor_x:" << valor_x << " valor_y:" << valor_y << "\n";
    glClearColor(0,0,0,0);
    glClear(GL_COLOR_BUFFER_BIT);
    /*GL_PROJECTION permite mover el punto de referencia (0,0,0) a donde se le indique*/
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    cerr <<"antes:" <<cont;

    Dib();

    cerr <<"despues:" <<cont;
    glColor3f(0.0,1.0,1.0);
    glLineWidth(3);
    glTranslatef(valor_x,valor_y,0.0);
    glBegin(GL_LINE_STRIP);
    glVertex2d(valor_x+30,valor_y);
    glVertex2d(valor_x-30,valor_y);
    glVertex2d(valor_x,valor_y);
    glVertex2d(valor_x,valor_y+30);
    glVertex2d(valor_x,valor_y-30);
    glEnd();

    glFlush();

}


void keyInput(unsigned char key, int x, int y){

    switch(key){
    case 'q':
            exit(0);
    break;
    case 'a':
        cerr << "keyInput()" << " key:" << key;
        posx[contador]={valor_x};
        posy[contador]={valor_y};
        contador++;
        //entra=1;
    break;
    }

}

void specialKeyInput(int key, int x, int y){
    if(key==GLUT_KEY_DOWN){
        valor_y=valor_y-0.1;
        if(valor_y<=-1)
            valor_y=-1;
    }
    if(key == GLUT_KEY_LEFT){
        valor_x=valor_x-0.1;
        if(valor_x<=-1)
            valor_x=-1;
    }
    if(key == GLUT_KEY_UP){
        valor_y=valor_y+0.1;
        if(valor_y>=1)
            valor_y=1;
    }
    if(key == GLUT_KEY_RIGHT){
        valor_x=valor_x+0.1;
        if(valor_x>=1)
            valor_x=1;
    }

    glutPostRedisplay();
}




int main(){
    cerr <<"main() \n";
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
    glutInitWindowSize(550,550);
    glutCreateWindow("");
    glutDisplayFunc(Dibuja);
    glutKeyboardFunc(keyInput);
    glutSpecialFunc(specialKeyInput);
    glutMainLoop();
}


Uso del Teclado para dibujar

En esta ocasión se realizó un programa que permite realizar una acción reconociendo las teclas arriba, abajo,izquierda y derecha de nuestro teclado, esto se logra haciendo uso de la instrucción specialKeyInput, así como cualquier tecla de nuestro teclado mediante la instrucción keyInput.



#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <iostream>
#endif

#include <stdlib.h>

using namespace std;
float radio=0.0;
float valor_x=0.0;
float valor_y=0.0;


//La función que nos va estar dibujando

void Dibuja(){
    cerr << "Dibuja() " << " valor_x:" << valor_x << " valor_y:" << valor_y << "\n";
    glClearColor(0,0,0,0);
    glClear(GL_COLOR_BUFFER_BIT);
    /*GL_PROJECTION permite mover el punto de referencia (0,0,0) a donde se le indique*/
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    glTranslatef(valor_x,valor_y,0.0);
    glRotatef(60,1,0,0);
    //glRotated(1,0,0,1);
    glColor3f(1.0,1.0,0.0);
    glutWireSphere(0.2,15,15);
    glFlush();
}

void keyInput(unsigned char key, int x, int y){
    switch (key){
    case 'q':
            exit(0);
            break;
    }
}

void specialKeyInput(int key, int x, int y){
    if(key==GLUT_KEY_DOWN){
        valor_y=valor_y-0.1;
        if(valor_y<=-1)
            valor_y=-1;
    }
    if(key == GLUT_KEY_LEFT){
        valor_x=valor_x-0.1;
        if(valor_x<=-1)
            valor_x=-1;
    }
    if(key == GLUT_KEY_UP){
        valor_y=valor_y+0.1;
        if(valor_y>=1)
            valor_y=1;
    }
    if(key == GLUT_KEY_RIGHT){
        valor_x=valor_x+0.1;
        if(valor_x>=1)
            valor_x=1;
    }

    glutPostRedisplay();
}



int main(){
    cerr <<"main() \n";
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
    glutInitWindowSize(590,590);
    glutCreateWindow("");
    glutDisplayFunc(Dibuja);
    glutKeyboardFunc(keyInput);
    glutSpecialFunc(specialKeyInput);
    glutMainLoop();
}


Traladar, Escalar, Rotar una Figura

En esta ocación se analizó el funcionamiento de glScale, glTranslate y glRotate, la primera función nos permite establecer la escala de la lo que se dibuje en el eje x,y,z; la segunda función nos permite trasladar nuestro punto de origen para dibujar al lugar que se le indique en los ejes x,y,z y por último la tercera función nos permite girar lo que se haya dibujado estableciendo el águlo,y los ejes x,y,z. Es importante mencionar que en OpenGl lo que dibujamos al final de un segmento de código es a lo que se le irán aplicando las funciones descritas hacia arriba.


#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <iostream>
#endif
#include <stdlib.h>


using namespace std;
//La función que nos va estar dibujando
void Dibuja(){
    cerr << "Dibuja()\n";
    glClearColor(0,0,0,0);
    glClear(GL_COLOR_BUFFER_BIT);
    /*GL_PROJECTION permite */
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    glPushMatrix();//guarda la matriz
    glTranslatef(-0.8,0.8,0.0);
    glScalef(1.5,1.5,1.5);//permite esblecer  una escala
    glRotatef(45,0,1,1);
    glColor3f(0.0,1.0,0.0);
    //glutSolidSphere(0.2,15,15); //dibuja la esfera solida
    glutWireSphere(0.2,15,15);
    glPopMatrix();//la guarda y la restaura

    glPushMatrix();
    glTranslatef(0.8,0.8,0.0);
    glColor3f(1.0,1.0,0.0);
    glutWireSphere(0.2,15,15);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(0.8,-0.8,0.0);
    glColor3f(0.0,1.0,1.0);
    glutWireSphere(0.2,15,15);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(-0.8,-0.8,0.0);
    glColor3f(0.0,0.0,1.0);
    glutWireSphere(0.2,15,15);
    glPopMatrix();

    glFlush();
}

int main(){
    cerr <<"main() \n";
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
    glutInitWindowSize(550,550);
    glutCreateWindow("");
    glutDisplayFunc(Dibuja);
    glutMainLoop();
}


viernes, 28 de febrero de 2014

Figuras con alambres y solidas

En esta ocasión dibujaremos algunas figuras como conos, esferas, etc. como si estubieran hechas por alambres y una dónde la figura sea sólida, lo haremos mediante las funciones glutWireSphere, glutWireCone, glutWireTorus, glutSolidSphere. 



#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>
#include <iostream>
#endif

#include <stdlib.h>

using namespace std;
//La función que nos va estar dibujando
void Dibuja(){
    cerr << "Dibuja()\n";
    glClearColor(0,0,0,0);
    glClear(GL_COLOR_BUFFER_BIT);
    /*GL_PROJECTION permite mover el punto de referencia (0,0,0) a donde se le indique*/
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();

    glPushMatrix();//guarda el estado de la matriz, es decir guardará lo
                    //se dibuje hasta antes del PopMatrix
    glTranslatef(-0.5,0.5,0.0);//permite mover el punto de origen de nuestro espacio en (x,y,z)
    glScalef(1.2,1.2,1.2);//permite esblecer  una escala
    glRotatef(45,0,1,1);//permite rotar el angulo según el eje que define el vector (x,y,z)
    glColor3f(0.0,1.0,0.0);//se establece el color para la figura a dibujar
    //glutSolidSphere(0.2,15,15); //dibuja la esfera solida
    glutWireSphere(0.2,15,15);//permite dibujar una esfera definiendo (radio,rebanadas en x,rebanadas en y)
    glPopMatrix();//la guarda y la restaura

    glPushMatrix();
    glTranslatef(0.0,0.7,0.0);
    glRotatef(60,1,0,0);
    //glRotated(1,0,0,1);
    glColor3f(1.0,1.0,0.0);
    //glutSolidCone(1,1,slices,stacks);//dibuja un cono solido
    glutWireCone(0.2,0.5,22.0,5.0);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(0.59,0.5,0.0);
    glRotatef(63,1,0,0);
    glColor3f(0.0,1.0,1.0);
    //glutSolidTorus(0.2,0.8,slices,stacks);
    glutWireTorus(0.05,0.3,12.0,32.0);
    glPopMatrix();

    glPushMatrix();
    glTranslatef(-0.4,-0.4,0.0);
    glRotatef(55,9,22,0);
    glColor3f(0.2,0.3,0.5);
    //glutWireCone(1,1,slices,stacks);//dibuja un cono sin relleno
    glutWireCube(0.4);
    glPopMatrix();

    glPushMatrix();//guarda la matriz
    glTranslatef(0.4,-0.4,0.0);
    glScalef(1.2,1.2,1.2);//permite esblecer  una escala
    glRotatef(45,0,1,1);
    glColor3f(0.5,0.0,0.5);
    glutSolidSphere(0.2,40,22); //dibuja la esfera solida
    //glutWireSphere(0.2,15,15);
    glPopMatrix();//la guarda y la restaura

    glFlush();
}

int main(){
    cerr <<"main() \n";
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGBA);
    glutInitWindowSize(700,700);
    glutCreateWindow("");
    glutDisplayFunc(Dibuja);
    glutMainLoop();
}

lunes, 17 de febrero de 2014

Programas en CODE BLOCKS utilizando OpenGL

Este código es el que muestra el SW Code Blocks como de prueba para observar distintas funciones que se pueden realizar en OpenGL.



/*
 * 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.
 */
//librerias
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glut.h>
#endif
#include <stdlib.h>
//Variables globales
static int slices = 16;/*  */
static int stacks = 16;//

/* GLUT callback Handlers */

static void resize(int width, int height)
{
    const float ar = (float) width / (float) height;

    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION); //Activar la matriz de proyeccion
    glLoadIdentity();
    glFrustum(-ar, ar, -1.0, 1.0, 2.0, 100.0);//Definición del volumen de visualizacion
    //la matriz de transformacion debe entenderse como una pila
    glMatrixMode(GL_MODELVIEW);//activar matriz de trasformación
    glLoadIdentity() ;
}

static void display(void)
{
    const double t = glutGet(GLUT_ELAPSED_TIME) / 1000.0;
    const double a = t*90.0;

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glColor3d(1,0,0);

    //aplicar transformaciones a una pequeña parte de la geometria
    glPushMatrix();//se guarda el estado actual de la matriz
        //Funcion que nos traslada posiX unidades en el ejeX
        //posiY en el eje Y
        glTranslated(-2.4,1.2,-6);
        //Rotar el angulo segn el eje que define el vector(vx,vy,vz)
        glRotated(60,1,0,0);
        glRotated(a,0,0,1);
        //dibuja la esfera en los puntos que se desea
        glutSolidSphere(1,slices,stacks);//Dibuja la esfera solida
    glPopMatrix();//se recupera el estado actual de la matriz

    glPushMatrix();
        //Funcion que nos traslada posiX unidades en el ejeX
        //posiY en el eje Y
        glTranslated(0,1.2,-6);
        //Rotar el angulo segn el eje que define el vector(vx,vy,vz)
        glRotated(60,1,0,0);
        glRotated(a,0,0,1);
        glutSolidCone(1,1,slices,stacks);//dibuja un cono solido
    glPopMatrix();

    glPushMatrix();
        //Funcion que nos traslada posiX unidades en el ejeX
        //posiY en el eje Y
        glTranslated(2.4,1.2,-6);
        //Rotar el angulo segn el eje que define el vector(vx,vy,vz)
        glRotated(60,1,0,0);
        glRotated(a,0,0,1);
        glutSolidTorus(0.2,0.8,slices,stacks);
    glPopMatrix();

    glPushMatrix();
        //Funcion que nos traslada posiX unidades en el ejeX
        //posiY en el eje Y
        glTranslated(-2.4,-1.2,-6);
        //Rotar el angulo segn el eje que define el vector(vx,vy,vz)
        glRotated(60,1,0,0);
        glRotated(a,0,0,1);
        glutWireSphere(1,slices,stacks);//dibuja una esfera sin relleno
    glPopMatrix();

    glPushMatrix();
        //Funcion que nos traslada posiX unidades en el ejeX
        //posiY en el eje Y
        glTranslated(0,-1.2,-6);
        //Rotar el angulo segn el eje que define el vector(vx,vy,vz)
        glRotated(60,1,0,0);
        glRotated(a,0,0,1);
        glutWireCone(1,1,slices,stacks);//dibuja un cono sin relleno
    glPopMatrix();

    glPushMatrix();
        //Funcion que nos traslada posiX unidades en el ejeX
        //posiY en el eje Y
        glTranslated(2.4,-1.2,-6);
        //Rotar el angulo segn el eje que define el vector(vx,vy,vz)
        glRotated(60,1,0,0);
        glRotated(a,0,0,1);
        glutWireTorus(0.2,0.8,slices,stacks);//dibuja una dona sin relleno
    glPopMatrix();

    glutSwapBuffers();
}

//metodo que controla la animación del movimiento de las figuras
static void key(unsigned char key, int x, int y)
{
    switch (key)
    {
        case 27 :
        case 'q':
            exit(0);
            break;

        case '+':
            slices++;
            stacks++;
            break;

        case '-':
            if (slices>3 && stacks>3)
            {
                slices--;
                stacks--;
            }
            break;
    }

    glutPostRedisplay();
}

static void idle(void)
{
    glutPostRedisplay();
}

const GLfloat light_ambient[]  = { 0.0f, 0.0f, 0.0f, 1.0f };
const GLfloat light_diffuse[]  = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat light_specular[] = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat light_position[] = { 2.0f, 5.0f, 5.0f, 0.0f };

const GLfloat mat_ambient[]    = { 0.7f, 0.7f, 0.7f, 1.0f };
const GLfloat mat_diffuse[]    = { 0.8f, 0.8f, 0.8f, 1.0f };
const GLfloat mat_specular[]   = { 1.0f, 1.0f, 1.0f, 1.0f };
const GLfloat high_shininess[] = { 100.0f };

/* Program entry point */

int main(int argc, char *argv[])
{
    glutInit(&argc, argv);//recoger los parametros de la linea de comandos
    glutInitWindowSize(640,480);//define tamaño de la ventana ancho y alto
    //colocar la ventana en un punto determinador de la pantalla, origenx,origeny
    glutInitWindowPosition(10,10);
    //le dice al motor grafico que hay que renderizar, refrescar
    //o no la pantalla, que buffer hay que activar o desactivar y
    //la modalidad de colores que queremos usar
    glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);

    //crear la ventana con un titulo<-se pasa a un array de caracteres
    glutCreateWindow("GLUT Shapes");

    ////manda llamar el metodo a ejecutar
    glutReshapeFunc(resize);
    //el sistema le dice al subsistema grafico cal es la funcion que
    //que debe llamarse cada vez que se requiera dibujar de nuevo en pantalla
    glutDisplayFunc(display);
    glutKeyboardFunc(key);
    glutIdleFunc(idle);

    glClearColor(1,1,1,1);
    glEnable(GL_CULL_FACE);
    glCullFace(GL_BACK);

    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);


    glEnable(GL_LIGHT0);//activar o desactivar la luz 0
    glEnable(GL_NORMALIZE);//activa la normalizacion
    glEnable(GL_COLOR_MATERIAL);
    glEnable(GL_LIGHTING);//activar y desactivar todo el cálculo de iluminación

    //Colocar un foco en un lugar determinado
    //GL_LIGHT0, GL_LIGHT1, GL_LIGHT2
    //parametros RGBA rales, definien el porcentaje de intensidad
    //de cada color que tiene la luz.
    glLightfv(GL_LIGHT0, GL_AMBIENT,  light_ambient);
    glLightfv(GL_LIGHT0, GL_DIFFUSE,  light_diffuse);
    glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position);

    //
    glMaterialfv(GL_FRONT, GL_AMBIENT,   mat_ambient);
    //definimos que todas las caras principales
    //FRONT son las caras "que se ven" del poligono
    //los componentes dibujados ahora tendrán una componente difu
    glMaterialfv(GL_FRONT, GL_DIFFUSE,   mat_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR,  mat_specular);
    glMaterialfv(GL_FRONT, GL_SHININESS, high_shininess);

    //Es entrar al bucle infinito que domina cualquier aplicacion
    //OpenGL y con la sig. funcion se le dice a la libreria que
    //espere eternamenta que se produzcan "eventos"
    glutMainLoop();

    return EXIT_SUCCESS;
}



Este es el primer código que eh realizado, consiste en dibujar puntos en un plano 2D. Cabe destacar el uso de la primitiva GL_POINTS.



//librerias
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glut.h>
#endif
#include <stdlib.h>

/* GLUT callback Handlers */

static void display(void)
{

    //glClearColor(0,0,1,1);//color de pantalla
    glClear(GL_COLOR_BUFFER_BIT);//limpia la pantalla
    glPointSize(10);//Grosor del punto
    glColor3f(1,0.1,0.0);//color rojo (RGB) para los elementos dibujados dentro del glBegin()
    //GLBegin se utiliza para encapsular o escribir toda primitiva
    //GL_POINTS se utiliza para dibujar puntos individuales
    glBegin(GL_POINTS);
        //controla x
        for(double i=-1.0;i<1.0;i=i+0.1){
            //controla y
            for(double j=-1.0; j<1.0;j=j+0.1){
                glVertex2d(i,j);
            }
        }

    glEnd();//cierra glBegin()
    glFlush();//refuerzo de pintado
}

int main(int argc, char *argv[])
{
    glutInit(&argc, argv);//recoger los parametros de la linea de comandos
    //le dice al motor grafico que hay que renderizar, refrescar
    //o no la pantalla, que buffer hay que activar o desactivar y
    //la modalidad de colores que queremos usar
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(600,600);//establece el tamaño de la pantalla donde se mostrará nuestro dibujo o animacion
    glutInitWindowPosition(0,0);//establecen las coordenadas del lugar de la pantalla donde se quiere que aparezca la ventana
    glutCreateWindow("Dibuja Puntos");//Titulo de la Ventana
    glutDisplayFunc(display);//manda llamar el metodo a ejecutar
    //Es entrar al bucle infinito que domina cualquier aplicacion
    //OpenGL y con la sig. funcion se le dice a la libreria que
    //espere eternamenta que se produzcan "eventos"
    glutMainLoop();

}




Este segundo código muestra como dibujar una cuadricula en un plano 2D. Cabe resaltar ahora el uso de la primitiva GL_LINES_STRIP.


//librerias
#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glut.h>
#endif
#include <stdlib.h>

/* GLUT callback Handlers */

static void display(void)
{
    glClearColor(1.0,1.0,0.0,1.0);//color de pantalla
    glClear(GL_COLOR_BUFFER_BIT);//limpia la pantalla
    glLineWidth(7);//define el grosor de linea
    glColor3f(0.0,0.0,1.0);//color azul fuerte (RGB) para los elementos dibujados dentro del glBegin()
    //GLBegin se utiliza para encapsular o escribir toda primitiva
    //GL_LINE_STRIP permite trazar series de segmentos conectados
    glBegin(GL_LINE_STRIP);
        //primer for dibuja las lineas verticales
        //controla y
        double j=1.0;
        //controla x
        for(double i=-0.1;i<=1.0;i=i+0.1){
                glVertex2d(i,j);// dibuja un vertice en la coordenada (x,y)
                glVertex2d(i,-j);
                glVertex2d(-i,-j);
                glVertex2d(-i,j);
        }
        //segundo for dibuja las lineas horizontales
        //controla x
        double i=1.0;
            //controla y
            for(double j=-1.0;j<=1.0;j=j+0.1){
                glVertex2d(-i,j);// dibuja un vertice en la coordenada (x,y)
                glVertex2d(-i,-j);
                glVertex2d(i,-j);
                glVertex2d(-i,-j);
                //glColor3f(1.0,1.0,0.0);
                //glVertex2d(i,-j);

            }

    glEnd();//cierra glBegin()
    glFlush();//refuerzo de pintado

}

int main(int argc, char *argv[])
{
    glutInit(&argc, argv);//recoger los parametros de la linea de comandos
    //le dice al motor grafico que hay que renderizar, refrescar
    //o no la pantalla, que buffer hay que activar o desactivar y
    //la modalidad de colores que queremos usar
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(600,600);//establece el tamaño de la pantalla donde se mostrará nuestro dibujo o animacion
    glutInitWindowPosition(50,50);//establecen las coordenadas del lugar de la pantalla donde se quiere que aparezca la ventana
    glutCreateWindow("Dibuja Cuadricula");//Titulo de la Ventana
    glutDisplayFunc(display);//manda llamar el metodo a ejecutar
    //Es entrar al bucle infinito que domina cualquier aplicacion
    //OpenGL y con la sig. funcion se le dice a la libreria que
    //espere eternamenta que se produzcan "eventos"
    glutMainLoop();

}



Este tercer código muestra como dibujar un cuadrado con cuadrados dibujados sobre él. Cabe resaltar ahora el uso de la primitiva GL_QUADS.



#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glut.h>
#endif

#include <stdlib.h>

static void display(void)
{
    float a=1.0;
    //glClearColor(1.0,1.0,0.0,1.0);//color de pantalla
    glClear(GL_COLOR_BUFFER_BIT);//limpia la pantalla
    glPointSize(10);//Grosor del punto
    //GLBegin se utiliza para encapsular o escribir toda primitiva
    //GL_QUADS permite que cada cuadrupla de vertices determine un cuadrado
    glBegin(GL_QUADS);

    for(double i=1.0;i>=0.1;i=i-0.1){
        glColor3f(0.0,a,1.0);//color azul marino/cian(RGB) para los elementos dibujados dentro del glBegin()
        glVertex2d(-i,-i);
        glVertex2d(-i,i);
        glVertex2d(i,i);
        glVertex2d(i,-i);
        if(a==1.0){
            a=a-1;
        }else{
            a=a+1;
        }

    }
        /*Cuadrado
        glVertex2d(-0.1,-0.1);
        glVertex2d(-0.1,0.1);
        glVertex2d(0.1,0.1);
        glVertex2d(0.1,-0.1);*/

    glEnd();//cierra glBegin()
    glFlush();//refuerzo de pintado

}

int main(int argc, char *argv[])
{
    glutInit(&argc, argv);//recoger los parametros de la linea de comandos
    //le dice al motor grafico que hay que renderizar, refrescar
    //o no la pantalla, que buffer hay que activar o desactivar y
    //la modalidad de colores que queremos usar
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(600,600);//establece el tamaño de la pantalla donde se mostrará nuestro dibujo o animacion
    glutInitWindowPosition(0,0);//establecen las coordenadas del lugar de la pantalla donde se quiere que aparezca la ventana
    glutCreateWindow("Dibuja Cuadrado");//Titulo de la Ventana
    glutDisplayFunc(display);//manda llamar el metodo a ejecutar
    //Es entrar al bucle infinito que domina cualquier aplicacion
    //OpenGL y con la sig. funcion se le dice a la libreria que
    //espere eternamenta que se produzcan "eventos"
    glutMainLoop();

}



Este cuarto código muestra como dibujar un triangulo con triangulo dibujados sobre él. Cabe resaltar ahora el uso de la primitiva GL_TRIANGLES.



#ifdef __APPLE__
#include <GLUT/glut.h>
#else
#include <GL/gl.h>
#include <GL/glut.h>
#endif

#include <stdlib.h>

static void display(void)
{
    float a=1.0;
    //glClearColor(1.0,1.0,0.0,1.0);//color de pantalla
    glClear(GL_COLOR_BUFFER_BIT);//limpia la pantalla
    glPointSize(10);//Grosor del punto
    //GLBegin se utiliza para encapsular o escribir toda primitiva
    //GL_TRIANNGLES permite que cada terna de vertices determine un triangulo
    glBegin(GL_TRIANGLES);

    for(double i=1.0;i>=0.1;i=i-0.1){
        glColor3f(1.0,a,0.0);//color amarillo/rojo (RGB) para los elementos dibujados dentro del glBegin()
        glVertex2d(-i,-i);
        glVertex2d(0.0,i);
        glVertex2d(i,-i);
        if(a==1.0){
            a=a-1;
        }else{
            a=a+1;
        }

    }
        /*Triangulo
        glVertex2d(-0.1,-0.1);
        glVertex2d(0.0,0.1);
        glVertex2d(0.1,-0.1);*/


    glEnd();//cierra glBegin()
    glFlush();//refuerzo de pintado

}

int main(int argc, char *argv[])
{
    glutInit(&argc, argv);//recoger los parametros de la linea de comandos
    //le dice al motor grafico que hay que renderizar, refrescar
    //o no la pantalla, que buffer hay que activar o desactivar y
    //la modalidad de colores que queremos usar
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(600,600);//establece el tamaño de la pantalla donde se mostrará nuestro dibujo o animacion
    glutInitWindowPosition(0,0);//establecen las coordenadas del lugar de la pantalla donde se quiere que aparezca la ventana
    glutCreateWindow("Dibuja Cuadrado");//Titulo de la Ventana
    glutDisplayFunc(display);//manda llamar el metodo a ejecutar
    //Es entrar al bucle infinito que domina cualquier aplicacion
    //OpenGL y con la sig. funcion se le dice a la libreria que
    //espere eternamenta que se produzcan "eventos"
    glutMainLoop();
}