sábado, 7 de diciembre de 2013
viernes, 6 de diciembre de 2013
Modelado Geometrico
Modelos geométricos
Describen componentes con propiedades geométricas inherentes y por lo tanto se presentan en forma natural a la representación gráfica. Forma entre los que se puede representar un modelo geométrico:
* Distribución espacial y forma de los componentes y otros componentes que afectan a la apariencia de los componentes.
* Conectividad de los componentes.
* Los valores de datos específicos para la aplicación
Modelado de superficie
Es la estimación de los valores de una superficie en cualquiera de sus puntos, partiendo de un conjunto de datos de muestreo (x,y,z), denominados puntos de control.
Aplicaciones
* Geología
* Geofísica
* Meteorología
* Ingeniería Ambiental
* Economía
* Medicina
Este modelo nos permite utilizar representaciones de los sólidos basadas el almacenamiento de la frontera, que es una entidad bidimensional. Para facilitar la representación se suele exigir, además que la frontera sea 2-variedad, esto es, cada punto de la frontera es homeomoformo a un disco en E2.
Existen dos enfoques para la presentación de la superficie externa del objeto:
1) El objeto se presenta con una lista de facetas, descritas por los lados y las aristas que la delimitan. La lista de caras puede incluir solamente informaciones geométricas propias de cada faceta (tamaño, posición respecto a un origen, etcétera), o puede estar estructurada en un conjunto más complejo, donde los nodos de tipo "caras" se ligan a los nodos arista a través de los nodos "lados". Estas conexiones pueden representarse en forma de gráficas o de una estructura de árbol.
2) El objeto se representa empleando superficies de "forma libre", que el usuario manipula interactivamente a través de puntos llamados de "control". Se utiliza una superficie representada por ecuaciones paramétricas, que efectúa una aproximación de envoltura exterior del objeto.
Modelado de sólido.
El modelado de sólidos es una rama del modelado geométrico que hace énfasis en la aplicabilidad general de modelos, e insiste únicamente en la creación de representaciones “completas” de objetos físicos sólidos, esto es, representaciones que son adecuadas para la respuesta de preguntas geométricas arbitrarias de manera algorítmica.
El objetivo de la aplicabilidad general, separa al modelado de sólidos de otros tipos de modelado geométrico, los cuales están enfocados hacia propósitos especiales. Los modelos gráficos (Graphical Models) intentan describir undibujo de un objeto mas que el objeto en si mismo.
El modelado de sólidos es el conjunto de teorías, técnicas y sistemas orientados a la representación “completa en cuanto a información” de sólidos. Dicha representación debe permitir (al menos en principio) calcular automáticamente cualquier propiedad bien conocida de cualquier solido almacenado.
jueves, 5 de diciembre de 2013
jueves, 14 de noviembre de 2013
Lineas
Algoritmo DDA para generacion de lineas.
Es un algoritmo que se basa en el calculo y la evaluacion de un DeltaX(X) y un DeltaY(Y). Por medio de las siguientes ecuaciones:
DeltaX = DeltaY / m
DeltaY = m * DeltaX
Leer Coordenadas P1(Xinicial, Yinicial)
Leer Coordenadas P2(Xfinal,Yfinal)
Asignar a DeltaX la diferencia de Xfinal - Xinicial
Asignar a DeltaY la diferencia de Yfinal - Yinicial
Si ABS( DeltaX) > ABS(DeltaY)
Asignar a Pasos el ABS(DeltaX)
De lo contrario
Asignar a Pasos el ABS(DeltaY)
Asignar a Xincremento el resultado de DeltaX / Pasos
Asignar a Yincremento el resultado de DeltaY / Pasos
Asignar a X el valor de Xinicial
Asignar a Y el valor de Yinicial
Iluminar pixel en coordenada X,Y
Desde k=1 hasta Pasos
Asignar a X la suma de X + Xincremento
Asignar a Y la suma de Y + Yincremento
Iluminar pixel en Coodenada X,Y
Fin de Algoritmo(DDA)
Es
considerado uno de los algoritmos más efectivos para dibujar líneas
mediante rastreo. Emplea cálculos incrementales con valores enteros. La
forma de determinar el siguiente pixel a dibujar en la generación de una
línea, se describe a continuación:
1.- Punto inicial P1(Xinicial,Yinicial).
2.- Se desplaza una columna (incrementando la posición en X)
3.- Se traza el pixel cuyo valor de Y de la línea de rastreo se aproxima más a la trayectoria de la línea. Se capturan los dos extremos de la línea P1(Xinicial,Yinicial) y P2(Xfinal,Yfinal)
4.- Se dibuja el primer pixel correspondiente al extremo izquierdo de la línea(P1)
5.- Se calculan los parámetros que permitien decidir cuál será el proximo pixel a dibujar (DeltaX, DeltaY y ConstanteP).
6.- Dependiendo del valor que tome el Parámetro ConstanteP se evalúa y determina la coordenada a dibujar que puede ser:
1.- (X+1,Y) para ConstanteP < 0
2.- Sino (X+1,Y+1)
El proceso anterior debe repetirse 4DeltaX veces.
Pseudocodigo.
Leer Coordenadas P1(Xinicial, Yinicial)
Leer Coordenadas P2(Xfinal, Yfinal)
Asignar a DeltaX el ABS( Xfinal - Xinicial)
Asignar a DeltaY el ABS( Yfinal -Yinicial)
Asignar a ConstanteP el resultado de 2*DeltaY - DeltaX
Si Xinicial > Xfinal
Asignar Xfinal a X
Asignar Yfinal a Y
Asignar Xinicial a Ultimo
De lo contrario
Asignar Xinicial a X
Asignar Yinicial a Y
Asignar a Xfinal a Ultimo
Iluminar pixel en coordenada X,Y
Hacer mientras X<Ultimo
Asignar X + 1 a X
Si ConstanteP < 0
Asignar ConstanteP + 2 *DeltaY a ConstanteP
De lo contrario
Asignar Y+1 a Y
Asignar a ConstanteP el resultado de ConstanteP+2 *(DeltaY-DeltaX)
Iluminar pixel en coordenada X,Y
Fin de Algoritmo (Bresenham)
Código:
void Bres(int x0,int y0,int xFin,int yFin)
{
int dx = fabs(xFin - x0),
dy = fabs(yFin - y0);
int p = 2 * dy - dx;
int dosDy = 2 * dy,
dosDyMenosDx = 2 * (dy - dx);
int x, y;
/* Determinamos que punto usamos como inicio. */
if (x0 > xFin) {
x = xFin;
y = yFin;
xFin = x0;
}
else {
x = x0;
y = y0;
}
setPixel (x, y);
while (x <>
x++;
if (p <>
p += dosDy;
else {
y++;
p += dosDyMenosDx;
}
setPixel (x, y);
}
}
Es un algoritmo que se basa en el calculo y la evaluacion de un DeltaX(X) y un DeltaY(Y). Por medio de las siguientes ecuaciones:
DeltaX = DeltaY / m
DeltaY = m * DeltaX
Se
efectua un muestreo de la linea en intervalos unitarios en una
coordenada y se determinan los valores enteros correspondientes mas
proximos a la trayectoria de la linea para la siguiente coordenada.
Se
aceptan como datos de entradas las dos posiciones de los pixeles
correspondientes a los extremos de la linea p1(Xinicial, Yinicial) y
p2(Xfinal, Yfinal). Las diferencias horizontal y vertical entre las
posiciones de los extemos dados, se asigna las variables DeltaX y DeltaY
respectivamente. La diferencia con la mayor magnitud determina el valor
del parametro Pasos. Se procede a determinar la compensacion necesaria
(incremento), para generar la posicion del pixel siguiente a lo largo de
la trayectoria de la linea. Luego, se ilumina la posicion en la
pantalla y se repite este proceso ciclico, hasta obtener la linea
deseada.
Pseudocodigo.
Leer Coordenadas P2(Xfinal,Yfinal)
Asignar a DeltaX la diferencia de Xfinal - Xinicial
Asignar a DeltaY la diferencia de Yfinal - Yinicial
Si ABS( DeltaX) > ABS(DeltaY)
Asignar a Pasos el ABS(DeltaX)
De lo contrario
Asignar a Pasos el ABS(DeltaY)
Asignar a Xincremento el resultado de DeltaX / Pasos
Asignar a Yincremento el resultado de DeltaY / Pasos
Asignar a X el valor de Xinicial
Asignar a Y el valor de Yinicial
Iluminar pixel en coordenada X,Y
Desde k=1 hasta Pasos
Asignar a X la suma de X + Xincremento
Asignar a Y la suma de Y + Yincremento
Iluminar pixel en Coodenada X,Y
Fin de Algoritmo(DDA)
Código:
void DDA(int x0,int y0,int xFin,int yFin)
{
int dx = xFin - x0, dy = yFin - y0, steps, k;
float xIncremento, yIncremento;
float x = x0, y = y0;
if (fabs (dx) > fabs (dy))
steps = fabs (dx); /* |m|<1>
else
steps = fabs (dy); /* |m|>=1 */
xIncremento=float(dx)/float (steps);
yIncrement = float (dy) / float (steps);
setPixel (round (x), round (y));
for (k = 0; k <>
{
x += xIncremento;
y += yIncremento;
setPixel (round (x), round (y));
}
}
void DDA(int x0,int y0,int xFin,int yFin)
{
int dx = xFin - x0, dy = yFin - y0, steps, k;
float xIncremento, yIncremento;
float x = x0, y = y0;
if (fabs (dx) > fabs (dy))
steps = fabs (dx); /* |m|<1>
else
steps = fabs (dy); /* |m|>=1 */
xIncremento=float(dx)/float (steps);
yIncrement = float (dy) / float (steps);
setPixel (round (x), round (y));
for (k = 0; k <>
{
x += xIncremento;
y += yIncremento;
setPixel (round (x), round (y));
}
}
Algoritmo de Bresenham para trazar líneas.
Es un
algoritmo creado para dibujar rectas en los dispositivos de graficos
rasterizados, como por ejemplo un monitor de computadora, que determina
que pixeles se rellenaran, en funcion de la inclinacion del angulo de la
recta a dibujar.
Es un
algoritmo preciso para la generacion de lineas de rastreo que convierte
mediante rastreo las lineas al utilizar solo calculos incrementales con
enteros que se pueden adaptar para desplegar circunferencias y curvas.
Los ejes verticales muestran las posiciones de rastreo y los ejes
horizontales identifican las columnas de pixel.
1.- Punto inicial P1(Xinicial,Yinicial).
2.- Se desplaza una columna (incrementando la posición en X)
3.- Se traza el pixel cuyo valor de Y de la línea de rastreo se aproxima más a la trayectoria de la línea. Se capturan los dos extremos de la línea P1(Xinicial,Yinicial) y P2(Xfinal,Yfinal)
4.- Se dibuja el primer pixel correspondiente al extremo izquierdo de la línea(P1)
5.- Se calculan los parámetros que permitien decidir cuál será el proximo pixel a dibujar (DeltaX, DeltaY y ConstanteP).
6.- Dependiendo del valor que tome el Parámetro ConstanteP se evalúa y determina la coordenada a dibujar que puede ser:
1.- (X+1,Y) para ConstanteP < 0
2.- Sino (X+1,Y+1)
El proceso anterior debe repetirse 4DeltaX veces.
Leer Coordenadas P2(Xfinal, Yfinal)
Asignar a DeltaX el ABS( Xfinal - Xinicial)
Asignar a DeltaY el ABS( Yfinal -Yinicial)
Asignar a ConstanteP el resultado de 2*DeltaY - DeltaX
Si Xinicial > Xfinal
Asignar Xfinal a X
Asignar Yfinal a Y
Asignar Xinicial a Ultimo
De lo contrario
Asignar Xinicial a X
Asignar Yinicial a Y
Asignar a Xfinal a Ultimo
Iluminar pixel en coordenada X,Y
Hacer mientras X<Ultimo
Asignar X + 1 a X
Si ConstanteP < 0
Asignar ConstanteP + 2 *DeltaY a ConstanteP
De lo contrario
Asignar Y+1 a Y
Asignar a ConstanteP el resultado de ConstanteP+2 *(DeltaY-DeltaX)
Iluminar pixel en coordenada X,Y
Fin de Algoritmo (Bresenham)
Código:
void Bres(int x0,int y0,int xFin,int yFin)
{
int dx = fabs(xFin - x0),
dy = fabs(yFin - y0);
int p = 2 * dy - dx;
int dosDy = 2 * dy,
dosDyMenosDx = 2 * (dy - dx);
int x, y;
/* Determinamos que punto usamos como inicio. */
if (x0 > xFin) {
x = xFin;
y = yFin;
xFin = x0;
}
else {
x = x0;
y = y0;
}
setPixel (x, y);
while (x <>
x++;
if (p <>
p += dosDy;
else {
y++;
p += dosDyMenosDx;
}
setPixel (x, y);
}
}
miércoles, 13 de noviembre de 2013
Conceptos Unidad III
Tecnicas de sombreado clásicas y avanzadas
Clasicas: iluminación local
OpenGL calcula la iluminación en cada vértice, y obtiene una terna rgb que se usará para dar color a los polígonos o aristas. El valor obtenido en cada vértice es la suma de cinco componentes:
Emisión (E)
Luz ambiental global (A1)
Luz ambiental específica del polígono (A2)
Reflexión difusa (D)
Reflexión especular (S)
La formula final es la suma de todos los términos anteriores:
I = E + A1 + A2 + D + S
OpenGL calcula el valor de I para cada vértice del modelo, y usa esos colores para asignar un color a todos los pixeles.
En general, I depende de las características de las fuentes de luz definidas y las características del material asignado a los polígonos que se dibujen.
En adelante, una terna RGB o color es un conjunto de tres valores reales entre cero y uno, ambos incluidos.
Posterior relleno de triangulos.
Para ello se realizan varias fases de procesamiento por Pixel. Comprobar si cada nuevo pixel es visible o no (comprobación de profundidad).
Interpolación lineal del color para el nuevo pixel (método de Gouraud).
Si existe una textura definida o transparencia, efectuar la modificación de color correspondiente.
En esta etapa se trata de asignar colores a los pixeles correspondientes al interior de cada triángulo proyectado que cae dentro del área de visualización.
Renderizado en tiempo real.
La idea fundamental del procesado en tiempo real es que todos los objetos deben ser descompuestos en polígonos. Estos polígonos serán descompuestos a su vez en triangulos. Cada triangulo será proyectado sobre la ventana bidimensional y rellenado con los colores adecuados para reflejar los efectos de la iluminación, texturas, etc. Una vez se han generado los triangulos, en la pipeline existen dos partes claramente diferenciadas: una primera etapa operaciones realizadas sobre cada uno de los vértices, y después de que estos se proyecten sobre la ventana, entonces comienza una segunda fase de cálculos realizados para cada pixel cubierto por los triangulos.
Realistas: iluminacion global.
Trazado de rayos.
El trazado de rayos computa la interacción de la luz desde un punto de vista determinado y es particularmente adecuado para superficies reflectantes. Puede utilizarse como propiedad especifica de un determinado material.
Radiosidad.
En el estado inicial la escena consta de dos tipos de objetos: objetos que emiten luz y objetos que reciben luz. A partir de aquí, en una primera vuelta, se computa la luz que recibe cada objeto en una aproximación mas exacta, cada parte de un objeto, según una subdivisión cuya densidad puede precisarse en sucesivas aproximaciones. Cada una de estas partes, según su grado de reflexividad, su orientación y su distancia con respecto a las fuentes de luz original, se convertirá en una segunda vuelta, en un nuevo emisor de energía lumínica, una fuente de luz secundaria que iluminara a su vez a los objetos que le rodean.
Calculos de iluminacion por pixel.
La iluminación por píxel en tiempo real es una tecnología revolucionaria ofrecida como primicia por NVIDIA Shading Rasterizer. La iluminación dinámica a nivel de píxel libera a los desarrolladores de las restricciones de otros sistemas de iluminación y pone a su alcance toda una gama de sofisticados efectos.
Alto acabado.
Sombreado Constante o plano. Un cálculo para todo el polígono. Obtenemos una intensidad que aplicamos a un conjunto de puntos de un objeto (p.ej. todo un triángulo). El polígono representa una superficie plana real del objeto que se modela y no es una aproximación de un objeto curvo.
Sombreado constante o plano.
Un calculo para todo el poligono.
Obtenemos una intensidad que aplicamos a un conjunto de puntos de un objeto (p.ej. todo un triángulo)
El polígono representa una superficie plana real del objeto que se modela y no es una aproximación de un objeto curvo.
Interpolacion de Intensidades (Gouraud).
Se basa en la interpolación de intensidad o color.
Considera que facetas planas vecinas proceden de aproximar una superficie curva
* Elimina en gran medida las discontinuidades de iluminación
* Es sencilla, pero produce peores resultados en objetos con brillos especulares que el método de Phong.
*Implementado en OpenGL
Calcula normales al poligono.
La iluminación cte. no produce buenos resultados en superficies curvas (aprox. por facetas planas).
Evaluar la ecuación de iluminación en cada punto de una superficie genérica es muy costoso. Posible solución: aproximar mediante facetas planas e interpolar dentro de cada polígono. Hay que evitar producir una apariencia “faceteada” (bandas de Mach; respuesta del ojo humano).
interpolacion de normales (PHONG)
Se basa en la interpolación de la dirección de la normal, calculada de la misma forma que antes. Igual que en Gouraud, se interpola a lo largo de cada línea de barrido, entre los puntos inicial y final, interpolados a su vez de los valores de los vértices de la arista. Captura mejor los brillos especulares en el medio de facetas planas. Si el coeficiente de reflexión especular es pequeño, los resultados no difieren tanto.
Raytracing
El raytracing o trazado de rayos es un algoritmo para síntesis de imágenes tridimensionales.
En el algoritmo Ray Casting se determinan las superficies visibles en la escena que se quiere sintetizar trazando rayos desde el observador (cámara) hasta la escena a través del plano de la imagen. Se calculan las intersecciones del rayo con los diferentes objetos de la escena y aquella intersección que esté más cerca del observador determina cuál es el objeto visible.
Buffer de profundidad
El Z-Buffer se basa en que al generar la posición de un punto en la pantalla la computadora reserve una zona de memoria especial, llamada Z-Buffer, información relacionada con la profundidad del punto que ocupa en la escena representada. Cuando el ordenador representa un nuevo punto consulta el Z-Buffer del píxel que corresponde en pantalla. Si el valor que ya existe en el píxel es mayor que el que posee el nuevo punto, el sistema asume que este último es el visible y lo sustituye en la memoria del Z- Buffer.
Buffer stencill
Stencill Buffer es una memoria intermedia que analiza y actualiza píxeles junto con “depth buffer” o buffer de profundidad. Añade planos de bits adicionales para cada píxel además de los bits de color y profundidad.
Stencil buffer es similar al buffer de profundidad en que los dos son colección de planos de bit que no se pueden mostrar.
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.
Luz ambiente
La luz ambiente ilumina por igual todas las zonas en sombra para simular el efecto de interacción entre objetos que hace que las partes en sombra de los objetos queden parcialmente iluminadas. Esta iluminación uniforme se llama luz ambiente. Si se sigue este segundo enfoque, se puede postular una intensidad ambiente en cada punto del ambiente.
Spotlights
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.
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, una computación que es una parte significativa del cálculo del sombreado. Sin embargo, si la fuente de luz está lejos de la superficie.
intensidad completa
La intensidad completa exclusivamente Por efectos de iluminación es la siguiente:
Clasicas: iluminación local
OpenGL calcula la iluminación en cada vértice, y obtiene una terna rgb que se usará para dar color a los polígonos o aristas. El valor obtenido en cada vértice es la suma de cinco componentes:
Emisión (E)
Luz ambiental global (A1)
Luz ambiental específica del polígono (A2)
Reflexión difusa (D)
Reflexión especular (S)
La formula final es la suma de todos los términos anteriores:
I = E + A1 + A2 + D + S
OpenGL calcula el valor de I para cada vértice del modelo, y usa esos colores para asignar un color a todos los pixeles.
En general, I depende de las características de las fuentes de luz definidas y las características del material asignado a los polígonos que se dibujen.
En adelante, una terna RGB o color es un conjunto de tres valores reales entre cero y uno, ambos incluidos.
Posterior relleno de triangulos.
Para ello se realizan varias fases de procesamiento por Pixel. Comprobar si cada nuevo pixel es visible o no (comprobación de profundidad).
Interpolación lineal del color para el nuevo pixel (método de Gouraud).
Si existe una textura definida o transparencia, efectuar la modificación de color correspondiente.
En esta etapa se trata de asignar colores a los pixeles correspondientes al interior de cada triángulo proyectado que cae dentro del área de visualización.
Renderizado en tiempo real.
La idea fundamental del procesado en tiempo real es que todos los objetos deben ser descompuestos en polígonos. Estos polígonos serán descompuestos a su vez en triangulos. Cada triangulo será proyectado sobre la ventana bidimensional y rellenado con los colores adecuados para reflejar los efectos de la iluminación, texturas, etc. Una vez se han generado los triangulos, en la pipeline existen dos partes claramente diferenciadas: una primera etapa operaciones realizadas sobre cada uno de los vértices, y después de que estos se proyecten sobre la ventana, entonces comienza una segunda fase de cálculos realizados para cada pixel cubierto por los triangulos.
Realistas: iluminacion global.
Trazado de rayos.
El trazado de rayos computa la interacción de la luz desde un punto de vista determinado y es particularmente adecuado para superficies reflectantes. Puede utilizarse como propiedad especifica de un determinado material.
Radiosidad.
En el estado inicial la escena consta de dos tipos de objetos: objetos que emiten luz y objetos que reciben luz. A partir de aquí, en una primera vuelta, se computa la luz que recibe cada objeto en una aproximación mas exacta, cada parte de un objeto, según una subdivisión cuya densidad puede precisarse en sucesivas aproximaciones. Cada una de estas partes, según su grado de reflexividad, su orientación y su distancia con respecto a las fuentes de luz original, se convertirá en una segunda vuelta, en un nuevo emisor de energía lumínica, una fuente de luz secundaria que iluminara a su vez a los objetos que le rodean.
Calculos de iluminacion por pixel.
La iluminación por píxel en tiempo real es una tecnología revolucionaria ofrecida como primicia por NVIDIA Shading Rasterizer. La iluminación dinámica a nivel de píxel libera a los desarrolladores de las restricciones de otros sistemas de iluminación y pone a su alcance toda una gama de sofisticados efectos.
Alto acabado.
Sombreado Constante o plano. Un cálculo para todo el polígono. Obtenemos una intensidad que aplicamos a un conjunto de puntos de un objeto (p.ej. todo un triángulo). El polígono representa una superficie plana real del objeto que se modela y no es una aproximación de un objeto curvo.
Sombreado constante o plano.
Un calculo para todo el poligono.
Obtenemos una intensidad que aplicamos a un conjunto de puntos de un objeto (p.ej. todo un triángulo)
El polígono representa una superficie plana real del objeto que se modela y no es una aproximación de un objeto curvo.
Interpolacion de Intensidades (Gouraud).
Se basa en la interpolación de intensidad o color.
Considera que facetas planas vecinas proceden de aproximar una superficie curva
* Elimina en gran medida las discontinuidades de iluminación
* Es sencilla, pero produce peores resultados en objetos con brillos especulares que el método de Phong.
*Implementado en OpenGL
Calcula normales al poligono.
La iluminación cte. no produce buenos resultados en superficies curvas (aprox. por facetas planas).
Evaluar la ecuación de iluminación en cada punto de una superficie genérica es muy costoso. Posible solución: aproximar mediante facetas planas e interpolar dentro de cada polígono. Hay que evitar producir una apariencia “faceteada” (bandas de Mach; respuesta del ojo humano).
Se basa en la interpolación de la dirección de la normal, calculada de la misma forma que antes. Igual que en Gouraud, se interpola a lo largo de cada línea de barrido, entre los puntos inicial y final, interpolados a su vez de los valores de los vértices de la arista. Captura mejor los brillos especulares en el medio de facetas planas. Si el coeficiente de reflexión especular es pequeño, los resultados no difieren tanto.
Raytracing
El raytracing o trazado de rayos es un algoritmo para síntesis de imágenes tridimensionales.
En el algoritmo Ray Casting se determinan las superficies visibles en la escena que se quiere sintetizar trazando rayos desde el observador (cámara) hasta la escena a través del plano de la imagen. Se calculan las intersecciones del rayo con los diferentes objetos de la escena y aquella intersección que esté más cerca del observador determina cuál es el objeto visible.
Buffer de profundidad
El Z-Buffer se basa en que al generar la posición de un punto en la pantalla la computadora reserve una zona de memoria especial, llamada Z-Buffer, información relacionada con la profundidad del punto que ocupa en la escena representada. Cuando el ordenador representa un nuevo punto consulta el Z-Buffer del píxel que corresponde en pantalla. Si el valor que ya existe en el píxel es mayor que el que posee el nuevo punto, el sistema asume que este último es el visible y lo sustituye en la memoria del Z- Buffer.
Buffer stencill
Stencill Buffer es una memoria intermedia que analiza y actualiza píxeles junto con “depth buffer” o buffer de profundidad. Añade planos de bits adicionales para cada píxel además de los bits de color y profundidad.
Stencil buffer es similar al buffer de profundidad en que los dos son colección de planos de bit que no se pueden mostrar.
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.
Luz ambiente
La luz ambiente ilumina por igual todas las zonas en sombra para simular el efecto de interacción entre objetos que hace que las partes en sombra de los objetos queden parcialmente iluminadas. Esta iluminación uniforme se llama luz ambiente. Si se sigue este segundo enfoque, se puede postular una intensidad ambiente en cada punto del ambiente.
Spotlights
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.
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, una computación que es una parte significativa del cálculo del sombreado. Sin embargo, si la fuente de luz está lejos de la superficie.
intensidad completa
La intensidad completa exclusivamente Por efectos de iluminación es la siguiente:
martes, 29 de octubre de 2013
viernes, 25 de octubre de 2013
jueves, 17 de octubre de 2013
Cubo Rubick
// cubo rubick.cpp: define el punto de entrada de la aplicación de consola.
//
#include "stdafx.h"
#include <stdlib.h>
#include <GL/glut.h>
GLfloat escala = 1.25f;
GLfloat angulo = 0.0f;
GLfloat angulo1 = 0.0f;
void reshape(int width, int height)
{
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-10,20,-4,10,-8,5);
glMatrixMode(GL_MODELVIEW);
}
void display(){
glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
angulo-=0.0f;
glRotatef(angulo, 1.0f, 0.0f, 0.0f);
glRotatef(angulo1, 0.0f, 1.0f, 0.0f);
glTranslatef(-5.5f,-1.5f,1.5f);
//cara frontal
//hilera 1
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,0);
glVertex3f(5,0,0);
glVertex3f(5,1,0);
glVertex3f(4,1,0);
glEnd();
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(5,0,0);
glVertex3f(6,0,0);
glVertex3f(6,1,0);
glVertex3f(5,1,0);
glEnd();
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(6,0,0);
glVertex3f(7,0,0);
glVertex3f(7,1,0);
glVertex3f(6,1,0);
glEnd();
//hilera2
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(4,1,0);
glVertex3f(5,1,0);
glVertex3f(5,2,0);
glVertex3f(4,2,0);
glEnd();
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(5,1,0);
glVertex3f(6,1,0);
glVertex3f(6,2,0);
glVertex3f(5,2,0);
glEnd();
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(6,1,0);
glVertex3f(7,1,0);
glVertex3f(7,2,0);
glVertex3f(6,2,0);
glEnd();
//hilera3
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(4,2,0);
glVertex3f(5,2,0);
glVertex3f(5,3,0);
glVertex3f(4,3,0);
glEnd();
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(5,2,0);
glVertex3f(6,2,0);
glVertex3f(6,3,0);
glVertex3f(5,3,0);
glEnd();
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(6,2,0);
glVertex3f(7,2,0);
glVertex3f(7,3,0);
glVertex3f(6,3,0);
glEnd();
//cara superior
//hilera1
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(4,3,0);
glVertex3f(5,3,0);
glVertex3f(5,3,-1);
glVertex3f(4,3,-1);
glEnd();
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(5,3,0);
glVertex3f(6,3,0);
glVertex3f(6,3,-1);
glVertex3f(5,3,-1);
glEnd();
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(6,3,0);
glVertex3f(7,3,0);
glVertex3f(7,3,-1);
glVertex3f(6,3,-1);
glEnd();
//hilera2
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(4,3,-1);
glVertex3f(5,3,-1);
glVertex3f(5,3,-2);
glVertex3f(4,3,-2);
glEnd();
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(5,3,-1);
glVertex3f(6,3,-1);
glVertex3f(6,3,-2);
glVertex3f(5,3,-2);
glEnd();
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(6,3,-1);
glVertex3f(7,3,-1);
glVertex3f(7,3,-2);
glVertex3f(6,3,-2);
glEnd();
//hilera3
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(4,3,-2);
glVertex3f(5,3,-2);
glVertex3f(5,3,-3);
glVertex3f(4,3,-3);
glEnd();
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(5,3,-2);
glVertex3f(6,3,-2);
glVertex3f(6,3,-3);
glVertex3f(5,3,-3);
glEnd();
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(6,3,-2);
glVertex3f(7,3,-2);
glVertex3f(7,3,-3);
glVertex3f(6,3,-3);
glEnd();
//cara posterior
//hilera1
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,-3);
glVertex3f(5,0,-3);
glVertex3f(5,1,-3);
glVertex3f(4,1,-3);
glEnd();
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(5,0,-3);
glVertex3f(6,0,-3);
glVertex3f(6,1,-3);
glVertex3f(5,1,-3);
glEnd();
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(6,0,-3);
glVertex3f(7,0,-3);
glVertex3f(7,1,-3);
glVertex3f(6,1,-3);
glEnd();
//hilera2
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(4,1,-3);
glVertex3f(5,1,-3);
glVertex3f(5,2,-3);
glVertex3f(4,2,-3);
glEnd();
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(5,1,-3);
glVertex3f(6,1,-3);
glVertex3f(6,2,-3);
glVertex3f(5,2,-3);
glEnd();
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(6,1,-3);
glVertex3f(7,1,-3);
glVertex3f(7,2,-3);
glVertex3f(6,2,-3);
glEnd();
//hilera3
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(4,2,-3);
glVertex3f(5,2,-3);
glVertex3f(5,3,-3);
glVertex3f(4,3,-3);
glEnd();
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(5,2,-3);
glVertex3f(6,2,-3);
glVertex3f(6,3,-3);
glVertex3f(5,3,-3);
glEnd();
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(6,2,-3);
glVertex3f(7,2,-3);
glVertex3f(7,3,-3);
glVertex3f(6,3,-3);
glEnd();
//cara inferior
//hilera1
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,0);
glVertex3f(5,0,0);
glVertex3f(5,0,-1);
glVertex3f(4,0,-1);
glEnd();
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(5,0,0);
glVertex3f(6,0,0);
glVertex3f(6,0,-1);
glVertex3f(5,0,-1);
glEnd();
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(6,0,0);
glVertex3f(7,0,0);
glVertex3f(7,0,-1);
glVertex3f(6,0,-1);
glEnd();
//hilera2
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,-1);
glVertex3f(5,0,-1);
glVertex3f(5,0,-2);
glVertex3f(4,0,-2);
glEnd();
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(5,0,-1);
glVertex3f(6,0,-1);
glVertex3f(6,0,-2);
glVertex3f(5,0,-2);
glEnd();
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(6,0,-1);
glVertex3f(7,0,-1);
glVertex3f(7,0,-2);
glVertex3f(6,0,-2);
glEnd();
//hilera3
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,-2);
glVertex3f(5,0,-2);
glVertex3f(5,0,-3);
glVertex3f(4,0,-3);
glEnd();
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(5,0,-2);
glVertex3f(6,0,-2);
glVertex3f(6,0,-3);
glVertex3f(5,0,-3);
glEnd();
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(6,0,-2);
glVertex3f(7,0,-2);
glVertex3f(7,0,-3);
glVertex3f(6,0,-3);
glEnd();
//cara derecha
//hilera 1
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,0,0);
glVertex3f(7,0,-1);
glVertex3f(7,1,-1);
glVertex3f(7,1,0);
glEnd();
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,0,-1);
glVertex3f(7,0,-2);
glVertex3f(7,1,-2);
glVertex3f(7,1,-1);
glEnd();
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,0,-2);
glVertex3f(7,0,-3);
glVertex3f(7,1,-3);
glVertex3f(7,1,-2);
glEnd();
//hilera2
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,1,0);
glVertex3f(7,1,-1);
glVertex3f(7,2,-1);
glVertex3f(7,2,-0);
glEnd();
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,1,-1);
glVertex3f(7,1,-2);
glVertex3f(7,2,-2);
glVertex3f(7,2,-1);
glEnd();
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,1,-2);
glVertex3f(7,1,-3);
glVertex3f(7,2,-3);
glVertex3f(7,2,-2);
glEnd();
//hilera3
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,2,0);
glVertex3f(7,2,-1);
glVertex3f(7,3,-1);
glVertex3f(7,3,0);
glEnd();
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,2,-1);
glVertex3f(7,2,-2);
glVertex3f(7,3,-2);
glVertex3f(7,3,-1);
glEnd();
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,2,-2);
glVertex3f(7,2,-3);
glVertex3f(7,3,-3);
glVertex3f(7,3,-2);
glEnd();
//cara izquierda
//hilera 1
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,0);
glVertex3f(4,0,-1);
glVertex3f(4,1,-1);
glVertex3f(4,1,0);
glEnd();
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,-1);
glVertex3f(4,0,-2);
glVertex3f(4,1,-2);
glVertex3f(4,1,-1);
glEnd();
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,-2);
glVertex3f(4,0,-3);
glVertex3f(4,1,-3);
glVertex3f(4,1,-2);
glEnd();
//hilera2
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,1,0);
glVertex3f(4,1,-1);
glVertex3f(4,2,-1);
glVertex3f(4,2,-0);
glEnd();
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,1,-1);
glVertex3f(4,1,-2);
glVertex3f(4,2,-2);
glVertex3f(4,2,-1);
glEnd();
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,1,-2);
glVertex3f(4,1,-3);
glVertex3f(4,2,-3);
glVertex3f(4,2,-2);
glEnd();
//hilera3
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,2,0);
glVertex3f(4,2,-1);
glVertex3f(4,3,-1);
glVertex3f(4,3,0);
glEnd();
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,2,-1);
glVertex3f(4,2,-2);
glVertex3f(4,3,-2);
glVertex3f(4,3,-1);
glEnd();
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,2,-2);
glVertex3f(4,2,-3);
glVertex3f(4,3,-3);
glVertex3f(4,3,-2);
glEnd();
//lineas-----------------------------------------------------------------
//cara frontal
//hilera 1
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,0);
glVertex3f(5,0,0);
glVertex3f(5,1,0);
glVertex3f(4,1,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,0,0);
glVertex3f(6,0,0);
glVertex3f(6,1,0);
glVertex3f(5,1,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,0,0);
glVertex3f(7,0,0);
glVertex3f(7,1,0);
glVertex3f(6,1,0);
glEnd();
//hilera2
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,1,0);
glVertex3f(5,1,0);
glVertex3f(5,2,0);
glVertex3f(4,2,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,1,0);
glVertex3f(6,1,0);
glVertex3f(6,2,0);
glVertex3f(5,2,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,1,0);
glVertex3f(7,1,0);
glVertex3f(7,2,0);
glVertex3f(6,2,0);
glEnd();
//hilera3
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,2,0);
glVertex3f(5,2,0);
glVertex3f(5,3,0);
glVertex3f(4,3,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,2,0);
glVertex3f(6,2,0);
glVertex3f(6,3,0);
glVertex3f(5,3,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,2,0);
glVertex3f(7,2,0);
glVertex3f(7,3,0);
glVertex3f(6,3,0);
glEnd();
//cara superior
//hilera1
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,3,0);
glVertex3f(5,3,0);
glVertex3f(5,3,-1);
glVertex3f(4,3,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,3,0);
glVertex3f(6,3,0);
glVertex3f(6,3,-1);
glVertex3f(5,3,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,3,0);
glVertex3f(7,3,0);
glVertex3f(7,3,-1);
glVertex3f(6,3,-1);
glEnd();
//hilera2
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,3,-1);
glVertex3f(5,3,-1);
glVertex3f(5,3,-2);
glVertex3f(4,3,-2);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,3,-1);
glVertex3f(6,3,-1);
glVertex3f(6,3,-2);
glVertex3f(5,3,-2);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,3,-1);
glVertex3f(7,3,-1);
glVertex3f(7,3,-2);
glVertex3f(6,3,-2);
glEnd();
//hilera3
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,3,-2);
glVertex3f(5,3,-2);
glVertex3f(5,3,-3);
glVertex3f(4,3,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,3,-2);
glVertex3f(6,3,-2);
glVertex3f(6,3,-3);
glVertex3f(5,3,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,3,-2);
glVertex3f(7,3,-2);
glVertex3f(7,3,-3);
glVertex3f(6,3,-3);
glEnd();
//cara posterior
//hilera1
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,-3);
glVertex3f(5,0,-3);
glVertex3f(5,1,-3);
glVertex3f(4,1,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,0,-3);
glVertex3f(6,0,-3);
glVertex3f(6,1,-3);
glVertex3f(5,1,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,0,-3);
glVertex3f(7,0,-3);
glVertex3f(7,1,-3);
glVertex3f(6,1,-3);
glEnd();
//hilera2
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,1,-3);
glVertex3f(5,1,-3);
glVertex3f(5,2,-3);
glVertex3f(4,2,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,1,-3);
glVertex3f(6,1,-3);
glVertex3f(6,2,-3);
glVertex3f(5,2,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,1,-3);
glVertex3f(7,1,-3);
glVertex3f(7,2,-3);
glVertex3f(6,2,-3);
glEnd();
//hilera3
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,2,-3);
glVertex3f(5,2,-3);
glVertex3f(5,3,-3);
glVertex3f(4,3,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,2,-3);
glVertex3f(6,2,-3);
glVertex3f(6,3,-3);
glVertex3f(5,3,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,2,-3);
glVertex3f(7,2,-3);
glVertex3f(7,3,-3);
glVertex3f(6,3,-3);
glEnd();
//cara inferior
//hilera1
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,0);
glVertex3f(5,0,0);
glVertex3f(5,0,-1);
glVertex3f(4,0,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,0,0);
glVertex3f(6,0,0);
glVertex3f(6,0,-1);
glVertex3f(5,0,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,0,0);
glVertex3f(7,0,0);
glVertex3f(7,0,-1);
glVertex3f(6,0,-1);
glEnd();
//hilera2
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,-1);
glVertex3f(5,0,-1);
glVertex3f(5,0,-2);
glVertex3f(4,0,-2);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,0,-1);
glVertex3f(6,0,-1);
glVertex3f(6,0,-2);
glVertex3f(5,0,-2);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,0,-1);
glVertex3f(7,0,-1);
glVertex3f(7,0,-2);
glVertex3f(6,0,-2);
glEnd();
//hilera3
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,-2);
glVertex3f(5,0,-2);
glVertex3f(5,0,-3);
glVertex3f(4,0,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,0,-2);
glVertex3f(6,0,-2);
glVertex3f(6,0,-3);
glVertex3f(5,0,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,0,-2);
glVertex3f(7,0,-2);
glVertex3f(7,0,-3);
glVertex3f(6,0,-3);
glEnd();
//cara derecha
//hilera 1
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,0,0);
glVertex3f(7,0,-1);
glVertex3f(7,1,-1);
glVertex3f(7,1,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,0,-1);
glVertex3f(7,0,-2);
glVertex3f(7,1,-2);
glVertex3f(7,1,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,0,-2);
glVertex3f(7,0,-3);
glVertex3f(7,1,-3);
glVertex3f(7,1,-2);
glEnd();
//hilera2
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,1,0);
glVertex3f(7,1,-1);
glVertex3f(7,2,-1);
glVertex3f(7,2,-0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,1,-1);
glVertex3f(7,1,-2);
glVertex3f(7,2,-2);
glVertex3f(7,2,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,1,-2);
glVertex3f(7,1,-3);
glVertex3f(7,2,-3);
glVertex3f(7,2,-2);
glEnd();
//hilera3
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,2,0);
glVertex3f(7,2,-1);
glVertex3f(7,3,-1);
glVertex3f(7,3,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,2,-1);
glVertex3f(7,2,-2);
glVertex3f(7,3,-2);
glVertex3f(7,3,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,2,-2);
glVertex3f(7,2,-3);
glVertex3f(7,3,-3);
glVertex3f(7,3,-2);
glEnd();
//cara izquierda
//hilera 1
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,0);
glVertex3f(4,0,-1);
glVertex3f(4,1,-1);
glVertex3f(4,1,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,-1);
glVertex3f(4,0,-2);
glVertex3f(4,1,-2);
glVertex3f(4,1,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,-2);
glVertex3f(4,0,-3);
glVertex3f(4,1,-3);
glVertex3f(4,1,-2);
glEnd();
//hilera2
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,1,0);
glVertex3f(4,1,-1);
glVertex3f(4,2,-1);
glVertex3f(4,2,-0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,1,-1);
glVertex3f(4,1,-2);
glVertex3f(4,2,-2);
glVertex3f(4,2,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,1,-2);
glVertex3f(4,1,-3);
glVertex3f(4,2,-3);
glVertex3f(4,2,-2);
glEnd();
//hilera3
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,2,0);
glVertex3f(4,2,-1);
glVertex3f(4,3,-1);
glVertex3f(4,3,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,2,-1);
glVertex3f(4,2,-2);
glVertex3f(4,3,-2);
glVertex3f(4,3,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,2,-2);
glVertex3f(4,2,-3);
glVertex3f(4,3,-3);
glVertex3f(4,3,-2);
glEnd();
glFlush();
glutSwapBuffers();
}
void idle()
{
display();
}
void init()
{
glClearColor(0,0,0,0);
}
void handleSpecialKeypress(int key, int x, int y) {
switch (key) {
case GLUT_KEY_UP:
angulo-=10.0f;
glRotatef(angulo, 1.0f, 0.0f, 0.0f);
break;
case GLUT_KEY_DOWN:
angulo+=10.0f;
glRotatef(angulo, 1.0f, 0.0f, 0.0f);
break;
case GLUT_KEY_LEFT:
angulo1-=10.0f;
glRotatef(angulo1, 0.0f, 1.0f, 0.0f);
break;
case GLUT_KEY_RIGHT:
angulo1+=10.0f;
glRotatef(angulo1, 0.0f, 1.0f, 0.0f);
break;
}
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowPosition(500,60);
glutInitWindowSize(600,500);
glutCreateWindow("Cubo Rubick");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glEnable(GL_DEPTH_TEST);
glutIdleFunc(idle);
glutSpecialFunc(handleSpecialKeypress);
glutMainLoop();
}
//
#include "stdafx.h"
#include <stdlib.h>
#include <GL/glut.h>
GLfloat escala = 1.25f;
GLfloat angulo = 0.0f;
GLfloat angulo1 = 0.0f;
void reshape(int width, int height)
{
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-10,20,-4,10,-8,5);
glMatrixMode(GL_MODELVIEW);
}
void display(){
glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
angulo-=0.0f;
glRotatef(angulo, 1.0f, 0.0f, 0.0f);
glRotatef(angulo1, 0.0f, 1.0f, 0.0f);
glTranslatef(-5.5f,-1.5f,1.5f);
//cara frontal
//hilera 1
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,0);
glVertex3f(5,0,0);
glVertex3f(5,1,0);
glVertex3f(4,1,0);
glEnd();
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(5,0,0);
glVertex3f(6,0,0);
glVertex3f(6,1,0);
glVertex3f(5,1,0);
glEnd();
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(6,0,0);
glVertex3f(7,0,0);
glVertex3f(7,1,0);
glVertex3f(6,1,0);
glEnd();
//hilera2
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(4,1,0);
glVertex3f(5,1,0);
glVertex3f(5,2,0);
glVertex3f(4,2,0);
glEnd();
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(5,1,0);
glVertex3f(6,1,0);
glVertex3f(6,2,0);
glVertex3f(5,2,0);
glEnd();
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(6,1,0);
glVertex3f(7,1,0);
glVertex3f(7,2,0);
glVertex3f(6,2,0);
glEnd();
//hilera3
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(4,2,0);
glVertex3f(5,2,0);
glVertex3f(5,3,0);
glVertex3f(4,3,0);
glEnd();
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(5,2,0);
glVertex3f(6,2,0);
glVertex3f(6,3,0);
glVertex3f(5,3,0);
glEnd();
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(6,2,0);
glVertex3f(7,2,0);
glVertex3f(7,3,0);
glVertex3f(6,3,0);
glEnd();
//cara superior
//hilera1
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(4,3,0);
glVertex3f(5,3,0);
glVertex3f(5,3,-1);
glVertex3f(4,3,-1);
glEnd();
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(5,3,0);
glVertex3f(6,3,0);
glVertex3f(6,3,-1);
glVertex3f(5,3,-1);
glEnd();
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(6,3,0);
glVertex3f(7,3,0);
glVertex3f(7,3,-1);
glVertex3f(6,3,-1);
glEnd();
//hilera2
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(4,3,-1);
glVertex3f(5,3,-1);
glVertex3f(5,3,-2);
glVertex3f(4,3,-2);
glEnd();
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(5,3,-1);
glVertex3f(6,3,-1);
glVertex3f(6,3,-2);
glVertex3f(5,3,-2);
glEnd();
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(6,3,-1);
glVertex3f(7,3,-1);
glVertex3f(7,3,-2);
glVertex3f(6,3,-2);
glEnd();
//hilera3
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(4,3,-2);
glVertex3f(5,3,-2);
glVertex3f(5,3,-3);
glVertex3f(4,3,-3);
glEnd();
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(5,3,-2);
glVertex3f(6,3,-2);
glVertex3f(6,3,-3);
glVertex3f(5,3,-3);
glEnd();
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(6,3,-2);
glVertex3f(7,3,-2);
glVertex3f(7,3,-3);
glVertex3f(6,3,-3);
glEnd();
//cara posterior
//hilera1
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,-3);
glVertex3f(5,0,-3);
glVertex3f(5,1,-3);
glVertex3f(4,1,-3);
glEnd();
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(5,0,-3);
glVertex3f(6,0,-3);
glVertex3f(6,1,-3);
glVertex3f(5,1,-3);
glEnd();
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(6,0,-3);
glVertex3f(7,0,-3);
glVertex3f(7,1,-3);
glVertex3f(6,1,-3);
glEnd();
//hilera2
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(4,1,-3);
glVertex3f(5,1,-3);
glVertex3f(5,2,-3);
glVertex3f(4,2,-3);
glEnd();
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(5,1,-3);
glVertex3f(6,1,-3);
glVertex3f(6,2,-3);
glVertex3f(5,2,-3);
glEnd();
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(6,1,-3);
glVertex3f(7,1,-3);
glVertex3f(7,2,-3);
glVertex3f(6,2,-3);
glEnd();
//hilera3
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(4,2,-3);
glVertex3f(5,2,-3);
glVertex3f(5,3,-3);
glVertex3f(4,3,-3);
glEnd();
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(5,2,-3);
glVertex3f(6,2,-3);
glVertex3f(6,3,-3);
glVertex3f(5,3,-3);
glEnd();
glColor3f(1,.5,0);
glBegin(GL_POLYGON);
glVertex3f(6,2,-3);
glVertex3f(7,2,-3);
glVertex3f(7,3,-3);
glVertex3f(6,3,-3);
glEnd();
//cara inferior
//hilera1
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,0);
glVertex3f(5,0,0);
glVertex3f(5,0,-1);
glVertex3f(4,0,-1);
glEnd();
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(5,0,0);
glVertex3f(6,0,0);
glVertex3f(6,0,-1);
glVertex3f(5,0,-1);
glEnd();
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(6,0,0);
glVertex3f(7,0,0);
glVertex3f(7,0,-1);
glVertex3f(6,0,-1);
glEnd();
//hilera2
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,-1);
glVertex3f(5,0,-1);
glVertex3f(5,0,-2);
glVertex3f(4,0,-2);
glEnd();
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(5,0,-1);
glVertex3f(6,0,-1);
glVertex3f(6,0,-2);
glVertex3f(5,0,-2);
glEnd();
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(6,0,-1);
glVertex3f(7,0,-1);
glVertex3f(7,0,-2);
glVertex3f(6,0,-2);
glEnd();
//hilera3
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,-2);
glVertex3f(5,0,-2);
glVertex3f(5,0,-3);
glVertex3f(4,0,-3);
glEnd();
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(5,0,-2);
glVertex3f(6,0,-2);
glVertex3f(6,0,-3);
glVertex3f(5,0,-3);
glEnd();
glColor3f(1,1,0);
glBegin(GL_POLYGON);
glVertex3f(6,0,-2);
glVertex3f(7,0,-2);
glVertex3f(7,0,-3);
glVertex3f(6,0,-3);
glEnd();
//cara derecha
//hilera 1
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,0,0);
glVertex3f(7,0,-1);
glVertex3f(7,1,-1);
glVertex3f(7,1,0);
glEnd();
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,0,-1);
glVertex3f(7,0,-2);
glVertex3f(7,1,-2);
glVertex3f(7,1,-1);
glEnd();
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,0,-2);
glVertex3f(7,0,-3);
glVertex3f(7,1,-3);
glVertex3f(7,1,-2);
glEnd();
//hilera2
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,1,0);
glVertex3f(7,1,-1);
glVertex3f(7,2,-1);
glVertex3f(7,2,-0);
glEnd();
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,1,-1);
glVertex3f(7,1,-2);
glVertex3f(7,2,-2);
glVertex3f(7,2,-1);
glEnd();
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,1,-2);
glVertex3f(7,1,-3);
glVertex3f(7,2,-3);
glVertex3f(7,2,-2);
glEnd();
//hilera3
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,2,0);
glVertex3f(7,2,-1);
glVertex3f(7,3,-1);
glVertex3f(7,3,0);
glEnd();
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,2,-1);
glVertex3f(7,2,-2);
glVertex3f(7,3,-2);
glVertex3f(7,3,-1);
glEnd();
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,2,-2);
glVertex3f(7,2,-3);
glVertex3f(7,3,-3);
glVertex3f(7,3,-2);
glEnd();
//cara izquierda
//hilera 1
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,0);
glVertex3f(4,0,-1);
glVertex3f(4,1,-1);
glVertex3f(4,1,0);
glEnd();
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,-1);
glVertex3f(4,0,-2);
glVertex3f(4,1,-2);
glVertex3f(4,1,-1);
glEnd();
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,0,-2);
glVertex3f(4,0,-3);
glVertex3f(4,1,-3);
glVertex3f(4,1,-2);
glEnd();
//hilera2
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,1,0);
glVertex3f(4,1,-1);
glVertex3f(4,2,-1);
glVertex3f(4,2,-0);
glEnd();
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,1,-1);
glVertex3f(4,1,-2);
glVertex3f(4,2,-2);
glVertex3f(4,2,-1);
glEnd();
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,1,-2);
glVertex3f(4,1,-3);
glVertex3f(4,2,-3);
glVertex3f(4,2,-2);
glEnd();
//hilera3
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,2,0);
glVertex3f(4,2,-1);
glVertex3f(4,3,-1);
glVertex3f(4,3,0);
glEnd();
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,2,-1);
glVertex3f(4,2,-2);
glVertex3f(4,3,-2);
glVertex3f(4,3,-1);
glEnd();
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(4,2,-2);
glVertex3f(4,2,-3);
glVertex3f(4,3,-3);
glVertex3f(4,3,-2);
glEnd();
//lineas-----------------------------------------------------------------
//cara frontal
//hilera 1
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,0);
glVertex3f(5,0,0);
glVertex3f(5,1,0);
glVertex3f(4,1,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,0,0);
glVertex3f(6,0,0);
glVertex3f(6,1,0);
glVertex3f(5,1,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,0,0);
glVertex3f(7,0,0);
glVertex3f(7,1,0);
glVertex3f(6,1,0);
glEnd();
//hilera2
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,1,0);
glVertex3f(5,1,0);
glVertex3f(5,2,0);
glVertex3f(4,2,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,1,0);
glVertex3f(6,1,0);
glVertex3f(6,2,0);
glVertex3f(5,2,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,1,0);
glVertex3f(7,1,0);
glVertex3f(7,2,0);
glVertex3f(6,2,0);
glEnd();
//hilera3
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,2,0);
glVertex3f(5,2,0);
glVertex3f(5,3,0);
glVertex3f(4,3,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,2,0);
glVertex3f(6,2,0);
glVertex3f(6,3,0);
glVertex3f(5,3,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,2,0);
glVertex3f(7,2,0);
glVertex3f(7,3,0);
glVertex3f(6,3,0);
glEnd();
//cara superior
//hilera1
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,3,0);
glVertex3f(5,3,0);
glVertex3f(5,3,-1);
glVertex3f(4,3,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,3,0);
glVertex3f(6,3,0);
glVertex3f(6,3,-1);
glVertex3f(5,3,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,3,0);
glVertex3f(7,3,0);
glVertex3f(7,3,-1);
glVertex3f(6,3,-1);
glEnd();
//hilera2
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,3,-1);
glVertex3f(5,3,-1);
glVertex3f(5,3,-2);
glVertex3f(4,3,-2);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,3,-1);
glVertex3f(6,3,-1);
glVertex3f(6,3,-2);
glVertex3f(5,3,-2);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,3,-1);
glVertex3f(7,3,-1);
glVertex3f(7,3,-2);
glVertex3f(6,3,-2);
glEnd();
//hilera3
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,3,-2);
glVertex3f(5,3,-2);
glVertex3f(5,3,-3);
glVertex3f(4,3,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,3,-2);
glVertex3f(6,3,-2);
glVertex3f(6,3,-3);
glVertex3f(5,3,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,3,-2);
glVertex3f(7,3,-2);
glVertex3f(7,3,-3);
glVertex3f(6,3,-3);
glEnd();
//cara posterior
//hilera1
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,-3);
glVertex3f(5,0,-3);
glVertex3f(5,1,-3);
glVertex3f(4,1,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,0,-3);
glVertex3f(6,0,-3);
glVertex3f(6,1,-3);
glVertex3f(5,1,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,0,-3);
glVertex3f(7,0,-3);
glVertex3f(7,1,-3);
glVertex3f(6,1,-3);
glEnd();
//hilera2
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,1,-3);
glVertex3f(5,1,-3);
glVertex3f(5,2,-3);
glVertex3f(4,2,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,1,-3);
glVertex3f(6,1,-3);
glVertex3f(6,2,-3);
glVertex3f(5,2,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,1,-3);
glVertex3f(7,1,-3);
glVertex3f(7,2,-3);
glVertex3f(6,2,-3);
glEnd();
//hilera3
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,2,-3);
glVertex3f(5,2,-3);
glVertex3f(5,3,-3);
glVertex3f(4,3,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,2,-3);
glVertex3f(6,2,-3);
glVertex3f(6,3,-3);
glVertex3f(5,3,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,2,-3);
glVertex3f(7,2,-3);
glVertex3f(7,3,-3);
glVertex3f(6,3,-3);
glEnd();
//cara inferior
//hilera1
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,0);
glVertex3f(5,0,0);
glVertex3f(5,0,-1);
glVertex3f(4,0,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,0,0);
glVertex3f(6,0,0);
glVertex3f(6,0,-1);
glVertex3f(5,0,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,0,0);
glVertex3f(7,0,0);
glVertex3f(7,0,-1);
glVertex3f(6,0,-1);
glEnd();
//hilera2
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,-1);
glVertex3f(5,0,-1);
glVertex3f(5,0,-2);
glVertex3f(4,0,-2);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,0,-1);
glVertex3f(6,0,-1);
glVertex3f(6,0,-2);
glVertex3f(5,0,-2);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,0,-1);
glVertex3f(7,0,-1);
glVertex3f(7,0,-2);
glVertex3f(6,0,-2);
glEnd();
//hilera3
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,-2);
glVertex3f(5,0,-2);
glVertex3f(5,0,-3);
glVertex3f(4,0,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(5,0,-2);
glVertex3f(6,0,-2);
glVertex3f(6,0,-3);
glVertex3f(5,0,-3);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(6,0,-2);
glVertex3f(7,0,-2);
glVertex3f(7,0,-3);
glVertex3f(6,0,-3);
glEnd();
//cara derecha
//hilera 1
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,0,0);
glVertex3f(7,0,-1);
glVertex3f(7,1,-1);
glVertex3f(7,1,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,0,-1);
glVertex3f(7,0,-2);
glVertex3f(7,1,-2);
glVertex3f(7,1,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,0,-2);
glVertex3f(7,0,-3);
glVertex3f(7,1,-3);
glVertex3f(7,1,-2);
glEnd();
//hilera2
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,1,0);
glVertex3f(7,1,-1);
glVertex3f(7,2,-1);
glVertex3f(7,2,-0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,1,-1);
glVertex3f(7,1,-2);
glVertex3f(7,2,-2);
glVertex3f(7,2,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,1,-2);
glVertex3f(7,1,-3);
glVertex3f(7,2,-3);
glVertex3f(7,2,-2);
glEnd();
//hilera3
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,2,0);
glVertex3f(7,2,-1);
glVertex3f(7,3,-1);
glVertex3f(7,3,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,2,-1);
glVertex3f(7,2,-2);
glVertex3f(7,3,-2);
glVertex3f(7,3,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(7,2,-2);
glVertex3f(7,2,-3);
glVertex3f(7,3,-3);
glVertex3f(7,3,-2);
glEnd();
//cara izquierda
//hilera 1
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,0);
glVertex3f(4,0,-1);
glVertex3f(4,1,-1);
glVertex3f(4,1,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,-1);
glVertex3f(4,0,-2);
glVertex3f(4,1,-2);
glVertex3f(4,1,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,0,-2);
glVertex3f(4,0,-3);
glVertex3f(4,1,-3);
glVertex3f(4,1,-2);
glEnd();
//hilera2
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,1,0);
glVertex3f(4,1,-1);
glVertex3f(4,2,-1);
glVertex3f(4,2,-0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,1,-1);
glVertex3f(4,1,-2);
glVertex3f(4,2,-2);
glVertex3f(4,2,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,1,-2);
glVertex3f(4,1,-3);
glVertex3f(4,2,-3);
glVertex3f(4,2,-2);
glEnd();
//hilera3
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,2,0);
glVertex3f(4,2,-1);
glVertex3f(4,3,-1);
glVertex3f(4,3,0);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,2,-1);
glVertex3f(4,2,-2);
glVertex3f(4,3,-2);
glVertex3f(4,3,-1);
glEnd();
glColor3f(0,0,0);
glBegin(GL_LINE_LOOP);
glVertex3f(4,2,-2);
glVertex3f(4,2,-3);
glVertex3f(4,3,-3);
glVertex3f(4,3,-2);
glEnd();
glFlush();
glutSwapBuffers();
}
void idle()
{
display();
}
void init()
{
glClearColor(0,0,0,0);
}
void handleSpecialKeypress(int key, int x, int y) {
switch (key) {
case GLUT_KEY_UP:
angulo-=10.0f;
glRotatef(angulo, 1.0f, 0.0f, 0.0f);
break;
case GLUT_KEY_DOWN:
angulo+=10.0f;
glRotatef(angulo, 1.0f, 0.0f, 0.0f);
break;
case GLUT_KEY_LEFT:
angulo1-=10.0f;
glRotatef(angulo1, 0.0f, 1.0f, 0.0f);
break;
case GLUT_KEY_RIGHT:
angulo1+=10.0f;
glRotatef(angulo1, 0.0f, 1.0f, 0.0f);
break;
}
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowPosition(500,60);
glutInitWindowSize(600,500);
glutCreateWindow("Cubo Rubick");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glEnable(GL_DEPTH_TEST);
glutIdleFunc(idle);
glutSpecialFunc(handleSpecialKeypress);
glutMainLoop();
}
lunes, 14 de octubre de 2013
Disney con la pantalla tactil 3d
atraves de la superficie, el algoritmo de Disney crea una percepcion de un bulto en 3D en la superfice tactil sin tener que mover la superficie fisicamente.
"Si podemos artificialmente estirar la piel de un dedo al momento que se desliza por la pantalla tactil, el cerebro sera engañado en el pensamiento que hay un bulto fisico en la pantalla tactil a pesar de quela superficie sea completamente lisa," dice el investigador de Disney Ivan Poupyrev.
Un nuevo algoritmo permite a los
Investigadores de Disney crear un
rendering tactil de funciones y texturas 3D
Durante las pruebas, los investigadores usaron electrovibraciones para modular la friccion entre los dededos deslizandose y la superficie tactil con las fuerzas electrostaticas. Como agregado, los investigadores crearon y validaron un modelo psicofisico que casi simula las fuerzas de friccion percividas por los dedos humanos cuando se deslizan sobre un bulto real.
"Con nuestro algoritmo no tenemos uno o dos efectos, si no el grupo de controles que hacen posible activar los efectos tactiles a un artefacto visual especifico en el momento".
Los investigadores estan presentando su trabajo en el ACM Symposium en las Interfaces de Usuario de Software y Tecnologia esta semana en San Andrews, Escocia
De TG Diario
jueves, 10 de octubre de 2013
MODELADO DE COMPUTADORA (USB)
// USB.cpp: define el punto de entrada de la aplicación de consola.
//
#include "stdafx.h"
#include <stdlib.h>
#include <GL/glut.h>
GLfloat xm= 1.5f;
GLfloat escala = 1.5f;
GLfloat angulo = 0.0f;
void reshape(int width, int height)
{
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-5,20,-4,5,-5,5);
glMatrixMode(GL_MODELVIEW);
}
void display(){
glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
angulo+=0.2f;
glTranslatef(xm,0.0f,0.0f);
glScalef(escala, escala, escala);
glRotatef(angulo, 1.0f, 0.0f, 0.0f);
//CUERPO
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(8,0,0);
glVertex3f(8,2.5,0);
glVertex3f(5,2.5,0);
glVertex3f(5,0,0);
glEnd();
//ENTRADA
glColor3f(0.75,0.75,0.75);
glBegin(GL_POLYGON);
glVertex3f(5.5,2.5,0.0);
glVertex3f(5.5,3.5,0.0);
glVertex3f(7.5,3.5,0.0);
glVertex3f(7.5,2.5,0.0);
glEnd();
//CUADRO DE DATOS
glColor3f(0,0,0);
glBegin(GL_POLYGON);
glVertex3f(5.65,2.75,0.1);
glVertex3f(5.65,3.25,0.1);
glVertex3f(6.35,3.25,0.1);
glVertex3f(6.35,2.75,0.1);
glEnd();
//CUADRO DE VOLTAJE
glColor3f(0,0,0);
glBegin(GL_POLYGON);
glVertex3f(6.55,2.75,0.1);
glVertex3f(6.55,3.25,0.1);
glVertex3f(7.25,3.25,0.1);
glVertex3f(7.25,2.75,0.1);
glEnd();
//FRANJA
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,.2,.1);
glVertex3f(7,2.3,.1);
glVertex3f(6,2.3,.1);
glVertex3f(6,.2,.1);
glEnd();
glFlush();
glutSwapBuffers();
}void idle()
{
display();
}
void init()
{
glClearColor(0,0,0,0);
}
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}
void ArrowKey(int key, int x, int y){
switch (key){
case GLUT_KEY_RIGHT:
if( xm<2.5){xm = xm + 0.2;}
if(xm>0.1 && xm<2){escala = xm;}
break;
case GLUT_KEY_LEFT:
if( xm>-2.5){xm = xm - 0.2;}
if(xm>0.1 && xm<1){escala = xm;}
break;
}
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowPosition(500,60);
glutInitWindowSize(600,500);
glutCreateWindow("USB");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glEnable(GL_DEPTH_TEST);
glutIdleFunc(idle);
glutKeyboardFunc(keyboard);
glutSpecialFunc(ArrowKey);
glutMainLoop();
}
//
#include "stdafx.h"
#include <stdlib.h>
#include <GL/glut.h>
GLfloat xm= 1.5f;
GLfloat escala = 1.5f;
GLfloat angulo = 0.0f;
void reshape(int width, int height)
{
glViewport(0,0,width,height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-5,20,-4,5,-5,5);
glMatrixMode(GL_MODELVIEW);
}
void display(){
glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
angulo+=0.2f;
glTranslatef(xm,0.0f,0.0f);
glScalef(escala, escala, escala);
glRotatef(angulo, 1.0f, 0.0f, 0.0f);
//CUERPO
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(8,0,0);
glVertex3f(8,2.5,0);
glVertex3f(5,2.5,0);
glVertex3f(5,0,0);
glEnd();
//ENTRADA
glColor3f(0.75,0.75,0.75);
glBegin(GL_POLYGON);
glVertex3f(5.5,2.5,0.0);
glVertex3f(5.5,3.5,0.0);
glVertex3f(7.5,3.5,0.0);
glVertex3f(7.5,2.5,0.0);
glEnd();
//CUADRO DE DATOS
glColor3f(0,0,0);
glBegin(GL_POLYGON);
glVertex3f(5.65,2.75,0.1);
glVertex3f(5.65,3.25,0.1);
glVertex3f(6.35,3.25,0.1);
glVertex3f(6.35,2.75,0.1);
glEnd();
//CUADRO DE VOLTAJE
glColor3f(0,0,0);
glBegin(GL_POLYGON);
glVertex3f(6.55,2.75,0.1);
glVertex3f(6.55,3.25,0.1);
glVertex3f(7.25,3.25,0.1);
glVertex3f(7.25,2.75,0.1);
glEnd();
//FRANJA
glColor3f(0,0,1);
glBegin(GL_POLYGON);
glVertex3f(7,.2,.1);
glVertex3f(7,2.3,.1);
glVertex3f(6,2.3,.1);
glVertex3f(6,.2,.1);
glEnd();
glFlush();
glutSwapBuffers();
}void idle()
{
display();
}
void init()
{
glClearColor(0,0,0,0);
}
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}
void ArrowKey(int key, int x, int y){
switch (key){
case GLUT_KEY_RIGHT:
if( xm<2.5){xm = xm + 0.2;}
if(xm>0.1 && xm<2){escala = xm;}
break;
case GLUT_KEY_LEFT:
if( xm>-2.5){xm = xm - 0.2;}
if(xm>0.1 && xm<1){escala = xm;}
break;
}
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
glutInitWindowPosition(500,60);
glutInitWindowSize(600,500);
glutCreateWindow("USB");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glEnable(GL_DEPTH_TEST);
glutIdleFunc(idle);
glutKeyboardFunc(keyboard);
glutSpecialFunc(ArrowKey);
glutMainLoop();
}
Transformaciones en la piramide
Transformaciones geometricas traslacion, rotacion y escalacion en OpenGL
*Traslación: glTranslatef(0.0f, 0.0f, 0.0f); //glTranslatef(unidadesdetrasladoen X, traslado en Y, traslado en Z);
*Rotación: Rota en sentido contrario a las manecillas del reloj. glRotatef(0.0f, 0.0f, 0.0f, 0.0f); //ángulos en grados
*Escalación: Nos permite expandir o contraer los objetos de un vértice. glScalef(0.0f, 0.0f, 0.0f);
*Rotación: Rota en sentido contrario a las manecillas del reloj. glRotatef(0.0f, 0.0f, 0.0f, 0.0f); //ángulos en grados
*Escalación: Nos permite expandir o contraer los objetos de un vértice. glScalef(0.0f, 0.0f, 0.0f);
#include "stdafx.h"
#include <stdlib.h>
#include <GL/glut.h>
GLfloat xm=1.5f;
GLfloat escala = 1.5f;
GLfloat angulo = 0.0f;
void reshape( int width, int height)
{
glViewport(0,0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(1,9,-5,5,-5,5);
glMatrixMode(GL_MODELVIEW);}
void display()
{
glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
angulo+=0.2f;
glTranslatef(xm,0.0f,0.0f);
glScalef(escala, escala, escala);
glRotatef(angulo, 1.0f, 0.0f, 0.0f);
//cara1
glColor3f(1,0,1);
glBegin(GL_TRIANGLES);
glVertex3f(0,0,0);
glVertex3f(1.5,3,0);
glVertex3f(3,0,0);
glEnd();
//cara2
glColor3f(1,0,0);
glBegin(GL_TRIANGLES);
glVertex3f(3,0,0);
glVertex3f(1.5,3,0);
glVertex3f(1.5,0,3);
glEnd();
//cara3
glColor3f(1,1,1);
glBegin(GL_TRIANGLES);
glVertex3f(1.5,3,0);
glVertex3f(1.5,0,3);
glVertex3f(0,0,0);
glEnd();
//BASE
glColor3f(0,1,0);
glBegin(GL_TRIANGLES);
glVertex3f(0,0,0);
glVertex3f(3,0,0);
glVertex3f(1.5,0,3);
glEnd();
glFlush();
glutSwapBuffers();
}
void idle()
{
display();
}
void
init()
{
glClearColor(0,0,0,0);
}
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}
void ArrowKey(int key, int x, int y){
switch (key){
case GLUT_KEY_LEFT:
if( xm<3.0 )
{xm = xm - 0.3;}
if(xm>0.1 && xm<2)
{escala = xm;}
break;
case GLUT_KEY_RIGHT:
if( xm>-3.0 ){xm = xm + 0.3;}
if(xm>0.1 && xm<2){escala = xm;}
break;
}
}
int main (int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(50,50);
glutInitWindowSize(500,500);
glutCreateWindow(
"Piramide");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutKeyboardFunc(keyboard);
glutSpecialFunc(ArrowKey);
glutMainLoop();
}
Piramide 3D
#include "stdafx.h"
#include <GL/glut.h>
void reshape( int width, int height)
{
glViewport(0,0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-4,7,-6,5,-5,5);
glMatrixMode(GL_MODELVIEW);}
void
display()
{
glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity();
//cara1
glColor3f(1,0,1);
glBegin(GL_POLYGON);
glVertex3f(0,0,0);
glVertex3f(1.5,3,0);
glVertex3f(3,0,0);
glEnd();
//cara2
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(3,0,0);
glVertex3f(1.5,3,0);
glVertex3f(1.5,0,3);
glEnd();
//cara3
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(1.5,3,0);
glVertex3f(1.5,0,3);
glVertex3f(0,0,0);
glEnd();
//base
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(0,0,0);
glVertex3f(3,0,0);
glVertex3f(1.5,0,3);
glEnd();
glFlush();
}
void
init()
{
glClearColor(0,0,0,0);
}
int main (int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(50,50);
glutInitWindowSize(500,500);
glutCreateWindow(
"Piramide");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}
#include <GL/glut.h>
void reshape( int width, int height)
{
glViewport(0,0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-4,7,-6,5,-5,5);
glMatrixMode(GL_MODELVIEW);}
void
display()
{
glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity();
//cara1
glColor3f(1,0,1);
glBegin(GL_POLYGON);
glVertex3f(0,0,0);
glVertex3f(1.5,3,0);
glVertex3f(3,0,0);
glEnd();
//cara2
glColor3f(1,0,0);
glBegin(GL_POLYGON);
glVertex3f(3,0,0);
glVertex3f(1.5,3,0);
glVertex3f(1.5,0,3);
glEnd();
//cara3
glColor3f(1,1,1);
glBegin(GL_POLYGON);
glVertex3f(1.5,3,0);
glVertex3f(1.5,0,3);
glVertex3f(0,0,0);
glEnd();
//base
glColor3f(0,1,0);
glBegin(GL_POLYGON);
glVertex3f(0,0,0);
glVertex3f(3,0,0);
glVertex3f(1.5,0,3);
glEnd();
glFlush();
}
void
init()
{
glClearColor(0,0,0,0);
}
int main (int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(50,50);
glutInitWindowSize(500,500);
glutCreateWindow(
"Piramide");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}
Secuencia de las tranformaciones y Pilas
Secuencia de Tranformaciones:
El orden en que se aplican las transformaciones en OpenGL es al contrario de lo que parece intuitivo a primera vista. Por ejemplo:
Primero carga la matriz identidad, luego multiplica por una matriz de translacion y por ultimo una de rotación. El resultado es que primero rota el triangulo y posteriormente lo traslada, esto es debido a que las multiplicaciones las realiza por el lado derecho:
La lectura se realiza de abajo arriba, hasta encontrar una funcion glLoadIdentity o glLoadMatrix. Las transformaciones que haya despues de la primitiva de dibujado glBegin - glEnd no se tienen en cuenta porque la primtiva ya ha sido renderizada.
Pila de Matrices
Ejemplo:
glPushMatrix(); // Guardamos la transformacion del mundo
glTranslatef(cocheX, cocheY, cocheZ);
glRotatef(angulo, ejeX, ejeY, ejeZ);
RenderCarroceria();
glTranslatef(rueda4X, rueda4Y, rueda4Z);
glRotatef(anguloRueda4, eje4X, eje4Y, eje4Z);
RenderRueda();
glPopMatrix();
glPopMatrix(); // Recuperamos la transformacion del mundo
El orden en que se aplican las transformaciones en OpenGL es al contrario de lo que parece intuitivo a primera vista. Por ejemplo:
glLoadIdentity();glTranslatef(0.5, 0.5, 1.0);
glRotatef(45.0, 1.0, 1.0, 1.0)
glBegin(GL_TRIANGLE);glVertex3f(0.0, 0.0, 0.0);glVertex3f(1.0, 0.0, 0.0);
glVertex3f(0.0, 1.0, 0.0);
glEnd();
Primero carga la matriz identidad, luego multiplica por una matriz de translacion y por ultimo una de rotación. El resultado es que primero rota el triangulo y posteriormente lo traslada, esto es debido a que las multiplicaciones las realiza por el lado derecho:
La lectura se realiza de abajo arriba, hasta encontrar una funcion glLoadIdentity o glLoadMatrix. Las transformaciones que haya despues de la primitiva de dibujado glBegin - glEnd no se tienen en cuenta porque la primtiva ya ha sido renderizada.
Pila de Matrices
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
disntintas
funciones.
Para
poder guardar una determinada matriz y posteriormente recuperarla OpenGL
dispone
de las dos funciones comentadas: glPushMatrix() y glPopMatrix().
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. 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().
Figura
1 PushMatrix y PopMatrix
En
la función display() al llamar
a la función glPushMatrix()
se realiza una copia de la
matriz
actual. La traslación en el eje Z se realiza en la matriz superior de la pila,
es decir, en la
copia
de la matriz, de tal forma que al llamar a la función glPopMatrix().
Ejemplo:
glPushMatrix(); // Guardamos la transformacion del mundo
glTranslatef(cocheX, cocheY, cocheZ);
glRotatef(angulo, ejeX, ejeY, ejeZ);
RenderCarroceria();
glPushMatrix(); // Guardamos la transformacion del cocheglPushMatrix();
glTranslatef(rueda1X, rueda1Y, rueda1Z);
glRotatef(anguloRueda1, eje1X, eje1Y, eje1Z);
RenderRueda();
glPopMatrix(); // Recuperamos la transformacion del coche
glPushMatrix();
glTranslatef(rueda2X, rueda2Y, rueda2Z);
glRotatef(anguloRueda2, eje2X, eje2Y, eje2Z);
RenderRueda();
glPopMatrix();
glPushMatrix();
glTranslatef(rueda3X, rueda3Y, rueda3Z);
glRotatef(anguloRueda3, eje3X, eje4Y, eje3Z);
RenderRueda();
glPopMatrix();
glTranslatef(rueda4X, rueda4Y, rueda4Z);
glRotatef(anguloRueda4, eje4X, eje4Y, eje4Z);
RenderRueda();
glPopMatrix();
glPopMatrix(); // Recuperamos la transformacion del mundo
Suscribirse a:
Entradas (Atom)