jueves, 8 de noviembre de 2012

Crucigrama


1. Superficies__________ - se caracterizan por reflejar la luz en todas las direcciones. Paredes pintadas con mate.
2. La luz puede dejar una superficie mediante dos procesos fundamentales:
     •  Emisión _________
    •  9. ________________
3. Si la superficie es________, reflexión y absorción significará de toda la luz que dé en la superficie
4. ___________________(Luces direccionales): se caracterizan por un rango delgado de ángulos por los cuales se emite luz
5. Se describe una fuente mediante una función de _____________ o 8____________ de tres componentes.
6. Fuentes de __________: emite luz de manera igual en todas las direcciones.
7. Luz_________: lograr un nivel de luz uniforme en el cuarto. Esta   iluminación uniforme se llama
10. Superficies_______________ - se ven relumbrantes porque la mayoría de la luz reflejada ocurre en un rango de ángulos cercanos al ángulo de reflexión.
11. Luces _________: si la fuente de luz está lejos de la superficie, el vector no cambiará mucho según se mueve de un punto a otro, al igual que la luz del sol da en todos los objetos cercanos entre si con el mismo ángulo.

jueves, 1 de noviembre de 2012

Tecnicas de sombreado clasicas y avanzadas


Clásicas: Modelo de iluminación local
Son aquellos en los que se considera que la intensidad de luz en un punto de la superficie de un objeto se debe exclusivamente a las Fuentes luminosas.

Renderizado en Tiempo Real
La  renderización es el proceso de generar una imagen desde un modelo, y  se suele aplicar en la computación gráfica, más comúnmente a la infografía. En infografía este proceso se desarrolla con el fin de imitar un espacio 3D formado por estructuras poligonales, comportamiento de luces, texturas, materiales (agua,  madera,  metal, plástico,  tela, etcétera) y  animación, simulando ambientes y estructuras físicas verosímiles. Una de las partes más importantes de los programas dedicados a la  infografía son los motores de renderizado, los cuales son capaces de realizar técnicas complejas como  radiosidad,  raytrace, canal alfa, reflexión, refracción o iluminación global.
Cuando se trabaja en un  programa de diseño  3D asistido por ordenador, normalmente no es posible visualizar en tiempo real el acabado final deseado de una escena 3D compleja ya que esto requiere una potencia de cálculo demasiado elevada, por lo que se opta por crear el entorno 3D con una forma de visualización más simple y técnica, y luego generar el lento proceso de renderización para conseguir los resultados finales deseados. El tiempo de render depende en gran medida de los parámetros establecidos en los materiales y luces, así como de la configuración del programa de renderizado.
Realistas: Modelo de iluminación global
Son aquellos en los que se considera que la intensidad de luz en un punto de la superficie de un objeto se debe a las fuentes luminosas y al resto de los elementos existentes en la escena.
Trazado de rayos
Consiste en que –teniendo la posición y atributos físicos de cada uno de los objetos a iluminar, así como la situación, intensidad y tipo de fuentes de luz que iluminan los objetos, junto con la posición del observador y la del plano de proyección de la imagen (la pantalla), y el modo de iluminación o cálculo del color en un punto de la superficie de un objeto- se traza un rayo desde la posición del observador a través de cada uno de los píxeles del plano de proyección (una de las ventajas del raytracing es que los rayos que se procesan son sólo los rayos que parten del observador ), y por cada uno de estos rayos trazados se busca si interseca con alguno de los objetos que se representan; si no se encuentra ninguna intersección, para ese pixel, no se sigue el proceso y se le hace corresponder, por defecto, un color de fondo.  Si el rayo se encontrara con un objeto, se analizan los atributos físicos que tiene asignado el objeto y se resuelve según la modelización de la iluminación, calculando su color en el punto del objeto donde interseca el rayo.
Radiosidad
El método de radiosidad, consiste en que las reflexiones de la luz sobre los objetos se tratan como reflexiones difusas ideales de tal manera que la modelización de los efectos ópticos, como la de los espejos, por ejemplo, no se realiza. Este método hace aquello que no realiza el trazado de rayos. Para este método, los materiales de los objetos tienen superficies mate que no producen reflexiones espectaculares, por lo que la parte de energía que les llega, y que no haya sido absorbida por la superficie, se refleja por igual a lo largo de toda esta superficie del objeto.
Cálculos de iluminación por pixel
Antes de que el color final del píxel sea decidido, un cálculo de iluminación debe ser computado para sombrear a los píxeles basados en alguna luz que puede estar presente en la escena.
Sombreado Plano o Constante
Los tres vectores, l, n y v, pueden variar según se va entre puntos sobre una superficie.
• Para un polígono plano, n es constante.
• Si se asume un observador distante, v es constante sobre el polígono.
• Si la fuente de luz es distante, l es constante.
Si los tres vectores son constantes, entonces el cálculo de sombreado se lleva a cabo una sola vez para cada polígono, y se asignará la misma sombra a cada punto en el polígono.
Sombreado plano mostrará diferencias de sombreado entre los polígonos.
Sombreado Gouraud
En el sombreado Gouraud, se define la normal en un vértice como el promedio normalizado de las normales de los polígonos que comparten el vértice.
Desde la perspectiva de OpenGL, el sombreado Gouraud es sencillo. Se necesita solamente asignar correctamente las normales de vértices. Sin embargo, existe un problema, encontrar las normales para promediar. Si el programa es lineal, especificar una lista de vértices (y otras propiedades), no se tiene la información necesaria de cuales polígonos comparten un vértice. Lo que se requiere es una estructura de datos para representar un "mesh". Atravesar esta estructura de datos puede generar los vértices con las normales promediadas. Tal estructura de datos debe contener, de manera mínima, polígonos, vértices, normales, y propiedades de los materiales.
Sombreado Phong
Phong propuso que, en lugar de interpolar intensidades de los vértices, se interpole normales a lo largo del polígono. Para un polígono que comparte lados y vértices con otros polígonos.
Se puede computar normales en los vértices interpolando sobre las normales de los polígonos que comparten el vértice. Luego, se puede usar interpolación bilineal, para interpolar las normales sobre el polígono.
Una vez obtenidas las normales en cada punto, se puede hacer cálculos de sombreado independientes. Normalmente, este proceso se combinará con la rasterización del polígono.
Sombreado Phong producirá imágenes mas suaves que con el sombreado Gouraud, pero a un costo computacional mayor.
Recortado de caras traseras
 En una escena, los objetos se tapan a sí mismos y entre sí, quedando siempre partes ocultas al observador.
Las partes ocultas deben ser eliminadas de posteriores operaciones: proceso de visibilidad.
El proceso de visibilidad es complejo, por lo que existen numerosas soluciones.
 Técnicas implicadas:
Cálculo de normales
Ordenación
Algoritmos de visibilidad
Aceleración por coherencia

Técnicas de aceleración
o    Eliminación de caras traseras
o    Coherencia
o    Contenedores
Algoritmo fundamental en el espacio de la imagen: trazado de visuales (ray casting)
Algoritmos más conocidos:
Z- Buffer
Prioridad en lista
Scan- Line
Buffer de Profundidad
El z-buffering, o el buffer de profundidad es la parte de la memoria de nuestra tarjeta gráfica encargada de la visibilidad de nuestros gráficos 3D según las coordenadas de sus pixeles, con lo que se puede gestionar qué elementos de una escena renderizada son visibles y cuales permanecerán ocultos según sus posiciones en el eje Z (distancia a cámara).
En definitiva lo que se hace es comparar las profundidades de ambos gráficos para representar el objeto más cercano al observador. La profundidad elegida se guardará en el z-buffering reemplazando a la anterior.
Transparencias
La implementación de la transparencia en un programa OpenGL no suele ser sencilla. Podemos combinar los colores de los objetos para una escena simple que contenga unas pocas superficies opacas y transparentes utilizando el valor de mezcla alpha para especificar el grado de transparencia y procesando las superficies según su orden de profundidad. Pero las operaciones de mezcla de color OpenGL ignoran los efectos de refracción, y el manejo de superficies transparentes en escenas complejas con una diversidad de condiciones de iluminación o con animaciones puede resultar muy complicado. Así mismo, OpenGL no proporciona ninguna funcionalidad para simular la apariencia superficial de un objeto translúcido (como por ejemplo un cristal esmerilado), que dispersa de manera difusa la luz transmitida a través del material semitransparente. Por tanto, para mostrar superficies translúcidas o los efectos de iluminación resultantes de la refracción, necesitamos describir nuestras propias rutinas. Para simular los efectos de iluminación a través de un objeto translúcido, podemos utilizar una combinación de valores de textura superficial y de propiedades del material. Para los efectos de refracción, podemos desplazar las posiciones de píxel para las superficies que se encuentren detrás de un objeto transparente.
El blending es simplemente una técnica que se puede utilizar para obtener efectos de transparencias.
La transparencia mediante el blending es tan difícil como incómoda, pero si se controlan algunos aspectos de la escena, se puede conseguir el efecto deseado sin demasiada complejidad.

Buffer de Stencil
Stencill Buffer es una memoria intermedia que analiza y actualiza píxeles (con sus operaciones) junto con buffer de profundidad.  Añade planos de bits adicionales para cada píxel además de los bits de color y profundidad.
Stencil Buffer se puede pensar que simplemente etiqueta los píxeles en la interpretación o renderización de la escena en la pantalla para controlar las siguientes interpretaciones. Los pasos son siguientes:
1.    Dada una escena con una sombra fija. Los píxeles de la escena se podrían considerar con “dentro” de la sombra o “fuera”. Asumimos que podemos etiquetar cada píxel apropiadamente.
2.    Cuando los píxeles ya son etiquetados, actualizamos los píxeles etiquetados como “dentro” de la sombra. Y renderizamos la escena con la fuente de luz desactivada.
3.    Después actualizamos los píxeles etiquetados como “fuera” de la sombra. Activamos la luz y renderizamos otra vez.


Buffer de acumulación
El buffer de acumulación sirve para capturar el buffer de color en un fotograma y aplicarle acumulaciones del color de otro fotograma/s. Esto básicamente sirve para simular el efecto de estela que deja un objeto cuando se mueve muy rápidamente en el encuadre de la cámara.
Fuentes de Luz
La luz puede dejar una superficie mediante dos procesos fundamentales:
• Emisión propia
• Reflexión
Normalmente se piensa en una fuente de luz como un objeto que emite luz solo mediante fuentes de energía internas, sin embargo, una fuente de luz, como un foco, puede reflejar alguna luz incidente a esta del ambiente.
Se considerarán cuatro tipos básicos de fuentes, que serán suficientes para generar las escenas más sencillas:
1. Luz ambiente
2. Fuentes de punto
3. Spotlights (Luces direccionales)
4. Luces distantes
Fuentes de color
Para la mayoría de las aplicaciones, se puede modelar fuentes de luz en base a tres componentes primarios, RGB, y puede usar cada uno de los tres colores fuentes para obtener el componente de color correspondiente que un observador humano vería.
Se describe una fuente mediante una función de intensidad o luminancia de tres componentes: Cada uno de los componentes es la intensidad de los componentes rojo, verde y azul independientes.


Luz Ambiente
Como el modelo de iluminación es local, las partes que no están iluminadas por una fuente de luz se verían totalmente negras. Para evitar esto, se supone que hay una iluminación uniforme que es el promedio de la luz reflejada por los objetos, a la que llamamos ambiental.
En algunos cuartos, las luces se diseñan y ubican para proveer iluminación uniforme en el cuarto. Tal iluminación se logra mediante fuentes grandes con difusores cuyo propósito es esparcir la luz en todas las direcciones. Se puede crear una simulación precisa de tal iluminación, modelando todas las fuentes distribuidas, y luego integrando la iluminación de estas fuentes en cada punto de una superficie reflectora. Hacer tal modelo y generar la escena sería una tarea formidable para un sistema gráfico, especialmente si se desea ejecución en tiempo real. De manera alternativa, se puede ver el efecto deseado de las fuentes: lograr un nivel de luz uniforme en el cuarto. Esta iluminación uniforme se llama luz ambiente.

Spotlights (Luces direccionales)
Los spotlights se caracterizan por un rango delgado de ángulos por los cuales se emite luz. Se puede construir un spotlight sencillo de una fuente de punto limitando los ángulos de donde la luz de la fuente se puede ver. Se puede usar un cono cuyo ápice está en ps, apuntando en la dirección ls, y cuyo ancho está determinado por el ángulo θ.
Spotlights más realistas se caracterizan por una distribución de luz dentro del cono, normalmente con la mayoría de la luz concentrada en el centro del cono.
Fuentes de Luz Distantes
La mayoría de los cálculos de sombreado requieren la dirección de un punto sobre la superficie a la fuente de luz. Según se mueve a lo largo de la superficie, se debe recomputar este vector para calcular la intensidad en cada punto. Sin embargo, si la fuente de luz está lejos de la superficie, el vector no cambiará mucho según se mueve de un punto a otro, al igual que la luz del sol da en todos los objetos cercanos entre si con el mismo ángulo.

En la práctica, los cálculos para fuentes de luz distantes son similares a los cálculos para proyecciones paralelas; se reemplaza la ubicación de la fuente de luz por una dirección de la fuente de luz. Por lo tanto, en coordenadas homogéneas, una fuente de luz de punto en p0 se representará internamente como una matriz columna de cuatro dimensiones

donde la fuente de luz distante se representa mediante

que es la representación de un vector.

Intensidad Completa
La intensidad completa exclusivamente para efectos de iluminación es la siguiente:

piramide




#include <GL/glut.h>
GLfloat anguloCuboX = 0.0f;
 GLfloat anguloCuboY = 0.0f;
 GLint ancho=500;
 GLint alto=500;
 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, -1, 4, -5, 10);  
   glMatrixMode(GL_MODELVIEW);    
   ancho = width;  
   alto = height;
  }

 void Piramide(void){

   glShadeModel(GL_SMOOTH);
  glColor3f(1.0, 0.0, 0.0);
  glBegin(GL_POLYGON);
   glVertex3f(0.0, 1.0,  0.0);  
   glVertex3f( 1.0f, 0.0f,  1.0f);  
   glVertex3f( 0.0f,  1.0f,  0.0f);
   glEnd();  

  glShadeModel(GL_SMOOTH);
     glBegin(GL_POLYGON);      
    glColor3f(1.0f, 1.0f, 1.0f);
  glVertex3f(-1.0f, 0.0f,  -1.0f);  
     glVertex3f( 1.0f, 0.0f,  -1.0f);
  glColor3f(0.0f, 1.0f, 0.0f);
  glVertex3f( 0.0f,  1.0f,  0.0f);
     glEnd();  

 glShadeModel(GL_SMOOTH);
     glBegin(GL_POLYGON);        
     glVertex3f(-1.0f, 0.0f,  1.0f);
   glColor3f(0.0, 1.0, 1.0);
     glVertex3f( -1.0f, 0.0f, -1.0f);  
  glVertex3f( 0.0f,  1.0f,  0.0f);  
  glEnd();

 glShadeModel(GL_SMOOTH);
     glBegin(GL_POLYGON);      
  glVertex3f(1.0f, 0.0f,  1.0f);
  glColor3f(1.0f, 0.0f, 0.0f);
     glVertex3f( 1.0f, 0.0f,  -1.0f);  
  glVertex3f( 0.0f,  1.0f,  0.0f);
  glEnd();

  glShadeModel(GL_SMOOTH);  
  glBegin(GL_QUADS);
  glVertex3f( 1.0f,0.0f, -1.0f);  
  glVertex3f( 1.0f, 0.0f,  1.0f);
  glColor3f(1.0f, 1.0f, 0.0f);
  glVertex3f(-1.0f,0.0f,  1.0f);  
  glVertex3f(-1.0f, 0.0f, -1.0f);  
  glEnd();

 }

  void display(){
   glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);    
   glLoadIdentity();    
  glScalef(2.5f, 2.5f, 2.5f);
   glRotatef(anguloCuboY, 0.0f, 1.0f, 0.0f);
   Piramide();    
   glLoadIdentity();    
   glFlush();  
   glutSwapBuffers();  
  anguloCuboX+=0.1f;  
   anguloCuboY+=0.1f;
  }

 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(100, 100);  
   glutInitWindowSize(ancho, alto);  
   glutCreateWindow("Tania Esparza");  
   init();  
   glutDisplayFunc(display);  
   glutReshapeFunc(reshape);  
   glutIdleFunc(idle);  
   glutMainLoop();  
   return 0;
 }

dibujos 3d y transformaciones geometricas

Tania Angélica Esparza Maldonado


miércoles, 17 de octubre de 2012

Problema II de examen

1. Resultados de los vertices despues de cada transformacion, usando excel


2. Programas en opengl de las transformaciones mencionadas:
a) tomando como base los vertices iniciales para cada transformación


#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();

glTranslatef (-2,-2,0);
glColor3f (1,1,.8);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Traslacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}


#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();

glScalef (0.5,0.5,0.0);
glColor3f (1,1,.8);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Escalacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}


#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();

glRotatef(45.0,0,0,1);
glColor3f (1,1,.8);
glBegin(GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Rotacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}

b) tomando las transformaciones en secuencia, es decir despues de la traslacion a los vertices resultantes aplicar la escalacion y al resultado aplicar la rotación.


#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();

glTranslatef (-2,-2,0);
glColor3f (1,1,.8);
glBegin (GL_POLYGON);
glVertex2f (2,2);
glVertex2f (7,2);
glVertex2f (7,7);
glVertex2f (2,7);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Translacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}


#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (0,0);
glVertex2f (5,0);
glVertex2f (5,5);
glVertex2f (0,5);
glEnd();

glScalef (0.5,0.5,0.0);
glColor3f (1,1,.8);
glBegin (GL_POLYGON);
glVertex2f (0,0);
glVertex2f (5,0);
glVertex2f (5,5);
glVertex2f (0,5);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Escalacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}


#include <GL/glut.h>

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0,1,1);
glBegin (GL_POLYGON);
glVertex2f (0,0);
glVertex2f (2.5,0);
glVertex2f (2.5,2.5);
glVertex2f (0,2.5);
glEnd();

glRotatef(45.0,0,0,1);
glColor3f (1,1,.8);
glBegin(GL_POLYGON);
glVertex2f (0,0);
glVertex2f (2.5,0);
glVertex2f (2.5,2.5);
glVertex2f (0,2.5);
glEnd();
glFlush ();
}

void init (void)
{
glClearColor (0,0,1,1);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-15,10,-15,10,-5,5);
}

int main(int argc, char** argv)
{
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE | GLUT_RGB);
glutInitWindowSize (400, 400);
glutInitWindowPosition (200, 200);
glutCreateWindow ("Rotacion");
init ();
glutDisplayFunc (display);
glutMainLoop ();
return 0;
}

lunes, 8 de octubre de 2012

Pelota que rebota


#include <GL/glut.h>
float escala=0.5; //tamaño de la Esfera.
int ResX=300,ResY=200;
float angX=0.0f,angY=0.0f;
enum{EJE=2};
float angB=0.0f,angC=0.0f,angDE=0.0f;
float aceX=0.0f,aceY=-0.00001f; //Entre mas pequeño sea el valor de la aceleracion de Y la pelota tarda mas
//tiempo en rebotar.
float velX=0.001f,velY=0.0f;
float posX=0.0f,posY=10.0f;
//Definición de las caracteristicas opticas del material: coeficientes de reflexión
GLfloat material [4] = {1.0f, 0.2f, 0.2f, 1.0f };
GLfloat RedMaterial [4] = {1.0, 1.0, 0.0, 1.0 };
GLfloat GreenMaterial [4] = {0, 0.0, 1.0, 1.0 };
GLfloat BlueMaterial [4] = {1.0, 1.0, 1.0, 0.6 };
GLfloat WhiteMaterial [4] = {0.6, 0.0, 0.0, 1.0 };
GLfloat BlackMaterial [4] = {0.6, 1.0, 0.4, 1.0 };
GLfloat GrayMaterial [4] = {0.7, 0.6, 0.6, 1.0 };
void pEJE(){
glNewList(EJE,GL_COMPILE);
glPushMatrix();
glutSolidSphere(1.0f,50,50);
glPopMatrix();
glEndList();
}
void RenderScene(void){
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
//CÁMARA
glLoadIdentity( );
glTranslatef(0.0f,0.0f,-5.0f);
glRotatef(angY,1.0f,0.0f,0.0f);
glRotatef(angX,0.0f,1.0f,0.0f);
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, GreenMaterial );
glPushMatrix();
glTranslatef(posX,posY,0.0f);
glCallList(EJE);
glPopMatrix();
//glFlush();
glutSwapBuffers();
}
//esta funcion se usa para el rebote de la esfera.
void idle(void){
velY+=aceY; posY+=velY;
velX+=aceX; posX+=velX;
if(posY<0.0f){posY=0.0f; velY*=-0.8f;
if(velY<0.01f){velX=0.0f; velY=0.0f;}
}
glutPostRedisplay();
}
int main(int a, char *b[]){
glutInit(&a,b);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(ResX,ResY);
glutInitWindowPosition(200,300);
glutCreateWindow("REBOTA");
glutDisplayFunc(RenderScene);
glutIdleFunc(idle);
glViewport( 0, 0, ResX, ResY );
glMatrixMode( GL_PROJECTION );
glLoadIdentity( );
glFrustum(-(float)ResX/ResY, (float)ResX/ResY, -1.0, 1.0, 2, 10000.0);
glMatrixMode( GL_MODELVIEW );
glLoadIdentity( );
glEnable(GL_DEPTH_TEST);
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glShadeModel(GL_SMOOTH);
pEJE();
glutMainLoop();
return 0;
}


sábado, 6 de octubre de 2012

Glosario


CAVE (Cave Automatic Virtual Environment). Es un entorno de realidad virtual inmersiva. Se trata de una sala en forma de cubo en la que hay proyectores orientados hacia las diferentes paredes, suelo y techo. Dependiendo del resultado que se quiera obtener se proyectará la imagen a todas o sólo alguna de las paredes de la sala.

Coordenadas Homogéneas. Las coordenadas homogéneas son un instrumento usado para describir un punto en el espacio proyectivo. Su notación en forma matricial se emplea en bibliotecas de programación gráfica en 3D como OpenGL y Direct3D.

Diafana. Que deja pasar a través la luz casi en su totalidad.

Ecografía. Es un procedimiento de imagenología que emplea los ecos de una emisión de ultrasonidos dirigida sobre un cuerpo u objeto como fuente de datos para formar una imagen de los órganos o masas internas con fines de diagnóstico. 

Espejo cóncavo. Es el que con su superficie forma un paraboloide de revolución, todos los rayos que inciden paralelos al eje del espejo, se reflejan pasando por el foco, y los que inciden pasando por el foco, se reflejan paralelos al eje.

Estereoscopía. Es cualquier técnica capaz de recoger información visual tridimensional y/o crear la ilusión de profundidad mediante una imagen estereográfica, un estereograma, o una imagen tridimensional.

Holografía. Es una técnica avanzada de fotografía, que consiste en crear imágenes tridimensionales. Para esto se utiliza un rayo láser, que graba microscópicamente una película fotosensible. Ésta, al recibir la luz desde la perspectiva adecuada, proyecta una imagen en tres dimensiones.

Obturador. Es el dispositivo que controla el tiempo durante el que llega la luz al dispositivo fotosensible. Este tiempo es conocido como la velocidad de obturación, y de él se desprenden conceptos como el congelado o el barrido fotográfico.

Pila (programacion). Una pila (stack en inglés) es una lista ordinal o estructura de datos en la que el modo de acceso a sus elementos es de tipo LIFO (del inglés Last In First Out, último en entrar, primero en salir) que permite almacenar y recuperar datos. Esta estructura se aplica en multitud de ocasiones en el área de informática debido a su simplicidad y ordenación implícita de la propia estructura.

Proyector LCD. El sistema de pantalla de cristal líquido es el más simple, por tanto uno de los más comunes y accesibles para el uso doméstico.
Realidad virtual inmersiva. Los métodos inmersivos de realidad virtual con frecuencia se ligan a un ambiente tridimensional creado por un ordenador, el cual se manipula a través de cascos, guantes u otros dispositivos que capturan la posición y rotación de diferentes partes del cuerpo humano.

Reconstrucción 3D. Es el proceso mediante el cual, objetos reales, son reproducidos en la memoria de una computadora, manteniendo sus características físicas.