lunes, 21 de mayo de 2012
EJEMPLOS DE USO DE LA GRAFICACION
USOS DE GRAFICACION DE
MEDICINA
La primera gran revolución
en el terreno de la imagen médica vino de la mano de Wilhelm Conrad von Röntgen
(1845-1923) al descubrir los rayos X el 8 de noviembre de 1895. La principal
característica de este nuevo descubrimiento era que hacía visible el interior
de los objetos, lo que desembocó en un aumento radical de la investigación de
las imágenes anatómicas. Aprovechando la radiación de los rayos X (notar que
los rayos X son una forma de radiación electromagnética) se consiguieron
plasmar, a principios del XX, las primeras imágenes del interior del cuerpo
humano, siendo la primera la de la mano de la esposa de Röntgen.
La segunda gran revolución
fue el descubrimiento y desarrollo de una técnica basada en los rayos X por la
que los físicos Allan MacLeod Cormack (1924) y Godfrey Newbold Hounsfield
(1919-2004) recibirían el Premio Nobel de Fisiología o Medicina en 1979: la
Tomografía Axial Computerizada (CT o TAC). El éxito de esta técnica viene de
que una imagen obtenida en una CT consigue distinguir diferencias mínimas de
intensidad, hecho que permitió, por ejemplo, diferenciar, a nivel cerebral, las
sustancias gris y blanca.
La tercera gran revolución
lleva el nombre de Imagen por Resonancia Magnética (MR o MRI), que permite
desde el estudio del cerebro de enfermos de esquizofrenia hasta el de los
ligamentos de los deportistas. La MR es un fenómeno físico basado en las
propiedades magnéticas que poseen los núcleos atómicos. Fue observado en 1946
por Felix Bloch (1905-1983) y Edward Mills Purcell (1912-1997) y se basa en que
ciertos núcleos atómicos
La cuarta gran revolución,
la ecografía, está muy ligada a un instrumento bélico, el sonar, desarrollado
por científicos franceses durante la Segunda Guerra Mundial. Se trata de una
técnica no invasiva basada en la utilización de ultrasonidos (ondas sonoras de
alta frecuencia) para estudiar la estructura de los tejidos, diferenciando
tejidos sanos de tejidos patológicos. Un aparato llamado transductor emite
estos ultrasonidos sobre una zona del cuerpo.
En los últimos años, el auge
de la radiología intervencionista y la cirugía mini invasiva ha supuesto
la investigación y el desarrollo de
nuevas técnicas y tecnologías capaces de minimizar el impacto de la acción
médica en el paciente, las cuales conforman la quinta y última gran revolución
en la imagen médica. Algunas de estas técnicas están basadas en, y/o utilizan,
alguna de las anteriormente explicadas, pero otras suponen un avance
extraordinario no sólo a nivel de la imagen en la medicina, sino en un contexto
general a nivel imagen
USOS DE GRAFICACION EN LA
A menudo, se utilizan como
instrumentos de ayuda educativa modelos de sistemas físicos, financieros y
económicos, los cuales se generan por computadora. Modelos de sistemas físicos,
sistemas fisiológicos, tendencias de población o equipo, pueden ayudar a los
estudiantes a comprender la operación del sistema. En el caso de algunas
aplicaciones de capacitación, se diseñan sistemas especiales, como los simuladores
para sesiones de práctica o capacitación de capitanes de barco, pilotos de
avión, operadores de equipo pesado y el personal de control de tráfico aéreo.
Algunos simuladores no tiene pantallas de video; por ejemplo, un simulador de
vuelo que sólo tiene un panel de control como instrumento de vuelo.
Cruces entre lo virtual y lo
real
Hacer un mundo dentro de un
mundo es inaugurar un conjunto de posibilidades de cruces y simulaciones. En
cuanto a lo primero, en la charla se observó que ya es están produciendo
vinculaciones entre el mundo real y el virtual en Second Life, que tienen como
antecedente sucesos similares que se produjeron en los juegos de rol.
USOS DE GRAFICACION EN LA
PUBLICIDAD
La mejor publicidad gráfica
siempre ha sido venerada y elevada a la categoría de arte. Propuestas
creativas, fotografía, tecnología aplicada a la imagen, etc... Todos son
ingredientes de una fórmula donde existe un componente especial. El mensaje.
Sin duda el elemento quizás
más importante de toda pieza artística y creativa, y como no, también de los
anuncios de la publicidad gráfica donde el objetivo principal se fundamente en
conseguir la forma más eficaz de transmitirlo sin necesidad apenas de recurrir
a las palabras.
USOS DE GRAFICACION EN EL
ENTRETIMIENTO
Es muy común utilizar
métodos de gráficas por computadora para producir películas, videos musicales y
programas de televisión.
El objetivo de los
videojuegos, como medio de ocio, siempre ha sido el de entretener al usuario,
desde sus inicios a nuestros días se ha mantenido esta máxima, pero tanto en el
contenido como en la apariencia estos han evolucionado a pasos agigantados,
avivados entre otras cosas por el rápido desarrollo de diferentes tecnologías.
Tanto han evolucionado los videojuegos, que cada vez nos es más difícil
relacionar los juegos pioneros con las grandes superproducciones que se lanzan
hoy día.
jueves, 26 de abril de 2012
Técnicas de sombreado clásicas y avanzadas
Clásicas:
Iluminación local.
Luces que no son extensas,
como las reales, sino inextensas, puntuales. Y, por añadidura, se relacionan
con los objetos como mónadas aisladas, sin tener en cuenta la interacción entre
ellos. Esto explica lo artificioso de muchas de las técnicas que se describirán
más adelante y que buscan compensar estas limitaciones.
Las insuficiencias de los
métodos de iluminación local se han superado en parte por medio de sistemas de
iluminación global que permiten tomar en cuenta la interacción entre objetos.
Las dos técnicas principales son el trazado de rayos (ray tracing) y la
radiosidad (radiosity)
Calculos de iluminación por vértices
Para poder aplicar
iluminación necesitamos asociar a cada vértice de nuestro objeto un vector
normal asociado. Cuando tenemos la normal calculada tenemos que normalizarla, o
sea, dividir ese vector por su propio modulo para que sea unitario, pero
también podemos hacer que se encargue la OpengGl activando la normalización,
glEnable GL_NORMALIZE
o desactivarla con,
glDisable GL_NORMALIZE
el usar GL_NORMALIZE
dependerá de nuestra aplicación ya que forzando a que sea OpenGl que las
utilice se ralentiza ya que le estamos hacer mas cálculos de los que debe.
Para definir las normales en
opengl utilizaremos la función glNormal3f(X,Y,Z) por ejemplo para definir una
cara con 4 vértices la definiremos de la siguiente manera
GlBegin GL_QUADS
glNormal3f nX,nY,nZ
glvertex3f x,y,z
glvertex3f x,y,z
glvertex3f x,y,z
glvertex3f x,y,z
glEnd
Es decir, cada vez que
queremos definir una normal a un vértice usamos glNormal y el vértice/s que
siguen se asocian a esta normal.
La luz de tipo SMOOTH el
polígono que definamos tendrá un color definido par cada vértice, asociando las
normales a los vértices OpenGL puede hacer los cálculos de los colores a cada
uno del vértice y después hace una interpolación de colores con este tipo de
luz se acerca bastante al realismo pero a un la podemos mejorar.
Posterior
relleno de triangulos
Rellenado de los triángulos
(rastering). 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.
Se trata de la última fase,
en ocasiones la más costosa, del proceso, por lo que es la primera que se suele
integrar en el hardware gráfico. En esta etapa se trata de asignar colores a
los pixels correspondientes al interior de cada triángulo proyectado que cae
dentro del área de visualización. Los colores asignados deben calcularse por el
método de Gouraud, interpolando linealmente entre los colores de los tres
vértices.
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 triángulos. Cada
triángulo 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 triángulos, 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 éstos se proyecten sobre la ventana,
entonces comienza una segunda fase de cálculos realizados para cada pixel
cubierto por los triángulos.
Realistas:
Iluminación global
Son sencillos y rápidos pero
proporcionan imágenes muy simples, que no representan adecuadamente el modo en
que la luz ilumina los objetos y los espacios. Esto no quiere decir que no sean
útiles para un gran número de casos, y es muy importante calibrar adecuadamente
que es lo que se necesita, pues puede muy bien ocurrir que un cálculo local
proporcione imágenes relativamente esquemáticas pero más adecuadas para la representación
de un proyecto.
Los métodos principales que
existen en la actualidad pueden considerarse como desarrollos, con diferentes
variantes, de los dos métodos principales que surgieron en la década de los
1980, ray tracing (introducido por T.Whitted en 1980) y radiosity (hacia 1984
por varios autores). Una base téorica más firme para los algoritmos y métodos
de GI (Global Illumination), vino con la publicación, por Kajiya, en 1986 de la
rendering equation, que puede encontrarse en un manual especializado
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 específica de un determinado material.
Radiosidad
Está basado en principios
generales que se pueden encontrar en un manual general sobre rendering. En el
estadio 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 o, en una aproximación más 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 iluminará a su vez a los objetos que
le rodean.
Casi todos los modelos de
iluminación necesitan conocer la normal de cada superficie para calcular su
color.
El primero, llamado método de Gouraud, efectúa
una interpolación a partir de los colores calculados por los vértices del
polígono, en los que se conoce la normal. El segundo llamado método de Pong,
interpola la normal en el punto en estudio a partir de las normales en los
vértices, calculando a continuación el color con la ayuda de esta normal según
el modelo de iluminación elegido.
Cálculos de iluminación por
pixel
Iluminación por fragmento
(por pixel) puede ser elaborada en hardware de gráficos moderno como un proceso
de post-rasterización por medio de un programa de shader.
Pixel Shader (PS) como un
pequeño programa que procesa fragments (algo así como pixelscon más datos) y
que se ejecuta en la GPU. Al crear un PS, se crea una función de procesado de
fragmentos que manipula datos de fragmentos.
Frecuentemente necesitan
datos del VS, llegando incluso a veces a ser “conducidos” por éste. Por
ejemplo, para calcular una iluminación por pixel, el PS necesita la orientación
del triángulo, la orientación del vector de luz y en algunos casos la
orientación del vector de vista.
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). Aceleramos el proceso de síntesis. Correcto si se verifica: Fuente de luz en el
infinito. Observador en el infinito. 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
Obtenemos una intensidad que aplicamos a
un conjunto de puntos de un objeto
*Aceleramos el proceso de síntesis
*Correcto si se verifica.
* Fuente de luz en el infinito
*Observador en el infinito
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)
Aceleramos el proceso de
síntesis
Correcto si se verifica
Fuente de luz en el infinito
Observador en el infinito
El polígono representa una
superficie plana real del objeto que se modela y no es una aproximación de un
objeto curvo.
• Interpolación de Intensidades (Gouraud)
Se basa en la interpolación de intensidad
o color
Considera que facetas planas vecinas
proceden deaproximar una superficie curva (salvo que se declare una arista real entre ambas)
*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 polígono
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).
Sombreado de 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 (Gouraud los puede omitir).
Produce mejores resultados,
a un coste computacional mayor (hay que incrementar la dirección de la normal
en tres direcciones, normalizarla y calcular la ecuación de sombreado encada
punto)
• Si el coeficiente de
reflexión especular es pequeño, los resultados no difieren tanto (se pueden
combinar objetos sombreados por ambos métodos en una escena).
Ray Tracing
En muchas formas, ray
tracing es una extensión al enfoque de rendering con un modelo de iluminación
local. Está basado en la observación previa que, de los rayos de luz saliendo
de una fuente, los únicos que contribuyen a la imagen son aquellos que entran
el lente de la cámara sintética y pasan por el centro de proyección.
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
Stencil.
Stencill Buffer es una
memoria intermedia que analiza y actualiza píxeles (con sus operaciones) 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. Del mismo modo que el buffer de profundidad asocia a cada píxel
de la ventana un valor de profundidad, el stencil buffer asocia su propio valor
a cada píxel mostrado. Cuando el buffer de profundidad esta activado los
valores de profundidad son usados para aceptar o rechazar fragmentos, del mismo
modo los valores de Stencil buffer son usados para aceptar o rechazar
fragmentos.
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. Este aspecto no será tomado en cuenta en los
modelos más sencillos.
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, 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.
Fuentes
de Color
No solamente las fuentes de
luz emiten diferentes cantidades de luz en diferentes frecuencias, pero también
sus propiedades direccionales varían con la frecuencia. Por lo tanto, un
modelos físicamente correcto puede ser muy complejo. 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.
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 un 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. Si se sigue este segundo enfoque, se puede postular una intensidad
ambiente en cada punto del ambiente. Por lo tanto, iluminación ambiente se
caracteriza por una intensidad Ia, que es idéntica en cada punto de la escena.
Spotlights (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 θ.
Intensidad
Completa
La intensidad completa exclusivamente para efectos de
iluminación es la siguiente:
miércoles, 18 de abril de 2012
ELIPSES Y CIRCULOS
Puesto que el círculo es un
componente muy frecuentemente utilizado en dibujos y gráficas, muchos paquetes
gráficos incluyen un procedimiento para generar círculos completos o arcos
circulares. Asimismo, en ocasiones hay disponible una función genérica en las
bibliotecas gráficas para mostrar diversos tipos de curvas, incluyendo círculos
y elipses.
Las rutinas para generar
curvas básicas, como círculos y elipses, no están incluidas como funciones
primitivas en la biblioteca OpenGL básica. Pero esta biblioteca sí que contiene
funciones para dibujar spunes de Bézier, que son polinomios que se definen mediante
un conjunto de puntos discreto. Y la utilidad OpenGL (GLU, OpenGL Ulility)
tiene rutinas para cuádricas tridimensionales, como esferas y cilindros, además
de rutinas para generar B-splines racionales, que son una clase genérica de
Splines en la que están incluidas las curvas de Bézier, más simples.
ALGORITMO
DEL PUNTO MEDIO PARA GENERACIÓN DE CÍRCULOS
1. Introducir el radio r y
el centro del círculo (xv,yt) y luego establecer las coordenadas para el primer
punto de la circunferencia de un círculo centrado en el origen mediante la
fórmula
2. Calcular el valor inicial
del parámetro de decisión
3. Para cada posición xy
comenzando en k = 0, realizar la siguiente comprobación. Si pk < 0, el
siguiente punto a lo largo de un círculo centrado en (0,0) será {xk+iJyk) y,
P^=Pt+2xktl+\
4. Determinar los puntos
simétricos en los otros siete octantes.
5. Mover cada posición de
píxel (x, y) calculada hasta la trayectoria circular centrada en (xc,yc) y
dibujar los valores de coordenadas: x=x+xc , y = y+yc
6. Repetir los Pasos 3 a 5
hasta que x > y.
ALGORITMOS
DE GENERACIÓN DE ELIPSES
Debido a que la elipse y la
circunferencia son figuras simétricas el algoritmo genera los vértices del
primer cuadrante solamente. Los vértices del segundo cuadrante se crean
aplicando simetría axial respecto a los vértices del primer cuadrante, los
vértices del tercer cuadrante con respecto a los del segundo y los vértices del
cuarto cuadrante con respecto a los del tercero.
En termines simples, una
elipse es un circulo alargado. También podemos escribir una elipse como un
circulo modificado cuyo radio varía desde un valor máximo en una dirección
hasta un valor mínimo en la dirección perpendicular.
Formas paramétricas
La ecuación paramétrica de
una elipse con centro en (H,K) y siendo el semieje mayor y b el menor, es:
con no es el ángulo θ del
sistema de coordenadas polares con origen en el centro de la elipse (tampoco es
el ángulo del sistema de coordenadas polares con origen en algún foco de la elipse).
martes, 17 de abril de 2012
gluLookAt()
Permite definir de forma específica
donde se va a situar la cámara, hacía donde mirará ésta y cuál será el orden de
los ejes de coordenadas.
Según sea el valor del
vector de vista hacia arriba el objeto que se visualizara tendrá un aspecto
diferente.En OpenGL lo tenemos fácil con:
gluLookAt(eyeX,
eyeY, eyeZ, atX, atY, atZ, upX, upY, upZ);
Esta es la función que
determina dónde y cómo está dispuesta la cámara. Cuidado que la posición de la
cámara no tiene nada que ver con el tipo de proyección que hayamos definidoPara
ello recordad siempre activar esta matriz antes de llamar a gluLookAt de esta
forma:
glMatrixMode(GL_MODELVIEW);
En cuanto a los parámetros
que demanda la función son los siguientes:
Coordenadas del
"eye". Es literalmente la posición XYZ dónde colocar la cámara dentro
del mundo.
Coordenadas del
"at". Es el valor XYZ del punto al que queremos que mire la cámara.
Un punto del mundo obviamente.
Coordenadas del vector
"up". Si, es un vector y no un punto. Con él regularemos la
orientación de la cámara. Este ha de ser el vector que "mira hacia
arriba" si entendemos que el vector que mira hacia adelante es el que va
del "eye" hasta el "at". Variando el "up"
variamos la orientación y sino mirad:
Si gluLookAt altera la matriz GL_MODELVIEW y esta es la que guarda el
estado de todo nuestro sistema en cuanto a transformaciones (recordad el
artículo anterior), mejor controlar la situación con los gl_push y gl_pop que
ya conoceis para no desmontarlo todo....y quizás tengais que limpiar la matriz
antes de tocar la cámara usando para ello una identidad.....pensad en ello un
poco...8)
domingo, 15 de abril de 2012
Carro en 2D
#include <GL/glut.h>
float pos;
int gr;
void reshape(int width, int height){
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-10, 10, -10, 10, 0.1f, 20);
glTranslatef(-3.0f, 0.0f, -15.0f);
glMatrixMode(GL_MODELVIEW);
}
void rueda_d(){
glPushMatrix();
glColor3f(0,0,0);
glTranslatef(1.5f,0.0f, 0.0f);
glRotatef(gr, 0.0f, 0.0f, 1.0f);
glutSolidSphere(1.0f,20,20);
glPopMatrix();
}
void rueda_t(){
glPushMatrix();
glColor3f(0,0,0);
glTranslatef(5.5f,0.0f, 3.0f);
glRotatef(gr, 0.0f, 0.0f, 1.0f);
glutSolidSphere(1.0f,20,20);
glPopMatrix();
}
void ventanas(){
glPushMatrix();
glColor3f(0,0,0);
glTranslatef(1.2f,2.0f, 0.01f);
glBegin(GL_TRIANGLES);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(0.8f, 0.0f, 0.0f);
glVertex3f(0.8f, 0.8f, 0.0f);
glEnd();
glBegin(GL_QUADS);
glVertex3f(0.8f, 0.0f, 0.0f);
glVertex3f(1.7f, 0.0f, 0.0f);
glVertex3f(1.7f, 0.8f, 0.0f);
glVertex3f(0.8f, 0.8f, 0.0f);
glEnd();
glTranslatef(1.9f,0.0f, 0.0f);
glBegin(GL_QUADS);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(0.9f, 0.0f, 0.0f);
glVertex3f(0.9f, 0.8f, 0.0f);
glVertex3f(0.0f, 0.8f, 0.0f);
glEnd();
glBegin(GL_TRIANGLES);
glVertex3f(0.9f, 0.0f, 0.0f);
glVertex3f(1.7f, 0.0f, 0.0f);
glVertex3f(0.9f, 0.8f, 0.0f);
glEnd();
glPopMatrix();
}
void techo(){
glPushMatrix();
glTranslatef(1.0f,2.0f, 0.0f);
glBegin(GL_TRIANGLES);
glVertex3f(1.0f, -1.0f, 0.0f);
glVertex3f(-1.0f, -1.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 0.0f);
glEnd();
glBegin(GL_QUADS);
glVertex3f(1.0f, 0.0f, 0.0f);
glVertex3f(3.0f, 0.0f, 0.0f);
glVertex3f(3.0f, 1.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 0.0f);
glEnd();
glBegin(GL_TRIANGLES);
glVertex3f(3.0f, 0.0f, 0.0f);
glVertex3f(4.0f, 0.0f, 0.0f);
glVertex3f(3.0f, 1.0f, 0.0f);
glEnd();
glPopMatrix();
}
coche(){
glColor3f(0,0,1);
glTranslatef(pos,0.0f, 0.0f);
glBegin(GL_QUADS);
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(7.0f, 0.0f, 0.0f);
glVertex3f(7.0f, 2.0f, 0.0f);
glVertex3f(0.0f, 2.0f, 0.0f);
glEnd();
}
void display(){
GLfloat angulo;
int i;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
coche();
techo();
ventanas();
rueda_d();
rueda_t();
glutSwapBuffers();
}
void init(){
glClearColor(1,1,1,0);
pos=0;
gr=0;
glEnable(GL_DEPTH_TEST);
}
void keyboard(unsigned char key, int x, int y){
switch(key)
{
case 'm':
case 'M':
pos+=0.1f;
gr-=180/3.14;
display();
break;
case 'n':
case 'N':
pos-=0.1f;
gr+=180/3.14;
display();
break;
}
}
int main(int argc, char **argv){
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(50, 50);
glutInitWindowSize(600, 600);
glutCreateWindow("Carro en 2 D");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}
Corrida
Programa que se Mueve la Pelota
#include <GL/glut.h>
GLfloat anguloCuboX = 0.0f;
GLfloat anguloCuboY = 0.0f;
GLfloat anguloEsfera = 0.0f;
GLfloat TrasEsferax= 3.0f;
GLfloat TrasEsferay= 0.0f;
GLfloat TrasEsferaz= -5.0f;
GLint ancho=400;
GLint alto=400;
int hazPerspectiva = 0;
void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
if(hazPerspectiva)
gluPerspective(60.0f, (GLfloat)width/(GLfloat)height, 1.0f, 20.0f);
else
glOrtho(-4,4, -4, 4, 1, 10);
glMatrixMode(GL_MODELVIEW);
ancho = width;
alto = height;
}
void drawCube(void)
{
glColor3f(0.0f, 0.0f, 0.5f);
glBegin(GL_QUADS);
glVertex3f( 4.0f,-4.0f, -4.0f);
glVertex3f( 4.0f,-4.0f, 4.0f);
glVertex3f(-4.0f,-4.0f, 4.0f);
glVertex3f(-4.0f,-4.0f, -4.0f);
glEnd();
}
void display()
{
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glTranslatef(0.0f, 0.0f, -5.0f);
glRotatef(5, 1.0f, 0.0f, 0.0f);
glRotatef(5, 0.0f, 1.0f, 0.0f);
drawCube();
glLoadIdentity();
glTranslatef(TrasEsferax,TrasEsferay,TrasEsferaz);
glColor3f(0.0f, 1.0f, 0.0f);
glutWireSphere(0.5f, 8, 8);
glFlush();
glutSwapBuffers();
}
void init()
{
glClearColor(0,0,0,0);
glEnable(GL_DEPTH_TEST);
ancho = 400;
alto = 400;
}
void idle()
{
display();
}
void keyboard(unsigned char key, int x, int y)
{
switch(key)
{
case 'p':
case 'P':
hazPerspectiva=1;
reshape(ancho,alto);
break;
case 'o':
case 'O':
hazPerspectiva=0;
reshape(ancho,alto);
break;
case 'j':
case 'J':
TrasEsferax-=1.0;
break;
case 'l':
case 'L':
TrasEsferax+=1.0;
break;
case 'i':
case 'I':
TrasEsferay+=1.0;
break;
case 'k':
case 'K':
TrasEsferay-=1.0;
break;
case 'u':
case 'U':
TrasEsferaz+=0.5;
break;
case 'y':
case 'Y':
TrasEsferaz-=0.5;
break;
case 27:
// exit(0);
break;
}
}
int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB);
glutInitWindowPosition(100, 100);
glutInitWindowSize(ancho, alto);
glutCreateWindow("Piso y pelota");
init();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}
Corrida
Suscribirse a:
Entradas (Atom)