jueves, 29 de marzo de 2012

Carrito 2D

#include <GL/glut.h>
float posicion;
int grados;
void reshape(int width, int height){
  glViewport(0, 0, width, height);
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  glOrtho(-5, 5, -5, 5, 0.1f, 20);
  glTranslatef(-3.5f, -2.0f, -15.0f);
  glMatrixMode(GL_MODELVIEW);
}

void dibujar_tornillos(){
  glPushMatrix();
   glColor3f(0.0f,0.0f,0.0f); 
   glTranslatef(0.0f,0.0f, 1.0f);
   glPushMatrix();
    glTranslatef(-0.5f,0.0f, 0.0f);
    glutSolidSphere(0.1f,20,20);
   glPopMatrix();
   glPushMatrix();
    glTranslatef(0.5f,0.0f, 0.0f);
    glutSolidSphere(0.1f,20,20);
   glPopMatrix();
   glPushMatrix();
    glTranslatef(0.0f,0.4f, 0.0f);
    glutSolidSphere(0.1f,20,20);
   glPopMatrix();
   glPushMatrix();
    glTranslatef(-0.2f,-0.5f, 0.0f);
    glutSolidSphere(0.1f,20,20);
   glPopMatrix();
   glPushMatrix();
    glTranslatef(0.2f,-0.5f, 0.0f);
    glutSolidSphere(0.1f,20,20);
   glPopMatrix();
  glPopMatrix();
}
void dibujar_rueda_y_tornillos_delante(){
  glPushMatrix();
  glColor3f(1.0f,0.0f,0.5f); 
  glTranslatef(1.2f,0.0f, 0.0f);
  glRotatef(grados, 0.0f, 0.0f, 1.0f);
  glutSolidSphere(1.0f,30,30);
  dibujar_tornillos();
  glPopMatrix();
}
void dibujar_rueda_y_tornillos_detras(){
  glPushMatrix();
  glColor3f(1.0f,0.0f,0.5f); 
  glTranslatef(5.8f,0.0f, 3.0f);
  glRotatef(grados, 0.0f, 0.0f, 1.0f);
  glutSolidSphere(1.0f,30,30);
  dibujar_tornillos();
  glPopMatrix();
}

void dibujar_ventanas(){
  glPushMatrix();
  glColor3f(0.0f,0.0f,0.5f); 
  glTranslatef(1.1f,2.1f, 0.01f);
  glBegin(GL_QUADS);
      glVertex3f(0.0f, 0.0f, 0.0f);
      glVertex3f(0.8f, 0.0f, 0.0f);
      glVertex3f(0.8f, 0.8f, 0.0f);
   glVertex3f(0.0f, 0.0f, 0.0f);
  glEnd();
  glBegin(GL_QUADS);
      glVertex3f(0.8f, 0.0f, 0.0f);
      glVertex3f(1.7f, 0.0f, 0.0f);
      glVertex3f(1.7f, 0.8f, 0.0f);
      glVertex3f(0.8f, 0.8f, 0.0f);
  glEnd();
  glTranslatef(1.9f,0.0f, 0.0f);
  glBegin(GL_QUADS);
      glVertex3f(0.0f, 0.0f, 0.0f);
      glVertex3f(0.9f, 0.0f, 0.0f);
      glVertex3f(0.9f, 0.8f, 0.0f);
      glVertex3f(0.0f, 0.8f, 0.0f);
  glEnd();
  glBegin(GL_TRIANGLES);
      glVertex3f(0.9f, 0.0f, 0.0f);
      glVertex3f(1.7f, 0.0f, 0.0f);
      glVertex3f(0.9f, 0.8f, 0.0f);
  glEnd();
  glPopMatrix();
}
void techo(){
  glPushMatrix();
  glTranslatef(1.0f,2.0f, 0.0f);
 glBegin(GL_TRIANGLES);
 glVertex3f(1.0f, -1.0f, 0.0f);
 glVertex3f(-1.0f, 0.0f, 0.0f);
 glVertex3f(1.0f, 1.0f, 0.0f);
  glEnd();
  glBegin(GL_QUADS);
      glVertex3f(1.0f, 0.0f, 0.0f);
      glVertex3f(3.0f, 0.0f, 0.0f);
      glVertex3f(3.0f, 1.0f, 0.0f);
      glVertex3f(1.0f, 1.0f, 0.0f);
  glEnd();
  glBegin(GL_TRIANGLES);
      glVertex3f(3.0f, 0.0f, 0.0f);
      glVertex3f(4.0f, 0.0f, 0.0f);
      glVertex3f(3.0f, 1.0f, 0.0f);
  glEnd();
  glPopMatrix();
}
dibujar_cuerpo_coche(){
  glColor3f(0.0,1.0,0.0); 
  glTranslatef(posicion,0.0f, 0.0f);
  glBegin(GL_QUADS);
      glVertex3f(0.0f, 0.0f, 0.0f);
      glVertex3f(7.0f, 0.0f, 0.0f);
      glVertex3f(7.0f, 2.0f, 0.0f);
      glVertex3f    (0.0f, 2.0f, 0.0f);
  glEnd();   
}
void display(){
  GLfloat angulo;
  int i;
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  glLoadIdentity();
  dibujar_cuerpo_coche();
  techo();
  dibujar_ventanas();
  dibujar_rueda_y_tornillos_delante();
  dibujar_rueda_y_tornillos_detras();
  glutSwapBuffers();
}
void init(){
  glClearColor(0,0,0,0);
  posicion=0;
  grados=0;
  glEnable(GL_DEPTH_TEST);
}
int main(int argc, char **argv){
  glutInit(&argc, argv);
  glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
  glutInitWindowPosition(50, 50);
  glutInitWindowSize(500, 500);
  glutCreateWindow("cARRITO RUN RUN");
  init();
  glutDisplayFunc(display);
  glutReshapeFunc(reshape);
  glutMainLoop();
  return 0;
}







lunes, 26 de marzo de 2012

Resumen unidad III


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 identidad
El “problema” del uso de estas funciones surge cuando se tiene más de un objeto en la escena. Estas funciones tienen efectos acumulativos.

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. Está delimitado por una serie de planos de trabajo. De estos planos, los más importantes son los planos de corte, que son los que nos acotan el volumen de visualización por delante y por detrás. En el plano más cercano a la cámara (znear) es donde se proyecta la escena para luego pasarla a la pantalla. Todo lo que esté más adelante del plano de corte más alejado de la cámara (zfar) no se representa.


Transformaciones
Las transformacion en OPENGL no sirven para poder tener funciones que permitan acceder directamente a las matrices que representen los estados de las transformaciones.


Algunas matrices como:
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 . 

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.

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’ = AM, 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(), con la diferencia que trabaja sobre una matriz en orden X. 


Estas operaciones afectan directamente las matrices mencionadas anteriormente, debido a que las operaciones de “alto nivel” (trasladar, rotar, escalar) que existen mas adelante se concatenan, es decir su efecto se acumula sobre matriz actual, existen dos operaciones que permiten guardar la matriz actual en una pila y restaurarla cuando sea necesario, estas son:


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.


Proyección
Una proyección es la forma en la que se pueden ver las cosas las cuales dependiendo de la forma en la que la veamos pueda cambiar lo que realmente es, tanto como sus dimensiones.
Hay dos formas de vistas las cuales son:


ORTOGRAFICA. La cual se maneja con la funciones glOrtho() y solo se ve el dibujo sin tener tamaños reales.


PERSPECTIVA la cual se ocupa con la libreria glFrustum() y otras funciones, esta ayuda para tener una profundidad y tamaño de las cosas reales.
La función es es void gluPerspective(GLdouble fov, GLdouble aspect, GLdouble near, GLdouble far);


Dentro de ellas existen transformaciones y modificaciones.


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 ModelView
Para las transformaciones modelview se necesita mas que el conocimiento de las coordenadas x,y,z si no tambien de conocimientos matematicos para hacer distintas funciones, lo bueno es que ya estan realizadas en bibliotecas y solo basta utilizarlas


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.


Rotacion
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)


Traslacion
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.


Escalacion
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.


Es importante aprender a utilizar correctamente glPushMatrix(), glPopMatrix() y otras operaciones que permitan salvar y restaurar estados de matriz, debido a que permiten realizar translaciones y rotaciones especificas para un cierto objeto, sin alterar los otros.


Coordenadas oculares: 
Las coordenadas oculares se sitúan en el punto de vista del observador, sin importar las transformaciones que tengan lugar. Por tanto, estas coordenadas representan un sistema virtual de coordenadas fijo usado como marco de referencia común.


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. Por defecto, el punto de vista está en el origen (0,0,0) mirando en dirección negativa del eje z. La transformación del observador permite colocar y apuntar la cámara donde y hacia donde se quiera. Todas las transformaciones posteriores tienen lugar basadas en el nuevo sistema de coordenadas modificado.


Propiedades del producto escalar usual.
1.  Conmutativa.  u · v = v  · u 
2.  Distributiva.  u · ( v + w)  = u · v  +  u · w 
3.  Reubicación del escalar. a (u · v) = (a u) · v = u · (a v) 
4.  Definida positiva: v · v = 0, y se da la igualdad v · v = 0 solamente para el vector v =  0 .
Vectores ortogonales lo son cuando su producto escalar es cero:  u · v = 0. Se denota u? v. 
Diremos que un conjunto de vectores es un conjunto ortogonal si cada uno de ellos es ortogonal a todos los demás. (Exigimos además que ninguno de los vectores sea el G0 ). 


Módulo de un vector
El módulo de un vector es la longitud del segmento orientado que lo define.
El módulo de un vector es un número siempre positivo y solamente el vector nulo tiene módulo cero.


Distancia entre dos puntos
La distancia entre dos puntos es igual al módulo del vector que tiene de extremos dichos puntos.

viernes, 23 de marzo de 2012

Esfera Cubo

#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);
glTranslatef(-3,0,0);

glRotatef(anguloCuboX, 1.0f, 0.0f, 0.0f);
glRotatef(anguloCuboY, 0.0f, 1.0f, 0.0f);
glScalef(0.5f, 0.5f, 0.5f);
drawCube();

glLoadIdentity();

glTranslatef(0.0f, 0.0f, -5.0f);
glRotatef(anguloEsfera, 1.0f, 0.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;
}




martes, 20 de marzo de 2012

Rebote de pelota

    #include <GL/glut.h>
    #include <GL/gl.h>
    #include <GL/glu.h>
    #include <math.h>
    #include <stdio.h>
    #include <string.h>
 
    #define WIDTH 640
    #define HEIGHT 480
 
 
 
    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 k=20;
    void circle(int p,int m)
    {
    int x=0,y,d,r;
    r=m;
    y=r;
    d=3-2*r;
    while(x<=y)
    {
 glVertex2i(-x,y+p);
    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(d<0)
    d=d+4*x+6;
    else
    {
    d=d+4*(x-y)+10;
    y--;
    }
    x++;
    }
    }
  
int r=50,flag=0;
  
    void display(void)
    {

  glColor3f(0.0,1.0,1.0);
  {
   glClear(GL_COLOR_BUFFER_BIT);
  glBegin(GL_QUADS);
          glVertex2f (-100.0, -240.0);
          glVertex2f (100.0, -240.0);
          glVertex2f (100.0, -200.0);
          glVertex2f (-100.0, -200.0);
          glVertex2f (100.0, -300.0);
          glVertex2f (100.0, -200.0);
          glVertex2f (100.0, -300.0);
          glVertex2f (100.0, -200.0);
    }

  
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glColor4f(1.0,0.0,0.0,1.0);
    glBegin(GL_POINTS);
  
  
    circle(k,r);
  
  
    if(flag==0)
    {
    if((k+r)<=240)
    {
    k=k+10;
  
    }
  
    if((k+r)>=240){
    flag=1;
  
    }
    }
  
    if(flag==1)
    {
    k=k-10;
  
  
    if((k-r)<=-200)
    {
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);
    }
 


martes, 13 de marzo de 2012

CUBO EN 3D

#include <GL/glut.h>
GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;
GLfloat x,y,z, ang, paso, dtx, dtz,pasoc,pasoa;
GLfloat pasob=-0.5;
GLint ancho=400;
GLint alto=400;
GLfloat trasy=0.0;
GLfloat a,b,c=2;
void myinit(void)
{
glClearColor(1.0, 1.0, 1.0, 1.0);
glColor3f(1.0, 0.0, 0.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0.0, 500.0, 0.0, 500.0);
glMatrixMode(GL_MODELVIEW);
}
int hazPerspectiva = 0;
void reshape(int width, int height)
{
    glViewport(0, 0, width, height);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
        glOrtho(-4,4, -4, 4, 1, 10);
        glMatrixMode(GL_MODELVIEW);
        ancho = width;
        alto = height;
}


void dibujarCube()
{
    glColor3f(0.0f, 1.0f, 0.0f);
    glBegin(GL_QUADS);  //cara frontal
    glVertex3f(a-1.0f, b-1.0f,  c+1.0f);
    glVertex3f(a+ 1.0f,b-1.0f, c+1.0f);
    glVertex3f( a+1.0f, b+1.0f,  c+1.0f);
    glVertex3f(a-1.0f,  b+1.0f,  c+1.0f);
    glEnd();
    glColor3f(0.0f, 1.0f, 1.0f);
  glBegin(GL_QUADS);       //cara trasera
    glVertex3f( a+1.0f, b-1.0f, c-1.0f);
    glVertex3f(a-1.0f, b-1.0f, c-1.0f);
    glVertex3f(a-1.0f,  b+1.0f, c-1.0f);
    glVertex3f( a+1.0f,  b+1.0f, c-1.0f);
    glEnd();
    glColor3f(1.0f, 0.0f, 1.0f);
glBegin(GL_QUADS);       //cara lateral izq
    glVertex3f(a-1.0f,b-1.0f, c-1.0f);
    glVertex3f(a-1.0f,b-1.0f,  c+1.0f);
    glVertex3f(a-1.0f, b+1.0f,  c+1.0f);
    glVertex3f(a-1.0f, b+1.0f, c-1.0f);
    glEnd();
    glColor3f(1.0f, 1.0f, 0.0f);
glBegin(GL_QUADS);     //cara lateral dcha
    glVertex3f(a+1.0f, b-1.0f,  c+1.0f);
    glVertex3f(a+1.0f, b-1.0f, c-1.0f);
    glVertex3f(a+1.0f,  b+1.0f, c-1.0f);
    glVertex3f(a+1.0f,  b+1.0f,  c+1.0f);
    glEnd();
    glColor3f(0.0f,0.0, 1.0f);
    glBegin(GL_QUADS);       //cara arriba
    glVertex3f(a-1.0f, b+1.0f,  c+1.0f);
    glVertex3f( a+1.0f, b+1.0f,  c+1.0f);
    glVertex3f( a+1.0f, b+1.0f, c-1.0f);
    glVertex3f(a-1.0f, b+1.0f, c-1.0f);
    glEnd();
    glColor3f(1.0f,1.0f, 1.0f);
  glBegin(GL_QUADS);      //cara abajo
    glVertex3f( a+1.0f,b-1.0f, c-1.0f);
    glVertex3f( a+1.0f,b-1.0f,  c+1.0f);
    glVertex3f(a-1.0f,b-1.0f,  c+1.0f);
    glVertex3f(a-1.0f,b-1.0f, c-1.0f);
    glEnd();
}
void gldrawCubo()
{
    float xMark = -1.0f;
    float yMark = -1.0f;
    float zMark = 1.0f;
    for (int i = 0; i < 2; i++)
    //moves back one unit on z-axis
    {
        for (int j = 0; j < 2; j++)
        //moves up one unit on y-axis
        {
            for (int k = 0; k < 2; k++)
            //builds 3 cubes along x-axis
            {
                dibujarCube();
                a=xMark;
                b=yMark;
                c=zMark;
                xMark++;
            }
            xMark = -1.0f;
            yMark++;
        }
        yMark = -1.0f;
        zMark--;
    }
}


void display()
{  
    glShadeModel(GL_SMOOTH);
    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);
    //glScalef(2.0f,2.0f,2.0f);
    gldrawCubo();
    glLoadIdentity();
    glTranslatef(0.0f, 0.0f, -5.0f);
   // glRotatef(anguloEsfera, 1.0f, 0.0f, 0.0f);
    glColor3f(1.0f, 1.0f, 1.0f);   
    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();
}


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


domingo, 11 de marzo de 2012

Investigación




Las proyecciones dentro del programa openGL puede hacerse ortogonales o perspectivas y cada uno de ellas tienen sus diferencias.



ORTOGONAL. Una proyección ortogonal define un volumen de la vista en forma parelepipeda, al ver el dibujo de esta forma es imposible el distinguir las medidas originales, es independiente una medida de otra.




Funciones
glMatriz(GL_Projection);//Indica la llamada a matriz de proteccion
glLoadIdentify();//Se carga la identidad inicial
void glortho(izquierda,derecha,abajo,arriba,cerca,lejos);// En lugar de las palabras van valores tipo flotantes para poder tener vistas.


En dado caso tengamos un dibujo tipo isometrico de dos dimensiones se utilizaria.
void gluortho2D(izquierda,derecha,abajo,arriba);





PERSPECTIVA. Una proyeccion perspectiva define un volumen de la vista la cual es un prisma truncado de base rectangular, con este se tiene una idea de cuales son las medidas, y la profundidad de los objetos




Funciones
void gluPerspective(fovy,aspecto,cerca,lejos);
//Fovy es el angulo de la toma
La perspectiva tiene una buena forma de ver los objetos, aunque para algunas presentacioners combiene la ortogonal





TRANSFORMACIONEGEOMÉTRICAS





TRASLACIÓN. La traslación es una funcion para mover el objeto a otro lugar de la pantalla, es decir el que el objeto solo vaya a otro lugar.


Para esto se tiene la siguiente funcion
glTraslatef(x.x,y.y,z.z)//Aqui se indica cuantos y en que eje se trasladara el objeto





ROTACIÓN. Para rotar un objeto sobre algun eje se tiene la siguiente funcion
glRotatef(GLfloat angulo, Glfloat x,GLfloat y, GLfloat z);


Al implementar esta funcion la rotacion se hace con sentido contrario a las manecillas del reloj





ESCALADO. Este cambie el tamaño del objeto en si, es decir si tiene un cuadrado con 2.0f a lo lados, dependiendo el escalado que le des sera menor o mayor, Se ocupa la siguiente funcion.
glScalef (GLfloat x, GLfloat y, GLfloat z);


Lo que podemos hacer tambien es el tener una diferente escalado para cada lado, dependiendo de la necesidad.





PILA DE MATRICES. 
En la funcion display() se encuentren las llamadas a dos funciones la glPushMatrix() y glPopMatrix(). Para comprender su funcionamiento un pequeño ejemplo.


La funcion glPushMatrix(), realiza copia de amtriz superior de forma que las dos sean igualesm ingresando los valores ala pila y con la funcion glPopMatrix() se llama a ese valor de la pila.


Existe otra funcion glMulMatrixd() multiplica la matriz superior de la pila por la matriz que tiene como argumento. Al multiplicar en este caso por la matriz identidad, la matriz que queda en la posicion superior de pila es mModel.





VIEWPORT
Viewport especifica la afinacion del eje x y el eje y la cual normaliza las coordenadas hacia la pantalla. Su funcion en si es al coordinacion de las coordenadas reales, a las coordenadas en pantalla.


En general, la ventana no esta ocupado unicamente por una aplicacion
-La ventana se divide en zonas de vision(viewports)
-El sistema coordenado es derecho
-Solo hay una zona de division activa
Linea de codigo.
glViewport(Xminimo,Yminimo,ancho,alto)
Principales aplicaciones:
-Tener varias areas de dibujo y proyeccion en una ventana
-Mantener la proporcion del aspecto













CONCLUSIONES

  • Es fácil de distinguir los dos tipos de perspectivas, ya que una es intuitiva y la otra es sin saber su altura o profundidad.
  • Al saber desarrollar la transformaciones geométricas se permitirá tener un mejor control de lo que dibujo, en dado caso no podamos verlo dentro de la pantalla o utilizarlo a nuestro antojo.
  • Al saber como están compuestas las matrices se da uno la idea del desarrollo de la maquina al hacer alguna funcion logica.
  • El pipeline no indica como se va mostrando los gráficos paso por paso en la pantalla, asi de una manera podemos ver que realizar la maquina por nosotros.





BIBLIOGRAFIA
http://www.opengl.org/sdk/docs/man/xhtml/glViewport.xml
http://graficos.uji.es/grafica/NuevasPracticas/Practica4/Proyecciones.html
http://www.tecnun.es/asignaturas/grafcomp/OpenGL/practica/capitulo4.pdf



viernes, 2 de marzo de 2012

Preguntas Proyecciones

PUEDE DIFERENCIAR ENTRE LOS DOS TIPOS DE PROYECCIÓN?
Si, la proyecciones perspectiva realiza un tipo de ilusión óptica, ya que depende del angulo en que se observe el objeto. Mientras que la otra solo se observa desde una sola forma.

PARA QUE SE USAN LAS MATRICES Y COMO LAS MANEJA OPENGL? 
Para tener puntos de referencia sobre los giros sobre el mismo punto, la perspectiva, etc. y estas se llevan acabo de métodos ya hecho para el programa

QUE ES LA MATRIZ IDENTIDAD Y PARA QUE SE UTILIZA EN OPENGL?
Esta matriz cumple la propiedad de ser el elemento neutro del producto de matrices. Esto quiere decir que el producto de cualquier matriz por la matriz identidad (donde dicho producto esté definido) no tiene ningún efecto

HAGA  OTRO PROGRAMA CON EL CUBO PERO CON PROYECCIÓN  EN PERSPECTIVA
EXPLIQUE LAS DIFERENCIAS.
No lo pude desarrollar en casa ya que no funciona el open GL aquí pero en dado caso la diferencia seria la forma en que se vera, es decir, si lo vemos de un angulo 90 grados tal ves solo se mire una cara, a que si lo vemos 135 quizás vemos 3

jueves, 1 de marzo de 2012

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.


Coordenadas oculares 
Las coordenadas oculares se sitúan en el punto de vista del observador, sin importar las transformaciones que tengan lugar. Por tanto, estas coordenadas representan un sistema virtual de coordenadas fijo usado como marco de referencia común. En la ilustración 4.1 se pueden apreciar dos perspectivas de este sistema de coordenadas. 


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. 

El modelador.- En esta sección se recogen las transformaciones del observador y del modelado puesto que, como se verá en el apartado 4.2.1.3, constituyen, al fin y al cabo, la misma transformación.
Transformaciones del observador.- La transformación del observador permite colocar y apuntar la cámara donde y hacia donde se quiera. Todas las transformaciones posteriores tienen lugar basadas en el nuevo sistema de coordenadas modificado.
Transformaciones del modelo.- Estas transformaciones se usan para situar, rotar y escalar los objetos de la escena. La apariencia final de los objetos depende en gran medida del orden con el que se hayan aplicado las transformaciones.
La matriz del modelador.- La matriz del modelador es una matriz 4x4 que representa el sistema de coordenadas transformado que se está usando para colocar y orientar los objetos. Si se multiplica la matriz del vértice (de tamaño 1x4) por ésta se obtiene otra matriz 1x4 con los vértices transformados sobre ese sistema de coordenadas.
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. Está delimitado por una serie de planos de trabajo. De estos planos, los más importantes son los planos de corte, que son los que nos acotan el volumen de visualización por delante y por detrás.


Para especificar una cámara virtual con perspectiva se necesita los siguientes parámetros:
cam
p
posición
(position)
d
dirección de mirada
(direction)
l
centro de enfoque
(look-at point)
u
dirección hacia arriba
(up-vector)
n
distancia al plano anterior
(near distance)
f
distancia al plano posterior
(far distance)
a=w/h
aspecto
(aspect)
Descripción: $ \alpha$
ángulo de abertura
(aperture angle)