jueves, 29 de marzo de 2012

PISO PELOTA

PROGRAMA
#include <GL/glut.h>

GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;
GLfloat TrasEsferax= 3.0f;
GLfloat TrasEsferay= 0.0f;
GLfloat TrasEsferaz= -5.0f;

GLint ancho=400;
GLint alto=400;

int hazPerspectiva = 0;

void reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
   
    if(hazPerspectiva)
 gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);
    else
 glOrtho(-4,4, -4, 4, 1, 10);
    glMatrixMode(GL_MODELVIEW);

    ancho = width;
    alto = height;
}

void drawCube(void)
{
    glColor3f(0.0f, 0.0f, 0.5f);
    glBegin(GL_QUADS);       //cara abajo
    glVertex3f( 2.0f,-2.0f, -2.0f);
    glVertex3f( 2.0f,-2.0f,  2.0f);
    glVertex3f(-2.0f,-2.0f,  2.0f);
    glVertex3f(-2.0f,-2.0f, -2.0f);
    glEnd();
}
void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glLoadIdentity();

    glTranslatef(0.0f, 0.0f, -5.0f);

   glRotatef(5, 1.0f, 0.0f, 0.0f);
   glRotatef(5, 0.0f, 1.0f, 0.0f);
    drawCube();
    glLoadIdentity();
    glTranslatef(TrasEsferax,TrasEsferay,TrasEsferaz);
    //glRotatef(anguloEsfera, 0.0f, 1.0f, 0.0f);
    //glTranslatef(0.0f, 3.0f, 0.0f);
    glColor3f(0.0f, 1.0f, 0.0f);
    glutWireSphere(0.5f, 8, 8);
    glFlush();
    glutSwapBuffers();
 //   anguloCuboX+=0.1f;
   // anguloCuboY+=0.1f;
    //anguloEsfera+=0.2f;
}
void init()
{
    glClearColor(0,0,0,0);
    glEnable(GL_DEPTH_TEST);
    ancho = 400;
    alto = 400;
}
 
void idle()
{
    display();
}

void keyboard(unsigned char key, int x, int y)
{
    switch(key)
    {
    case 'p':
    case 'P':
 hazPerspectiva=1;
 reshape(ancho,alto);
 break;

    case 'o':
    case 'O':
 hazPerspectiva=0;
 reshape(ancho,alto);
 break;
 case 'a':
    case 'A':
    TrasEsferax-=1.0;
  break;
 case 'd':
    case 'D':
    TrasEsferax+=1.0;
  break;
 case 'w':
    case 'W':
    TrasEsferay+=1.0;
  break;
 case 's':
    case 'S':
    TrasEsferay-=1.0;
  break;
 case 'g':
    case 'G':
    TrasEsferaz+=0.5;
  break;
 
 case 'c':
    case 'C':
    TrasEsferaz-=0.5;
  break;

    case 27:   // escape
// exit(0);
      break;
    }
}

int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(ancho, alto);
    glutCreateWindow("Piso y pelota");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutIdleFunc(idle);
    glutKeyboardFunc(keyboard);
    glutMainLoop();
    return 0;
}
RESULTADOS





ACTIVIDAD 2 RESUMEN

OPENGL
·         Proyección: Trasforman una escena 3d “abstracta”, en una imagen plana que puede ser visualizada en una pantalla.
·         Viewport: Ajustan el producto de la proyección a las dimensiones de un rectángulo contenedor (ventana).
·   De vista: Que definen y afectan la posición desde la cual se visualizan las escenas tridimensionales.
·         Modelado: Sirven para manipular los objetos en la escena, permitiendo trasladarlos, rotarlos y deformarlos (escalarlos).
·         Modelo-Vista: Son la combinación de las dos transformaciones anteriores, que desde un punto de vista práctico son semejantes. 


 
  •  void glMatrixMode( enum mode ); Permite seleccionar la matriz sobre la cual se realizaran las operaciones, los posibles valores de mode son TEXTURE, MODELVIEW, COLOR o PROJECTION . Por ahora las más interesantes son MODELVIEW y PROJECTION, las otras se verán en su momento.
  • Void glLoadMatrix{fd} (T m[16]); Recibe una matriz de 4×4 que reemplaza la actual seleccionada. El arreglo es ordenado en forma de una matriz que tiene orden Y, a diferencia de las matrices convencionales que tienen orden X, lo que quiere decir que tiene la forma:     m = [a1 ,a2 ,a3 ,a4 ,a5 ,a6 ,a7 ,a8 ,a9 ,a10, a11, a12, a13, a14, a15, a16]
  • void glMultMatrix{fd}( T m[16] ); Multiplica la matriz actual por la matriz m[16] y reemplaza la matriz actual con el resultado de la operación. La operación resultante sería algo así como A’ = A M , donde A es la matriz actual, M es la matriz suministrada y A’ es la nueva matriz que resulta de la operación y que reemplaza a A.
  • void glLoadTransposeMatrix{fd}( T m[16] ); Realiza una función similar a LoadMatrix(
  • void glMultTransposeMatrix{fd}( T m[16] ); Misma funcionalidad que MultMatrix() , solo que actúa en base al la matriz en orden X, o sea la transpuesta.
  • void glLoadIdentity( void ); Remplaza la matriz actual por la matriz identidad de tamaño 4×4.
  • void glPushMatrix( void ); Coloca una copia de la matriz actual en la parte superior de la pila correspondiente.
  • void glPopMatrix( void ); Saca el elemento superior de la pila, que pasa a reemplazar a la matriz actual. 
TRANSFORMACIONES EN OPENGL
PROYECCIÓN
Como ya se ha visto en tutoriales anteriores, OpenGL maneja 2 tipos de proyección en perspectiva y ortográfica.
PRESPECTIVA.-  corresponde a la visión “realista” de la escena, mientras que la segunda es una “plana” que no deforma las dimensiones de los objetos dependiendo de su distancia a la cámara.
ORTOGRÁFICA: Para ajustar la proyección ortográfica se utiliza el siguiente grupo de funciones:
glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far);
Esta función permite controlar los parámetros del volumen de vista izquierdo, derecho, abajo, arriba, cerca y lejos. Hay que recordar que debido a que no se posee percepción de profundidad en este modo el valor del volumen deberá corresponder en la mayoría de los casos a un volumen suficientemente grande para contener los objetos de la escena.
gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top);
Esta función es simplemente una forma de la anterior, en donde se ha despreciado el valor de Z asignando los valores near = -1 y far = 1, generalmente se utiliza para escenas planas, en las que los objetos carecen de profundidad.
Perspectiva: Existen dos manera de manejar la proyección en perspectiva, a través de de una función gl o mediante la librería glu (una tercera puede ser realizar los cálculos de la matriz “manualmente”. En el primer caso:
glFrustrum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)
Esta función crea una matriz y la multiplica por la matriz de proyección actual.
Transformaciones ModelView
Una tarea muy común en la creación de gráficos 2d, 3d y videojuegos es la de mover objetos par crear cierta animación. La primera idea que se nos viene a la cabeza en el caso de OpeGL es que todo modelo está formado por primitivas, toda primitiva por puntos y finalmente todo punto por una tripleta de coordenadas XYZ, así que si se cambian las coordenadas todo de ahí hacia arriba se mueve.
Después de un tiempo tal vez se requieran realizar unas tareas un poco mas complicadas como rotar el objeto alrededor de su centro, o alrededor de la posición donde se encuentra con respecto al sistema coordenada. Esta tarea no es tan simple y requiere algo de conocimiento en matemático para hacerse, debido a que probablemente implique la implementación de un sistema para almacenar y operar matrices, implementación de coordenadas homogéneas, etc. OpenGL provee de estos sistemas y utiliza algunas simples funciones para su acceso, contando con tres operaciones básicas: mover, rotar y escalar un conjunto de vértices.
void glRotate[fd](GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
Realiza una rotación del espacio coordenado por una medida de (angle) tomados en grados a lo largo del vector determinado por (x,y,z). Es recomendable que (x,y,z) representen un vector normalizado (o sea magnitud(x,y,z) = 1), debido a que si no es así OpenGL intentará normalizarlo. La rotación se lleva siguiendo la regla de la mano derecha, teniendo en cuenta que el vector (x,y,z) apunta con el “pulgar” hacia adentro (hacia uno).
void glTranslate[fd](GLfloat x, GLfloat y, GLfloat z);
Esta función traslada el espacio coordenado en x, y, z unidades sobre sus respectivos ejes coordenados X, Y, Z.
void glScalef(GLfloat x, GLfloat y, GLfloat z);
Cambia la proporción de los objetos respecto a los ejes coordenados, lo que es equivalente a decir que los estira o encoge una cantidad determinada por los parámetros de la función x,y,z.



COORDENADAS OCULARES
Las coordenadas oculares se sitúan en el punto de vista del observador, sin importar las transformaciones que tengan lugar.

TRANSFORMACIONES
Las transformaciones son las que hacen posible la proyección de coordenadas 3D sobre superficies 2D. También son las encargadas de mover, rotar y escalar objetos.

TRANSFORMACIONES DEL OBSERVADOR
La transformación del observador es la primera que se aplica a la escena, y se usa para determinar el punto más ventajoso de la escena.
TRANSFORMACIONES DEL MODELO
Estas transformaciones se usan para situar, rotar y escalar los objetos de la escena.
TRANSFORMACIONES DE LA PROYECCIÓN
 La transformación de proyección se aplica a la orientación final del modelador. Esta proyección define el volumen de visualización y establece los planos de trabajo.
TRANSFORMACIONES DE LA VISTA
 En el momento en que se ha terminado todo el proceso de transformaciones, solo queda un último paso: proyectar lo que hemos dibujado en 3D al 2D de la pantalla, en la ventana en la que estamos trabajando. Esta es la denominada transformación de la vista.
 MATRICES
 Las matemáticas que hay tras estas transformaciones se simplifican gracias a las matrices. Cada una de las transformaciones de las que se acaba de hablar puede conseguirse multiplicando una matriz que contenga los vértices por una matriz que describa la transformación.
LA MATRIZ DE PROYECCIÓN 
La matriz de proyección especifica el tamaño y la forma del volumen de visualización. El volumen de visualización es aquel cuyo contenido es el que se representa en pantalla.
PROYECCIONES ORTOGRÁFICAS
Una proyección ortográfica es cuadrada en todas sus caras. Esto produce una proyección paralela, útil para aplicaciones de tipo CAD o dibujos arquitectónicos, o también para tomar medidas, ya que las dimensiones de lo que representan no se ven alteradas por la proyección.
PROYECCIÓN ORTOGONAL
Una proyección ortogonal define un volumen de la vista de tipo paralelepipédico
PROYECCIONES PERSPECTIVAS
Una proyección en perspectiva reduce y estirar los objetos más alejados del observador.

programas

lunes, 26 de marzo de 2012

UNIDAD III DIBUJOS Y TRANSFORMACIONES GEOMETRICAS

CODIGO DE ESCALACION, ROTACION Y TRASLACION EN UNO SOLO

#include <GL/glut.h>

GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;

GLint ancho=400;
GLint alto=400;

int hazPerspectiva = 0;

void reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
   
    if(hazPerspectiva)
 gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);
    else
 glOrtho(-4,4, -4, 4, 1, 10);
    glMatrixMode(GL_MODELVIEW);

    ancho = width;
    alto = height;
}

void drawCube(void)
{
    glColor3f(1.0f, 0.0f, 0.5f);
    glBegin(GL_QUADS);       //cara frontal
    glVertex3f(-0.5f, -0.5f,  0.5f);
    glVertex3f( 0.5f, -0.5f,  0.5f);
    glVertex3f( 0.5f,  0.5f,  0.5f);
    glVertex3f(-0.5f,  0.5f,  0.5f);
    glEnd();
    glColor3f(0.0f, 1.0f, 1.0f);
    glBegin(GL_QUADS);       //cara trasera
    glVertex3f( 0.5f, -0.5f, -0.5f);
    glVertex3f(-0.5f, -0.5f, -0.5f);
    glVertex3f(-0.5f,  0.5f, -0.5f);
    glVertex3f( 0.5f,  0.5f, -0.5f);
    glEnd();
    glColor3f(0.0f, 0.0f, 1.0f);
    glBegin(GL_QUADS);       //cara lateral izq
    glVertex3f(-0.5f,-0.5f, -0.5f);
    glVertex3f(-0.5f,-0.5f,  0.5f);
    glVertex3f(-0.5f, 0.5f,  0.5f);
    glVertex3f(-0.5f, 0.5f, -0.5f);
    glEnd();
    glColor3f(1.0f, 1.0f, 0.0f);
    glBegin(GL_QUADS);       //cara lateral dcha
    glVertex3f(0.5f, -0.5f,  0.5f);
    glVertex3f(0.5f, -0.5f, -0.5f);
    glVertex3f(0.5f,  0.5f, -0.5f);
    glVertex3f(0.5f,  0.5f,  0.5f);
    glEnd();
    glColor3f(0.0f,      1.0f, 0.0f);
    glBegin(GL_QUADS);       //cara arriba
    glVertex3f(-0.5f, 0.5f,  0.5f);
    glVertex3f( 0.5f, 0.5f,  0.5f);
    glVertex3f( 0.5f, 0.5f, -0.5f);
    glVertex3f(-0.5f, 0.5f, -0.5f);
    glEnd();

    glColor3f(1.0f, 0.0f, 0.0f);
    glBegin(GL_QUADS);       //cara abajo
    glVertex3f( 0.5f,-0.5f, -0.5f);
    glVertex3f( 0.5f,-0.5f,  0.5f);
    glVertex3f(-0.5f,-0.5f,  0.5f);
    glVertex3f(-0.5f,-0.5f, -0.5f);
    glEnd();
}
void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glLoadIdentity();

    glTranslatef(3.0f, 0.0f, -5.0f);

    glRotatef(anguloCuboX, 1.0f, 0.0f, 0.0f);
    glRotatef(anguloCuboY, 0.0f, 1.0f, 0.0f);

    drawCube();

    glLoadIdentity();

    glTranslatef(0.0f, 0.0f, -5.0f);
    glRotatef(anguloEsfera, 0.0f, 1.0f, 0.0f);
    glTranslatef(0.0f, 3.0f, 0.0f);

    glColor3f(1.0f, 1.0f, 1.0f);
    glutWireSphere(0.5f, 8, 8);

    glFlush();
    glutSwapBuffers();

    anguloCuboX+=0.1f;
    anguloCuboY+=0.1f;
    anguloEsfera+=0.2f;
}
void init()
{
    glClearColor(0,0,0,0);
    glEnable(GL_DEPTH_TEST);
    ancho = 400;
    alto = 400;
}
 
void idle()
{
    display();
}
void keyboard(unsigned char key, int x, int y)
{
    switch(key)
    {
    case 'p':
    case 'P':
 hazPerspectiva=1;
 reshape(ancho,alto);
 break;

    case 'o':
    case 'O':
 hazPerspectiva=0;
 reshape(ancho,alto);
 break;

    case 27:   // escape
// exit(0);
      break;
    }
}

int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(ancho, alto);
    glutCreateWindow("Cubo 1");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutIdleFunc(idle);
    glutKeyboardFunc(keyboard);
    glutMainLoop();
    return 0;
}
RESULTADOS DE LA ROTACION TRASLACION Y ESCALACION

El cubo se roto 3 unidades en x, se escalo a la mitad y la esfera roto en su propio eje

jueves, 22 de marzo de 2012

PELOTA

CODIGO
    // JULIAN ARMANDO AGUILAR JUAREZ
    //  PROYECTO PELOTA

    #include <GL/glut.h>
    #include <GL/gl.h>
    #include <GL/glu.h>
    #include <math.h>
    #include <stdio.h>
    #include <string.h>
    #define WIDTH 620
    #define HEIGHT 450
  
  
    void reshape(int width, int height){
    glViewport(0,0,width,height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-WIDTH/2,WIDTH/2-1,-HEIGHT/2,HEIGHT/2-1,-1,1);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    }  
    void init(void){
    glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glPointSize(2.0);
    }
  
    void Timer(int ex)
    {
  
    glutPostRedisplay();
    glutTimerFunc(30,Timer,0);
    }
   int j=20;
    void circle(int p,int m)
    {
    int x=0,y,g,t;
    t=m;
    y=t;
    g=3-2*t;
    while(x<=y)
    {
    glVertex2i(x,y+p);
    glVertex2i(y,x+p);
    glVertex2i(-x,y+p);
    glVertex2i(-y,x+p);
    glVertex2i(-x,-y+p);
    glVertex2i(-y,-x+p);
    glVertex2i(y,-x+p);
glVertex2i(x,-y+p);
    if(g<0)
    g=g+4*x+6;
    else
    {
    g=g+4*(x-y)+10;
    y--;
    }
    x++;
    }
    }
  
int t=100,flag=0;
  
    void display(void)
    {
  
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glColor3f(0.0,0.0,1.0);
    glBegin(GL_POINTS);
  
  circle(j,t);
  
    if(flag==0)
    {
    if((j+t)<=200)
    {
    j=j+10;
  
    }
  
    if((j+t)>=200){
    flag=1;
  
    }
    }
  
    if(flag==1)
    {
    j=j-10;
  
    if((j-t)<=-220)
    {
flag=0;
    }
    }
  
    glEnd();
    glutSwapBuffers();
    }
  
void idle(void){
    /* do nothing */
}
  
    int main(int argc, char **argv){
    glutInit(&argc,argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
 glutInitWindowPosition(0,0);
    glutInitWindowSize(WIDTH,HEIGHT);
 glutCreateWindow(argv[0]);
 init();
 glutIdleFunc(idle);
    glutReshapeFunc(reshape);
    glutDisplayFunc(display);
    glutTimerFunc(0,Timer,0);
    glutMainLoop();
    return(1);
 }
RESULTADO



miércoles, 14 de marzo de 2012

CUBO 3D

CODIGO

//// Julian Armando Aguilar Juarez
/// Cubo 3D
#include <GL/glut.h>
void myinit(void)
{


      glClearColor(1.0, 1.0, 1.0, 1.0);
      glEnable(GL_DEPTH_TEST);
      glMatrixMode(GL_PROJECTION);
      glLoadIdentity();
      glOrtho(0.0, 500.0, 0.0, 500.0,0.1,400.00);
      glMatrixMode(GL_MODELVIEW);
   glRotatef(30,0,1,0);
}

void display( void )
{
    typedef GLfloat point3[3];   
    point3 vertices[8]={{100.0,100.0,0.0},{200.0,100.0,0.0},{200.0,200.0,0.0},{100.0,200.0,0.0},{100.0,100.0,-100.00},{200.0,100,-100.00},{200.0,200.0,-100.00},{100.0,200.0,-100.00}};
 
glClearColor(1.0, 1.0, 1.0, 0.0);
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
        glTranslatef(200,100,-100);
  glRotatef(10,1,1,1);
        glBegin(GL_QUADS);
 
  glColor3f(1.0,1.0,0.0);
glVertex3fv(vertices[0]);
glVertex3fv(vertices[1]);
glVertex3fv(vertices[2]);
glVertex3fv(vertices[3]);
 glColor3f(1.0,0.0,0.0);
glVertex3fv(vertices[2]);
glVertex3fv(vertices[3]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[7]);
  glColor3f(0.0,1.0,0.0);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[5]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[7]);
  glColor3f(1.0,0.0,1.0);
  glVertex3fv(vertices[0]);
glVertex3fv(vertices[1]);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[5]);
  
  glColor3f(0.0,.0.0,0.4);
 glVertex3fv(vertices[0]);
glVertex3fv(vertices[3]);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[7]);
   glColor3f(1.0,0.0,0.0);
glVertex3fv(vertices[2]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[1]);
glVertex3fv(vertices[5]);


  glEnd();
glutSwapBuffers();
     glFlush();
 }

void main(int argc, char** argv)
{
    glutInit(&argc,argv);
    glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
    glutInitWindowSize(500,500);
    glutInitWindowPosition(0,0);
    glutCreateWindow("Sierpinski Gasket");
    glutDisplayFunc(display);

    myinit();
    glutMainLoop();
}

RESULTADO

martes, 13 de marzo de 2012

INVESTIGACION

PROYECCION ORTOGONAL.
El tipo de proyección que hemos utilizado hasta ahora es una proyección ortogonal. Una proyección ortogonal define un volumen de la vista de tipo paralelepipédico tal y como se muestra en la siguiente figura. La principal característica de esta proyección es que el tamaño de los objetos es independiente de la distancia a la que estén del observador, por ejemplo, dos cilindros del mismo tamaño, uno a cinco unidades y el otro a diez unidades de distancia del observador se proyectarán con el mismo tamaño


Para definir una proyección ortogonal en OpenGL hay que dar los siguiente pasos:

glMatrix(GL_PROJECTION); /* Voy a manejar la matriz de proyección */
glLoadIdentity(); /* Cargo inicialmente la identidad */
/* Y ahora defino la proyección ortogonal */

void glOrtho(izquierda, derecha, abajo, arriba, cerca, lejos);
Si lo que deseamos es trabajar con una proyección ortogonal 2D:

void gluOrtho2D(izquierda, derecha, abajo, arriba);

que no es más que una proyección ortogonal donde el plan delantero está en -1 y el trasero en 1.

PROYECCIÓN PERSPECTIVA.
La proyección ortogonal no da sensación de profundidad porque el tamaño de los objetos no depende de su distancia al observador. Para conseguir este efecto necesitamos definir una proyección perspectiva. Esta proyección define un volumen de la vista que es una prisma truncado de base rectangular, como el de la siguiente figura



La función OpenGL que establece este tipo de perspectiva es:



void glFrustum(izquierda, derecha, abajo, arriba, cerca, lejos);




este modo de definir la proyección perspectiva no es demasiado intuitivo, es más sencillo establecerla con un esquema como el que se muestra en la siguiente figura:

y la función OpenGL que la establece es:



void gluPerspective(fovy, aspecto, cerca, lejos);




donde fovy es el ángulo de apertura del objetivo de la cámara, en grados, y aspecto es la relación ancho/alto de la base de la pirámide.



EJEMPLOS DE TRASLACION, ROTACION Y ESCALACION OPENGL
En esteprograma se puede realizar las tres funciones de traslacion, rotacion y escalacion.

RESUMEN

OPERACIONES CON MATRICES: DIBUJANDO EL CAMINO
La transformación de las coordenadas se realiza internamente en OpenGL a partir de las matrices de transformación y de las coordenadas de modelado del objeto. Sin embargo, para representar el rastro que dibuja la tortuga al desplazarse, se realizará explícitamente la transformación de la coordenada en la que se encuentra la tortuga. De esta forma se actúa directamente en la matriz de transformación.

LA PILA DE MATRICES
En la función display() se encuentran las llamadas a dos funciones de matrices que todavía no han sido comentadas. Se trata de glPushMatrix() y glPopMatrix(). Para comprender su funcionamiento, primero se va a experimentar que es lo que ocurre cuando no están dichas llamadas. Para ello se comentan en la función display() ambas llamadas:
void display(void) {
...
// glPushMatrix();
...
glTranslatef(0.0, 0.0, .5);
...
// glPopMatrix();
glutSwapBuffers();
}
La razón de este movimiento es que en la función display está incluida una llamada a glTranslatef() que se utiliza para posicionar uno de los objetos. Como se ha explicado anteriormente, las funciones de traslación multiplican la matriz actual por una matriz de traslación creada con los argumentos que se le pasan, por tanto, sucesivas llamadas a la función display() provocan sucesivas multiplicaciones de la matriz actual con el efecto que se observa de incrementar la traslación.
Para solucionar este problema OpenGL dispone de unos stacks o pilas de matrices, que permiten almacenar y recuperar una matriz anterior. Aunque OpenGL dispone de pilas para las matrices GL_MODELVIEW y GL_PROJECTION, sólo se suele utilizar la pila de GL_MODELVIEW.
Una pila es un almacén con funcionamiento LIFO, el último en entrar es el primero en salir, por lo que suele comparar a una pila de platos en la que sólo se puede dejar uno encima de la pila o coger el superior que es el último depositado. La pila de matrices tiene el mismo funcionamiento sustituyendo los platos por matrices. La matriz superior de la pila es sobre la que se aplican las distintas transformaciones, multiplicándola por la matriz que generan las distintas funciones.
La función glPushMatrix() realiza una copia de la matriz superior y la pone encima de la pila, de tal forma que las dos matrices superiores son iguales. En la figura 1 se observa la pila en la situación inicial con una sola matriz, al llamar a la función glPushMatrix() se duplica la matriz superior. Las siguientes transformaciones que se realizan se aplican sólo a la matriz superior de la pila, quedando la anterior con los valores que tenía en el momento de llamar a la función glPushMatrix().
La función glPopMatrix() elimina la matriz superior, quedando en la parte superior de la pila la matriz que estaba en el momento de llamar a la función glPushMatrix().

DIBUJANDO UN RASTRO
Una característica de Logo es que la tortuga al avanzar va dibujando el camino por el que ha pasado. Hasta ahora la aplicación va transformando las coordenadas del objeto para situarlo en la nueva posición según las instrucciones introducidas pero no muestra la ruta seguida.
Para mostrar la ruta es necesario almacenar los puntos por los que pasa la tortuga. El rastro consistirá en una línea que una estos puntos.
Necesitaremos realizar tres operaciones: calcular la coordendas donde se encuentra la tortuga, almacenar dicha coordenada y dibujar el rastro.
Para almacenar los puntos se utiliza una variable para indicar el número de puntos y tres vectores para las coordenadas x, y, z.
int np = 0;
float px [10000];
float py [10000];
float pz [10000];
Para calcular las coordenadas de la tortuga es necesario conocer la matriz de transformación de modelado. Debido a que en OpenGL, la matriz de modelado se almacena junto con la de visualización en la matriz GL_MODELVIEW, es necesario guardar de modo independiente esta matriz de modelado. Para ello definimos la variable mModel, como una variable global, ya que va a ser accedida en distinos puntos de la aplicación: GLdouble mModel[16]
Para operar con la matriz mModel, se cargará en la pila de matrices de GL_MODELVIEW despues de realizar un PushMatrix(), de modo que no altere la matriz actual. En la función main() se inicializa esta matriz con el código:
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glGetDoublev (GL_MODELVIEW_MATRIX, mModel);
glPopMatrix();

MOSTRAR TEXTO
Las instrucciones introducidas se muestran en la ventana MSDOS. Se pueden mostrar en la ventana gráfica. Para ello es necesario cambiar las matrices de transformación. La siguiente función realiza la representación del texto:
void text(GLuint x, GLuint y, GLfloat scale, char* format, ...) {
va_list args;
char buffer[255], *p;
GLfloat font_scale = 119.05f + 33.33f;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0,
glutGet(GLUT_WINDOW_HEIGHT));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glTranslatef(x, y, 0.0);
glScalef(scale/font_scale, scale/font_scale, scale/font_scale);
for(p = buffer; *p; p++)
glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
                             
PUNTOS A REALIZAR
Utilizando los comandos de logo representar una esfera compuesta por un conjunto de circunferencias en el espacio.
Utilizando los comandos de logo realizar la representación de una helicoidal.


VIEWPORT
Aplicaciones
·         Tener varias áreas de dibujo y proyección en una ventana
·         Mantener la proporción del aspecto

SINTAXIS
glViewport(Xminimo, Yminimo,Anco,Alto)


CODIGO
#include <GL/glut.h>

GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;

GLint ancho=400;
GLint alto=400;

int hazPerspectiva = 0;

void reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
   
    if(hazPerspectiva)
 gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);
    else

 glOrtho(-4,4, -4, 4, 1, 10);
    glMatrixMode(GL_MODELVIEW);

    ancho = width;
    alto = height;
}

void drawCube(void)
{
    glColor3f(1.0f, 0.0f, 0.0f);
    glBegin(GL_QUADS);       //cara frontal
    glVertex3f(-1.0f, -1.0f,  1.0f);
    glVertex3f( 1.0f, -1.0f,  1.0f);
    glVertex3f( 1.0f,  1.0f,  1.0f);
    glVertex3f(-1.0f,  1.0f,  1.0f);

    glEnd();
    glColor3f(0.0f, 1.0f, 0.0f);
    glBegin(GL_QUADS);       //cara trasera
    glVertex3f( 1.0f, -1.0f, -1.0f);
    glVertex3f(-1.0f, -1.0f, -1.0f);
    glVertex3f(-1.0f,  1.0f, -1.0f);
    glVertex3f( 1.0f,  1.0f, -1.0f);

    glEnd();
    glColor3f(0.0f, 0.0f, 1.0f);
    glBegin(GL_QUADS);       //cara lateral izq
    glVertex3f(-1.0f,-1.0f, -1.0f);
    glVertex3f(-1.0f,-1.0f,  1.0f);
    glVertex3f(-1.0f, 1.0f,  1.0f);
    glVertex3f(-1.0f, 1.0f, -1.0f);
    glEnd();

    glColor3f(1.0f, 1.0f, 0.0f);
    glBegin(GL_QUADS);       //cara lateral dcha
    glVertex3f(1.0f, -1.0f,  1.0f);
    glVertex3f(1.0f, -1.0f, -1.0f);
    glVertex3f(1.0f,  1.0f, -1.0f);
    glVertex3f(1.0f,  1.0f,  1.0f);
    glEnd();
    glColor3f(0.0f,      1.0f, 1.0f);
    glBegin(GL_QUADS);       //cara arriba
    glVertex3f(-1.0f, 1.0f,  1.0f);
    glVertex3f( 1.0f, 1.0f,  1.0f);
    glVertex3f( 1.0f, 1.0f, -1.0f);
    glVertex3f(-1.0f, 1.0f, -1.0f);
    glEnd();

    glColor3f(1.0f, 0.0f, 1.0f);
    glBegin(GL_QUADS);       //cara abajo
    glVertex3f( 1.0f,-1.0f, -1.0f);
    glVertex3f( 1.0f,-1.0f,  1.0f);
    glVertex3f(-1.0f,-1.0f,  1.0f);
    glVertex3f(-1.0f,-1.0f, -1.0f);
    glEnd();
}

void display()
{
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glLoadIdentity();

    glTranslatef(0.0f, 0.0f, -5.0f);

    glRotatef(anguloCuboX, 1.0f, 0.0f, 0.0f);
    glRotatef(anguloCuboY, 0.0f, 1.0f, 0.0f);

    drawCube();

    glLoadIdentity();

    glTranslatef(0.0f, 0.0f, -5.0f);
    glRotatef(anguloEsfera, 0.0f, 1.0f, 0.0f);
    glTranslatef(3.0f, 0.0f, 0.0f);

    glColor3f(1.0f, 1.0f, 1.0f);
    glutWireSphere(0.5f, 8, 8);

    glFlush();
    glutSwapBuffers();

    anguloCuboX+=0.1f;
    anguloCuboY+=0.1f;
    anguloEsfera+=0.2f;
}

void init()
{
    glClearColor(0,0,0,0);
    glEnable(GL_DEPTH_TEST);
    ancho = 400;
    alto = 400;
}
 

void idle()
{
    display();
}

void keyboard(unsigned char key, int x, int y)
{
    switch(key)
    {
    case 'p':
    case 'P':
 hazPerspectiva=1;
 reshape(ancho,alto);
 break;

    case 'o':
    case 'O':
 hazPerspectiva=0;
 reshape(ancho,alto);
 break;

    case 27:   // escape
 //exit(0);
      break;
    }
}

int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
    glutInitWindowPosition(100, 100);
    glutInitWindowSize(ancho, alto);
    glutCreateWindow("Cubo 1");
    init();
    glutDisplayFunc(display);
    glutReshapeFunc(reshape);
    glutIdleFunc(idle);
    glutKeyboardFunc(keyboard);
    glutMainLoop();
    return 0;
}


RESULTADO

jueves, 8 de marzo de 2012

CUBO 3D (QUADS)

// JULIAN ARMANDO AGUILAR JUAREZ 01/03/12
// CUBO EN 3D HECHO CON CUADROS NO CON LINEAS
#include <GL/glut.h>
#include <stdlib.h>
void myinit(void)
{
glClearColor(0.0, 1.0, 0.0, 1.0);
glColor3f(0.0, 0.0, 1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 600.0, 0.0, 600.0);
glMatrixMode(GL_MODELVIEW);
}
void display( void )
{
typedef GLfloat point2[3];
point2 vertices[8]={{100.0,100.0,0},{200.0,100.0,0},{200.0,200.0,0},{100.0,200.0,0},{100.0,100.0,-100.0},{200.0,100.0,-100.0},{200.0,200.0,-100.0},{100.0,200.0,-100.0}};
glClearColor(1.0, 1.0, 1.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_QUADS);

glColor3f(0.0, 0.0, 1.0);
glVertex3fv(vertices[0]);
glVertex3fv(vertices[1]);
glVertex3fv(vertices[2]);
glVertex3fv(vertices[3]);

glColor3f(0.0, 1.0, 1.0);
glVertex3fv(vertices[2]);
glVertex3fv(vertices[3]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[7]);

glColor3f(1.0, 0.0, 1.0);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[5]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[7]);

glColor3f(1.0, 0.0, 0.0);
glVertex3fv(vertices[0]);
glVertex3fv(vertices[1]);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[5]);

glColor3f(0.0, 1.0, 0.0);
glVertex3fv(vertices[0]);
glVertex3fv(vertices[3]);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[7]);

glColor3f(1.0, 1.0, 1.0);
glVertex3fv(vertices[2]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[1]);
glVertex3fv(vertices[5]);

glEnd();
glFlush();
}
void main(int argc, char** argv)
{
glutInit(&argc,argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(600,600);
glutInitWindowPosition(0,0);
glutCreateWindow("Cubo en 3 Dimensiones <60");
glutDisplayFunc(display);
myinit();
glutMainLoop(); }



domingo, 4 de marzo de 2012

CUBO 3D (VISTA FRONTAL)

CODIGO
// JULIAN ARMANDO AGUILAR JUAREZ 01/03/12
// CUBO EN 3D CON LA VISTA FRONTAL
#include <GL/glut.h>
#include <stdlib.h>
void myinit(void)
{

glClearColor(0.0, 1.0, 0.0, 1.0);
glColor3f(0.0, 0.0, 1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 400.0, 0.0, 400.0);
glMatrixMode(GL_MODELVIEW);
}

void display( void )
{
typedef GLfloat point2[3];
point2 vertices[8]={{100.0,100.0,0},{200.0,100.0,0},{200.0,200.0,0},{100.0,200.0,0},{100.0,100.0,-100.0},{200.0,100.0,-100.0},{200.0,200.0,-100.0},{100.0,200.0,-100.0}};
glClearColor(1.0, 1.0, 1.0, 0.0);

glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_LINES);
glVertex2fv(vertices[0]);
glVertex2fv(vertices[1]);
glVertex2fv(vertices[0]);
glVertex2fv(vertices[3]);
glVertex2fv(vertices[1]);
glVertex2fv(vertices[2]);
glVertex2fv(vertices[2]);
glVertex2fv(vertices[3]);
glVertex2fv(vertices[4]);
glVertex2fv(vertices[5]);
glVertex2fv(vertices[5]);
glVertex2fv(vertices[6]);
glVertex2fv(vertices[6]);
glVertex2fv(vertices[7]);
glVertex2fv(vertices[4]);
glVertex2fv(vertices[7]);
glVertex2fv(vertices[3]);
glVertex2fv(vertices[7]);
glVertex2fv(vertices[2]);
glVertex2fv(vertices[6]);
glVertex2fv(vertices[0]);
glVertex2fv(vertices[4]);
glVertex2fv(vertices[1]);
glVertex2fv(vertices[5]);
glEnd();
glFlush();
}
void main(int argc, char** argv)
{

glutInit(&argc,argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize(600,600);
glutInitWindowPosition(0,0);
glutCreateWindow("Cubo en 3 Dimensiones <60");
glutDisplayFunc(display);
myinit();
glutMainLoop(); }

RESULTADO

jueves, 1 de marzo de 2012

Resumen: Proyeccion Ortogonal y en Prespectiva

COORDENADAS OCULARES
Las coordenadas oculares se sitúan en el punto de vista del observador, sin importar las transformaciones que tengan lugar.


TRANSFORMACIONES
Las transformaciones son las que hacen posible la proyección de coordenadas 3D sobre superficies 2D. También son las encargadas de mover, rotar y escalar objetos.

TRANSFORMACIONES DEL OBSERVADOR
La transformación del observador es la primera que se aplica a la escena, y se usa para determinar el punto más ventajoso de la escena.

Estas transformaciones se usan para situar, rotar y escalar los objetos de la escena.

 La transformación de proyección se aplica a la orientación final del modelador. Esta proyección define el volumen de visualización y establece los planos de trabajo.

 En el momento en que se ha terminado todo el proceso de transformaciones, solo queda un último paso: proyectar lo que hemos dibujado en 3D al 2D de la pantalla, en la ventana en la que estamos trabajando. Esta es la denominada transformación de la vista.

 Las matemáticas que hay tras estas transformaciones se simplifican gracias a las matrices. Cada una de las transformaciones de las que se acaba de hablar puede conseguirse multiplicando una matriz que contenga los vértices por una matriz que describa la transformación.

La matriz de proyección especifica el tamaño y la forma del volumen de visualización. El volumen de visualización es aquel cuyo contenido es el que se representa en pantalla.

Una proyección ortográfica es cuadrada en todas sus caras. Esto produce una proyección paralela, útil para aplicaciones de tipo CAD o dibujos arquitectónicos, o también para tomar medidas, ya que las dimensiones de lo que representan no se ven alteradas por la proyección.

Una proyección ortogonal define un volumen de la vista de tipo paralelepipédico

PROYECCIONES PERSPECTIVAS
Una proyección en perspectiva reduce y estirar los objetos más alejados del observador.
Para especificar una cámara virtual con perspectiva se necesita los siguientes parámetros:


El concepto es parecido a la proyeccion ortogonal de la entrega anterior pero los puntos de la escena se proyectan sobre el plano de proyeccion (la pantalla) siguiendo una linea que pasa por un punto detras de este plano, el punto de vista (donde estamos situados para ver la escena).


TRANSFORMACIÓN A COORDENADAS DEL VIEWPORT.

El último paso que debemos dar es definir el tamaño de la ventana a través del cual nos asomamos al mundo 3D. La analogía con la cámara de fotos es positivar un negativo a un determinado tamaño de fotografía.

La función OpenGL que establece el tamaño del vierport es:

void glViewport(GLint x, GLint y, GLsizei ancho, GLsizei alto);


PREGUNTAS
 
1.   ¿PUEDE DIFERENCIAR ENTRE LOS DOS TIPOS DE PROYECCIÓN?
Si son las ortogonales y las que están en perspectiva. Las dos se parecen en mucho solo que la que está en perspectiva realiza una ilusión óptica (por decir) dependiendo de cómo se observe la figura se puede alargar o reducir.
2.   ENTIENDE PARA QUE SE USAN LAS MATRICES Y COMO LAS MANEJA OPENGL? EXPLIQUELO.
Las matrices no me quedo muy claro pero si entiendo poco ese tema lo que no logre entender bien fue como las maneja opengl
3.   QUE ES LA MATRIZ IDENTIDAD Y PARA QUE SE UTILIZA EN OPENGL?

4.   HAGA  OTRO PROGRAMA CON EL CUBO PERO CON PROYECCIÓN  EN PERSPECTIVA
5.   EXPLIQUE LAS DIFERENCIAS.