COMPUTACION-GRAFICA

PREVIO PRACTICA NO. 10

2007-05-26T12:20:00.000-07:00

PREVIO NO. 10

Animación Esqueletal:
Un modelo 3d está compuesto por cientos o miles de polígonos de distintas formas y tamaños que unidos entre sí forman la figura deseada. El número de polígonos ha ido aumentando progresivamente de modo que ahora para formar el brazo de un determinado modelo se utilizan miles de polígonos... miles de polígonos que han de modificar su tamaño y forma con cada mínimo movimiento del modelo.
Calcular cada deformación de estos miles de polígonos y sus nuevas coordenadas en la escena, además de la aplicación sobre ellos de efectos luminosos, texturados, filtrados... El trabajo que supone para el sistema gráfico es tremendo. En eliminar esa inmensa carga se basa la tecnología del "esqueleto 3d". La "animación esqueletal" se basa en crear el modelo sobre una arquitectura o esqueleto y después recubrirlo de texturas (o piel). Con esta técnica, cada miembro del gorila del ejemplo se construiría recubriendo de polígonos un "hueso" (bone) del esqueleto. Las ventajas llegan cuando ese miembro se tiene que mover respecto al cuerpo. Cada hueso tendrá un movimiento limitado respecto al hueso con el que se une, exactamente del mismo modo que lo tiene el animal real. Cada parte móvil del modelo está formada a través de un hueso que tiene su propio recubrimiento de carne (polígonos) y su propia piel (texturas) y con la movilidad que el programador le quiera dar. De este modo, el gorila del ejemplo podría tener un hueso que le permita mover el brazo respecto al hombro, el antebrazo respecto al resto del brazo, la mano respecto al antebrazo, los dedos respecto a la mano... El movimiento es mucho más realista y, sobre todo, requiere muchos menos recursos del sistema al no tener que calcular la deformación de los polígonos que hasta ahora se utilizaban para representar las articulaciones.
El único problema que representa la creación de modelos 3d a partir del un esqueleto se encuentra en la unión de los distintos huesos. Entre un hueso y otro existe un espacio que, siguiendo el símil con el cuerpo de los vertebrados reales, llamaremos articulación. Esta articulación se contrae, se estira y de deforma de distintas formas dependiendo del movimiento que hagan los dos huesos que une por ejemplo:

La grieta que se crea entre ambos huesos es algo que no se puede mostrar en la imagen final. Para esconderla se utiliza la técnica "Skinning" que, como su nombre indica, se encarga de recubir de piel estas imperfecciones.

Mediante esta piel flexible, que une cada uno de los vértices de un hueso con el correspondiente en el otro, se da continuidad al objeto y se acerca mucho al movimiento totalmente natural que podemos observar en cualquier ser vivo. Un problema que genera esta "piel" radica en la textura que recubre esta piel.
El problema radica en cómo unir los distintos huesos de modo que la apariencia final sea realista. De eso se ocupa el Vertex Skinning. Esta técnica se basa en la aplicación lo más realista posible del cálculo de las funciones matemáticas que calculan la posición de cada vértice de un objeto en la escena. Explicado de una forma sencilla, se ocupa de rellenar de la forma más realista posible los espacios entre los distintos "huesos" de los que ya hemos hablado. La unión entre los citados huesos es más real cuanto más matrices se utilicen. Estas matrices son cálculos matemáticos destinados a unir entre sí cada vértice del objeto. Cuantas más veces se recalcule la unión (más matrices haya), más realista será el objeto final.

El brazo del modelo (en rojo) se une al torso (en azul). Cada color representa una de las matrices y, como vemos, la unión entre ambas es poco natural. Tarjetas como las ATi Radeon soportan hasta cuatro matrices por hardware, por lo que en ejemplos como este, añadiendo una tercera matriz se solucionaría el problema.

Entre las matrices roja y azul, se ha introducido una tercera matriz representada en verde. Esta matriz se introduce entre las otras dos actuando como una especie de colchón flexible que hace que la unión de las otras dos sea más natural. En caso de que el resultado no fuese el buscado, se podría introducir una cuarta matriz y perfeccionar aún más el resultado. Otra de las ventajas de contar con más matrices a la hora de representar un modelo, es que se puede definir el comportamiento de la textura (piel) que recubre cada matriz. Si se trata de representar la piel de un animal, la textura que recubre la matriz central se estirará mientras que la que recubre las otros dos matrices permanecerá igual. Del mismo modo, cada matriz puede verse afectada de forma diferente por la luz, ensombreciendo o aclarando la textura que la recubre.
La gran ventaja de las ATi Radeon es que calcula hasta cuatro de estas matrices por hardware. Calcular estas matrices por software sería imposible ya que el procesador principal quedaría completamente colapsado ante tal afluencia de operaciones de cálculo en tiempo real.
En el siguiente gráfico podemos ver un ejemplo real en un juego, el Dungeon Siege de Microsoft, en el que se pueden ver las cuatro matrices en distintos colores.

Cada color representa una matriz, sin embargo, la aplicación más efectiva de las distintas matrices, donde más efectiva se muestra es en las transiciones automáticas. Los conocidos "morphings".
Formatos:
.fbx
el formato FBX, desarrollado por Kaydara para el intercambio de información.
FBX es un formato binario que soporta toda clase de información 3D, 2D, video y audio, por lo que facilita enormemente la comunicación entre distintas aplicaciones (como Cinema4D, Lightwave, 3D Studio).
.fpx
Formato que admite múltiples resoluciones de una imagen. Con o sin compresión y de 8 a 24 bits de profundidad de color Desarrollado por Kodak en conjunto con Hewlett Packard
.x
Los ficheros .X estan compues de plantillas, que pueden ser definidas por el usuario. Una plantilla es una "definicion de como quiere el usuario que se almacene la informacion".
Para animar un fichero .X necesitas especificar una serie de animaciones con referencia a las matrices frame correspondientes. Abajo aparece un ejemplo de nuestro cuadrado texturizado y animado.
Un ejemplo de estos formatos "optimizados" para juegos son los utilizados por Id Software para su Quake. Es posible que escriba un tutorial sobre este formato mas adellante, pero por el momento vamos a empezar con uno mas sencillo: el formato .X que es el que usa por defecto DirectX.

Existe una herramienta que viene con el SDK de DirectX8 para transformar los ficheros del 3dStudio a formato .X en C:\mssdk\bin\DXUtils\XFiles\conv3ds.exe

Estos ficheros .X van a contener la informacion acerca de nuestros modelos 3D (personajes, naves, etc...) e incluso de nuestro mundo 3D (pistas, ciudades, mapas, etc...)

Los puntos claves cuando trabajamos con estos ficheros son:

- De que manera estan almacenados los objetos.

- De que forma se relacionan entre ellos.

MODELO:

Previo Practica 9

2007-05-19T11:48:00.000-07:00

Previo Practica No.9

1.- Investigue acerca de los métodos usuales de la animación

Keyframes (Cuadros Llave):
Se refiere a imágenes o dibujos los cuales define una parte esencial de inicio y fin entre puntos de transición. Estos son llamados “frames” porque su duración en el tiempo forman parte de una filmación. Una secuencia de keyframes define el movimiento que el espectador puede ver, algunas veces la posición de los keyframes en un film, video o animación define el tiempo del movimiento. Por que la duración de solamente 2 o 3 keyframes en un segundo no produce una ilusión de movimiento, la permanencia de los frames son fijados con más dibujos o imágenes, llamadas “inbetweens”.

Forward Kinematics (Cinemática Directa):

Es un método de la computación grafica en 3D para la animación de modelos. El concepto esencial de este concepto es que la posición de partes particulares de un modelo en un especifico tiempo son calculados desde la posición de orientación d el objeto, junto con la información en la unión de alguna articulación del modelo.

Inverse Kinematics (Cinemática Inversa):

Es un proceso utilizado en la animación de computación grafica en 3D, para calcular lo que requiere la articulación de una serie de extremidades o conjunturas, tal como al final de las extremidades hacia arriba en una localización particular.

Motion Capture (Captura de Movimientos):

Es una técnica de grabación digital de movimientos para entretenimiento o espectáculo, deportes y aplicaciones médicas. Utiliza varios sistemas de captura desde los ópticos, mecánicos, sistemas magnéticos, ya sea mediante de el uso de censores u otros dispositivos. Solo graba los movimientos no la apariencia, este método surgió como investigación militar.

2.- Discuta acerca de las ventajas y desventajas de cada método y de ejemplos al menos dos de situaciones en las que cada uno este mejor aplicado.

Keyframes (Cuadros Llave):

Ventajas:
Fácil de manejar
Útil para hacer videos rápidos.
Solo se necesitan figuras básicas.

Desventajas:
Ineficiente para una buena animación.
Para un trabajo grande se necesitan varias figuras base.

Aplicaciones:
Videos
Films
Comerciales
Presentaciones

Forward Kinematics (Cinemática Directa):
Ventajas:
Determina comportamientos.
Determina Posiciones.
Se planea cada movimiento.

Desventajas:
No define leyes físicas como la gravedad y colisiones.

Aplicaciones:
Robotica
Juegos de Computadora
Animación.

Inverse Kinematics (Cinemática Inversa):
Ventajas:
Se encarga de los requerimientos en las articulaciones.

Desventajas:
Limites antropomórficos
Limites en las articulaciones

Aplicaciones:
Robotica
Animación por Computadora.

Motion Capture (Captura de Movimientos):
Ventajas:
Más rápido, algunas veces da mejores resultados en tiempo real.
La cantidad de trabajo no varia con la complejidad o tamaño de la calidad o el mismo grado cuando se usan las técnicas tradicionales.
El movimiento complejo y las interacciones realistas físicas tal como una animación secundaria, peso e intercambio de fuerzas puedes ser más fáciles de crear con un modo preciso de chequeo.
La tecnología concede a un actor jugar múltiples roles con un solo film.
Desventajas:
Necesita hardware específico y programas especiales requeridos para obtener y procesar datos.
El costo del software y equipo, personal requerido pueden no ser viables para pequeñas producciones.
El sistema de captura tendría que tener requerimientos específicos para ser operados en ellos.
Cuando ocurren problemas estos pueden ser fáciles es mejor reseguir la escena que intentar manipular los datos. Solamente pocos sistemas alojan vista en tiempo real del dato para decidir si se toman cartas en el asunto o se tiene que volver a rehacer.
Ampliado movimiento para cuadruplicar caracteres puede ser difícil.
La tecnología puede llegar a ser obsoleta en pocos años así como el software y técnicas para desarrollo.
Los resultados son limitados para que pueda existir una alta calidad en la captura dependiendo del volumen y la edición extra de los datos.
El movimiento no puede seguir las leyes de la física generalmente no se pueden representar.
Las técnicas de animación tradicionales tal como el énfasis o la anticipación y seguimiento, movimientos secundarios o manipulación, son estrechos en la animación y generalmente no se aplican.
Si el modelo de computadora tiene diferentes proporciones desde la captura del objeto, esto pueden ocurrir.
La calidad real de vida no puede trasladarse el modelo en la computadora como uno esperaba.

Aplicaciones:
En videojuegos donde se captura movimientos, por ejemplo: fútbol, básquetbol o combates de artes marciales, en general deportes de acción.
Para captura de efectos CG, en algunos casos remplaza la celda de animación, y por completamente la generación de criaturas por computadora como Golum, La Momia y King Kong
Realidad Virtual para interacción en tiempo real. Asi como visualización.
Generación de Personajes en tiempo real.

3.- Investigue que método de animación usan los modelos de Quake y de Unreal Tournament. Busque código que utilizando OpenGL permita visualizar un modelo de estos juegos y ejecútelo.

Los modelos Quake utilizan la predicción de movimiento por lo tanto utilizan el método de Forward Kinematics.

Los modelos de Unreal Tournament tienen bases de inteligencia Artificial

Pseudocodigo Iluminacion por Raster

2007-05-14T13:48:00.000-07:00

int v1x,v1y,v2x,v2y,v3x,v3y,v4x,v4y; //vertices

void ilumina(){

float *Ax,*Ay;

float *A'x,*A'y;

float *Bx,*By;

float *B'x,*B'y;

float *Cx,*Cy;

float *C'x,*C'y;
int ret;

if(ordena1==1){ //la funcion ordena devulve el vertice de mayor ordenada

B'x=bresenham1(*Ax,*Ay,*By,*Bx) //se utiliza el algoritmo de Bresenham
B'y=bresenham2(*Ax,*Ay,*By,*Bx)
color(r,g,b,B'x);
color(r,g,b,B'y);
C'x=bresenham1(*Ax,*Ay,*Cy,*Cx)
C'y=bresenham2(*Ax,*Ay,*Cy,*Cx)
color(r,g,b,C'x);
color(r,g,b,C'y);

}

if(ordena2==1){
B'x=bresenham1(*Ax,*Ay,*By,*Bx)
B'y=bresenham2(*Ax,*Ay,*By,*Bx)
color(r,g,b,B'x);
color(r,g,b,B'y);
C'x=bresenham1(*Ax,*Ay,*Cy,*Cx)
C'y=bresenham2(*Ax,*Ay,*Cy,*Cx)
color(r,g,b,C'x);
color(r,g,b,C'y);
}
if(ordena3==1){
B'x=bresenham1(*Ax,*Ay,*By,*Bx)
B'y=bresenham2(*Ax,*Ay,*By,*Bx)
color(r,g,b,B'x);
color(r,g,b,B'y);
C'x=bresenham1(*Ax,*Ay,*Cy,*Cx)
C'y=bresenham2(*Ax,*Ay,*Cy,*Cx)
color(r,g,b,C'x);
color(r,g,b,C'y);
}
if(ordena4==1){
B'x=bresenham1(*Ax,*Ay,*By,*Bx)
B'y=bresenham2(*Ax,*Ay,*By,*Bx)
color(r,g,b,B'x);
color(r,g,b,B'y);
C'x=bresenham1(*Ax,*Ay,*Cy,*Cx)
C'y=bresenham2(*Ax,*Ay,*Cy,*Cx)
color(r,g,b,C'x);
color(r,g,b,C'y);
}
while(By!=Cy){

if( B'y<=c'y&& c'y==cy){
A'y=cy
A'x=cx}

if( c'y<=B'y&& B'y==By){
Ay=By
Ax=Bx}

if(c'y=cy){
cy=V3Y
cx=v3X
}

if( B'y==By){
By=V3Y
Bx=v3X
}

}
B'x=bresenham1(*Ax,*Ay,*By,*Bx)
B'y=bresenham2(*Ax,*Ay,*By,*Bx)
color(r,g,b,B'x);
color(r,g,b,B'y);
C'x=bresenham1(*Ax,*Ay,*Cy,*Cx)
C'y=bresenham2(*Ax,*Ay,*Cy,*Cx)
color(r,g,b,C'x);
color(r,g,b,C'y);

}
}

int ordena1(){
if(v2y<=v1y>=v3y && v1y>=v4y){
Ay=A'y=v1y;
Ax=A'x=v1x;
if(v3y<=v2y>=v4y({
By=B'y=v2y;
Bx=B'x=v2x;

if(v3y<=v4y{
cy=c'y=v4y;
cx=c'x=v4x;
}else{

cy=c'y=v3y;
cx=c'x=v3x;
}
}
if(v2y<=v3y>=v4y){
By=B'y=v3y;
Bx=B'x=v3x;
if(v2y<=v4y{
cy=c'y=v4y;
cx=c'x=v4x;
}else{

cy=c'y=v2y;
cx=c'x=v2x;
}
}

}

if(v3y<=v4y>=v2y){
By=B'y=v4y;
Bx=B'x=v4x;
if(v3y<=v2y{
cy=c'y=v2y;
cx=c'x=v2x;
}else{

cy=c'y=v3y;
cx=c'x=v3x;
}
}
verif=1;
}

else
verif=0;
}

}

Previo 8

2007-05-08T08:43:00.000-07:00

1.- Investigue como crear y definir una fuente de luz en opengl creación de la luz:
CREACION DE FUENTES DE LUZ
Las propiedades de una fuente de luz son el color, posición y dirección. El comando usado para especificar todas las propiedades de una luz es glLight*(), tiene tres argumentos para identificar la luz que se está utilizando, la propiedad y el valor deseado para esapropiedad.
Después de definir las características de las luces, hay que encenderlas con el comando glEnable(). También hay que llamar a este comando con el parámetro GL_LIGHTING , de esta forma se preparar OpenGL para desarrollar los cálculos de Iluminación.

¿Cuantas luces se pueden definir?:
Podemos tener al menos ocho fuentes de luz en la escena (puede haber más, depende de la implementación de OpenGL. OpenGL necesita realizar cálculos para determinar cuanta luz recibe cada vértice de cada fuente de luz. El incremento del número de luces influye en una ejecución más lenta.

Parametrización de la fuente de luz

void glLight{if}[v] (GLenum light, GLenum pname, TYPE param )
Crea la luz especificada por light, la cual puede ser GL_LIGHT0, GL_LIGHT1,
…GL_LIGHT7. Las características de la luz quedan definidas por pname. El argumento
param indica los valores que establece la característica pname; si se utiliza la versión de
vector(v) pname es un puntero a un grupo de valores, o el propio valor si la versión sin vector es la que estamos usando(i,f).
Valores por defecto para el parámetro pname de glLLight*().

Tipos de luces
En OpenGL existen tres tipos fundamentales de luces:
Luces direccionales
Luces locales
Focos
Todos los tipos de luces permiten definir una componente ambiente, una difusa y una especular con componentes RGBA.
Definir las fuentes de luz (propiedades de cada una de las luces).
GLvoid glLightfv(GLenum light, GLenum pname, const GLfloat *params);
Light: la luz a la que se esté haciendo referencia (GL_LIGHT0, GL_LIGHT1, GL_LIGHT2, etc.).
*params, es un array de valores RGBA, cada valor define el porcentaje de intensidad de cada color que tiene la luz.
Luces direccionales
Una luz direccional esta situada en el infinito
Definir el vector direccional
float difusa[3]={1.0,0.0,0.0};
float direccion[4]={1.0,1.0,1.0,0.0};
glLightfv(GL_LIGHT0, GL_POSITION, direccion};
glLightfv(GL_LIGHT0, GL_DIFFUSE,difusa);
Luces locales
Las luces locales se definen de la misma forma que las direccionales solo que el cuarto elemento del vector vale uno.
float difusa[3]={1.0,0.0,0.0};
float posicion[4]={1.0,1.0,1.0,1.0};
glLightfv(GL_LIGHT0, GL_POSITION, posición};
glLightfv(GL_LIGHT0, GL_DIFFUSE, difusa);
Focos de luz
El foco viene definido como: una luz local, una dirección o una apertura del foco.
float difusa[3]={1.0,0.0,0.0};
float posicion[4]={1.0,1.0,1.0,1.0};
float direccion[3]={1.0,1.0,1.0};
glLightfv(GL_LIGHT0, GL_POSITION, posicion};
glLightfv(GL_LIGHT0, GL_DIFFUSE, difusa);
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, direccion); //Dirección del foco
glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 20); // ángulo de corte entre 0 y 180

Color de la luz
OpenGL permite asociar a cualquier luz tres parámetros relacionados con el color:
GL_AMBIENT, GL_DIFFUSE, GL_SPECULAR. El parámetro GL_AMBIENT se refiere a la intensidad RGBA de la luz ambiente que una fuente de luz añade a la escena. El valor por defecto es que no hay luz ambiente. El parámetro GL_DIFFUSE es el que está más relacionado con el concepto que tenemos normalmente de “color de una luz”; se refiere a la intensidad RGBA de la luz difusa que una fuente de luz añade a la escena. El valor por defecto es (1.0, 1.0, 1.0, 1.0) para GL_LIGHT0 que produce una luz blanca brillante. El valor por defecto para GL_LIGHT1… GL_LIGHT7 es (0.0, 0.0, 0.0, 0.0). El parámetro GL_SPECULAR afecta a el color del brillo especular en un objeto. Un objeto como un vaso tiene una luz especular que es el color de la luz que está brillando en él, normalmente blanca. Si queremos crear un efecto realista, el parámetro GL_SPECULAR y GL_DIFFUSE se deben establecer al mismo valor.

Habilitación y desabilitación de luces
Para que las luces tengan efecto se debe activar el cálculo del modelo de iluminación utilizando las luces usando la llamada: glEnable(GL_LIGHTING) y para deshabilitarlo glDisable(GL_LIGHTING);
y activar cada una de las luces individuales que se quieran utilizar con
glEnable(GL_LIGHTn) y deshabilitarlas glDisable(GL_LIGHTn);

Luz por defaul y características por defaul
Es una luz ambiente básica la cual especificará como se realiza la iluminación de la escena en cuanto a si las luces afectan a las dos partes de un objeto el modelo de cálculo de la relación entre el observador y los objetos en el caso de componente especular.
Propiedades para definir del modelo básico de iluminación:
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, ambiente); //Valores de lacomponente ambiente base.
GlLightModelf(GL_LIGHT_MODEL_TWO_SIDE,TRUE); //las luces afectana ambas caras de un material.
GlLightModelfv(GL_LIGHT_MODEL_LOCAL_VIEWER, TRUE); //Coloca el modo de cálculo especular con el observador local, si no todos los cálculos se hace como si el observador estuviese situado sobre el eje Z.

2.- Investige la diferencia entre luz he iluminación(ligth/ligthing)

Habilitación y desabilitación de la iluminación (¿Cómo?)
Para la habilitación/deshabilitación de toda la iluminación dentro de una escena se utiliza:
glEnable(GL_LIGHTING);
glDisable(GL_LIGHTING);

Para que hay que habilitar o desabilitar la iluminación
Con OpenGL necesitas habilitar o deshabilitar explícitamente la iluminación. Si no
Está habilitada el color actual es mapeado al vértice pero los cálculos de normales, fuentes de luz, modelo de iluminación y propiedades de material no se producen.

3.- Investigue la definición de propiedades de material a una superficie
Ø El modelo de iluminación de OpenGL realiza una aproximación del color de un material en función de la luz que incide sobre él y la luz que es capaz de reflejar
Ø Por ejemplo una pelota perfectamente roja es aquel objeto cuyo material es capaz de absorber todas longitudes de onda excepto el rojo y es capaz de reflejar únicamente este color
Ø Los materiales tienen dos propiedades sobre sus colores, que indican cómo influye cada una de las propiedades de un rayo de luz sobre él
Ø Ambient
Ø Diffuse
Ø También tiene tres propiedades sobre la capacidad de emisión y reflexión de luz
Ø Specular
Ø Shininess
Ø Emission
Ø Ambient
Ø se casa con la propiedad Ambient de un rayo de luz e indica cómo se va a comportar el material en función de la componente Ambient del rayo de luz incidente
Ø se refiere al color por defecto del material
Ø Diffuse
Ø se casa con la propiedad Diffuse de un rayo de luz e indica cómo se va a comportar el material en función de la componente Diffuse del rayo de luz incidente
Ø se refiere a la luz que reflejará de forma difusa
Ø Estas dos propiedades determinan el color del material y suelen tener valores aproximados sino iguales
Ø Specular
Ø se casa con la propiedad Specular de un rayo de luz e indica cómo se va a comportar el material en función de la componente Specular del rayo de luz incidente
Ø La propiedad especular se suele definir blanca o gris, de forma que los reflejos del material se degradan desde el color base de la luz incidente hasta el color definido en esta propiedad
Ø Shininess
Ø Determina la concentración de los puntos que van a reflejar la luz
Ø Puede ser un único punto o toda la superficie del objeto

Ø Emission
l Esta propiedad define la capacidad de un objeto de simular la emisión de luz
l NO es una fuente de luz
l Se definen los colores de la luz que emite
l Sirve para simular estrellas, lámparas u otros objetos similares

Características de las superficies (difusa, especular, brillantez, emisividad, etc.)
Luz ambiente
La luz ambiental es aquella que no proviene de una dirección concreta, incide sobre todas las partes del objeto por igual.
Iambiente = ka Ia
ka coeficiente de reflexión ambiental [0,1] dependiente de cada objeto.
Ia intensidad ambiental en todo punto del espacio.

Luz difusa
• La fuente tiene una localización y una dirección particular
• Una vez toca la superficie del objeto, se refleja en todas direcciones
La luz difusa es la que proviene de una dirección particular y es reflejada en todas direcciones.
Afecta a aquellas partes del objeto en las que la luz incide.
La luz difusa es reflejada por la superficie de un objeto de manera adireccional.

I L : Intensidad de la fuente
q : Angulo de incidencia [0º..90º]
Kd: Coeficiente de reflexión difusa para cada objeto [0..1]
N: Normal a la superficie (unitario)
L: Vector de iluminación (unitario)

Luz especular
• También es direccional, pero el reflejo se produce en una dirección concreta
• Produce un punto brillante en la superficie que ilumina --> reflejo especular
La luz especular procede de una dirección concreta y se refleja en una única dirección.
Produce brillos intensos.
Las reflexiones especulares son normalmente del mismo color que la fuente de luz.
La intensidad de la luz especular reflejada depende de:
La longitud de onda de la luz incidente
El ángulo de la luz incidente
Las características del material
En un espejo perfecto la dirección desde la que se observa el reflejo es la dirección de reflexión perfecta R.
La reflexión especular depende de la posición del observador.

Dependiendo de la superficie (grado de pulido) el brillo es más o menos concentrado alrededor del punto donde R y V coinciden.

BRILLOS
Se basan en la componente especular de los materiales
Produce un blanqueamiento del material
Depende del punto de vista
Produce reflejos especulares
Para realizar brillos en un material, la luz debe contener una componente especular distinta de cero:
Espec[]= {1.0f, 1.0f, 1.0f, 1.0f};
glLigth(GL_LIGHT0, GL_SPECULAR, Espec);
El material sobre el que incida también deberá tener una componente especular distinta de cero:
Glfloat especular[] = {1.0f, 1.0f, 1.0f, 1.0f}; glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); glMaterialfv(GL_FRONT, GL_SPECULAR, especular);

La propiedad de brillo del material determina el tamaño de la superficie que va a reflejar el brillo
glMaterialf(GL_FRONT, GL_SPECULAR, mat_option);
glMateriali(GL_FRONT, GL_SHININESS, 128);

El valor de esta componente varía entre:
0 La superficie es un punto
128 Toda la superficie del objeto refleja
SOMBRAS
Ausencia de luz producida generalmente por la superposición de un cuerpo opaco entre una fuente de luz y otro cuerpo
En OpenGL las proyecciones sólo se realizan sobre objetos volumétricos
Tipos de Sombras:
Sombras Proyectadas
Sombras Volumétricas
Sombras proyectadas
Es la técnica más sencilla, y consiste en calcular una matriz de proyección sobre el plano sobre el que se quiere dibujar la sombra
Una vez calculada esta matriz, si se multiplica por la matriz del modelo, y se dibujan el resto de las figuras, éstas se estarán proyectando sobre ese plano

Sombras volumétricas
La técnica anterior es muy sencilla, pero solo sirve para dibujar esas sobras proyectadas sobre planos
Si se tiene una composición de figuras en las que unas proyectan sombras sobre otras, con la técnica anterior no se podrán representar
Para evitar esto se utiliza una matriz especial que calculará la influencia de la posición de un objeto sobre los restantes

NIEBLA
Efecto especial utilizado para difuminar una escena dando la impresión de que se halla realmente cubierta por una masa de niebla
En general consiste en difuminar el color de la escena, oscureciendo los objetos más lejanos llegando incluso a desaparecer, mientras que los objetos más cercanos aparecen más claros
El efecto niebla se puede aplicar de dos formas principalmente:
Basado en vértices
Basado en tablas

¿Como se define sobre que cara(s) de un polígono se aplican los materiales?
Se tiene la función
void glMaterial{if}{v} (GLenum face, GLenum pname, TYPE *param);
Donde:
Parámetros de glMaterial{fv}
Face: Indica la cara sobre la que se va a aplicar el material
GL_FRONT à Se aplica sobre las caras delanteras del objeto
GL_BACK à Se aplica sobre las caras internas del objeto
GL_FRONT_AND_BACK à Se aplica sobre todas las caras del objeto
Param: Indica la propiedad que se va a establecer de las ya explicadas 4.- Invetige acerca del mapeo de texturas en opengl

Carga-definición de bytmap

La carga se hace abriendo el archivo de el bitmap directamente y asignándolo a un apuntador para después pintarlo:
bool CTextura::CargarBMP(char *szNombreFichero)
{
FILE *hFichero;
AUX_RGBImageRec *Imagen;
bool bResultado=false;

if (szNombreFichero) // Comprobamos que el nombre de fichero sea correcto
{
hFichero=fopen(szNombreFichero,"r"); // Comprobamos si el fichero existe (Si podemos abrirlo)

if (hFichero) // ¿Existe el fichero?
{
fclose(hFichero); // Cerramos el handle
Crear(szNombreFichero);

Imagen=auxDIBImageLoad(szNombreFichero); // Cargamos el BMP
m_nAncho=Imagen->sizeX;
m_nAlto=Imagen->sizeY;

glTexImage2D(GL_TEXTURE_2D, 0, 3, m_nAncho, m_nAlto, 0, GL_RGB, GL_UNSIGNED_BYTE, Imagen->data);

bResultado=true;
}
}
delete Imagen->data;
delete Imagen;
return bResultado;
}

Transformación de la textura y Modos de aplicación de una textura (repeat,wrap,etc)

Se indica con la función:
El tamaño de una textura generalmente no es el mismo que el del polígono proyectado sobre el que se pega, existirán casos en que el tamaño de la textura será mayor que el del polígono proyectado y otros en que será menor.

Necesitamos especificar cómo se calculará el color final de los píxeles sobre el polígono proyectado, a partir de la imagen de textura. Por otro lado, quizás estemos interesados en que la textura se repita cada cierto intervalo de tiempo. Todo este comportamiento se fija a través de la función:

void glTexParameter{if}{v}(GLenum tipoTex, GLenum param, TYPE valor);

donde tipoTex puede ser GL_TEXTURE_1D o GL_TEXTURE_2D y param y valor pueden tomar los valores de las siguiente tabla:

Parámetro Valor
GL_TEXTURE_WRAP_S GL_CLAMP, GL_REPEAT
GL_TEXTURE_WRAP_T GL_CLAMP, GL_REPEAT
GL_TEXTURE_MAG_FILTER GL_NEAREST, GL_LINEAR
GL_TEXTURE_MIN_FILTER GL_NEAREST, GL_LINEAR,
GL_NEAREST_MIPMAP_NEAREST,
GL_NEAREST_MIPMAP_LINEAR,
GL_LINEAR_MIPMAP_NEAREST,
GL_LINEAR_MIPMAP_LINEAR
GL_TEXTURE_BORDER_COLOR cuatro valores en el intervalo [0...1]

Un ejemplo de su uso es el siguiente:
glTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);

Mapeo de la textura en una superficie

Se inicializa la textura antes de indicar el tipo de la superficie por ejemplo:
glTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
glTexParameterfv(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
La primera permite que las texturas se repitan en horizontal, y la segunda,
en vertical.
Con este cambio, podríamos mapear las texturas con coordenadas mayores
a 1, de manera que las texturas se repetirían, de esta manera:
glBindTexture(GL_TEXTURE_2D,texture_floor);
glBegin(GL_QUADS);
glTexCoord2d(0.0,0.0);
glVertex3f(-6.0,0.0,-6.0);
glTexCoord2d(0.0,6.0);
glVertex3f(-6.0,0.0,6.0);
glTexCoord2d(6.0,6.0);
glVertex3f(6.0,0.0,6.0);
glTexCoord2d(6.0,0.0);
glVertex3f(6.0,0.0,-6.0);
glEnd();

5.- Programa

Previo 8

2007-05-08T08:29:00.000-07:00

Programa que crea 2 cubos, dos luces, utiliza textura y materiales

#include GL/glut.h
#include stdlib.h
#include stdio.h
#include math.h
#include "bitmap.h"
int Width;
int Height;
int bd,bi;
BITMAPINFO *BitmapInfo;
GLubyte *BitmapBits;
char *nomimage;
float xRot=0;
float yRot=0;

void init(void)
{
bd=0;
bi=0;
//glClearColor (0.0, 0.0, 1.0, 0.0);
glClear( GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT);
//glEnable(GL_DEPTH_TEST);
glShadeModel (GL_SMOOTH);

}
void carcatex(){
BitmapBits = LoadDIBitmap(nomimage, &BitmapInfo);
glTexImage2D(GL_TEXTURE_2D,0,3,BitmapInfo->bmiHeader.biWidth,BitmapInfo->bmiHeader.biHeight,0,GL_RGB,GL_UNSIGNED_BYTE,BitmapBits);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
//glTexEnvi(GL_TEXTURE_ENV,GL_TEXTURE_ENV_MODE,GL_BLEND);
glTexImage2D(GL_TEXTURE_2D, 0, 3, 128,128,0,GL_RGB,GL_UNSIGNED_BYTE,BitmapBits);
}
void cmaterial (x,y){
float colorf[4]={0.0,0.4,0,1};
float colora[4]={0.2,.4,1,1};
float colord[4]={0.3,0,1,1};
float colori[4]={0.5,.0,0,1};
float colors[4]={0.5,.6,0,1};
float colorin[4]={0.0,.6,0,1};
glShadeModel(GL_SMOOTH);
glPushMatrix();
glRotatef(45,0,1,1);
glTranslatef(x,y,0);
/* Caras transversales */
nomimage="mountain.bmp"; //Nombre de la imagen
carcatex();
glMaterialfv(GL_FRONT, GL_DIFFUSE, colord );
glEnable(GL_TEXTURE_2D);
glBegin( GL_QUADS );
/* Vertical hacia atras */
glTexCoord2f(0.0, 0.0);
glVertex3f( 1, 0, 0 );
glTexCoord2f(1.0, 0.0);
glVertex3f( 0, 0, 0 );
glTexCoord2f(1.0, 1.0);
glVertex3f( 0, 1, 0 );
glTexCoord2f(0.0, 1.0);
glVertex3f( 1, 1, 0 );
glEnd();
glMaterialfv(GL_FRONT,GL_SPECULAR, colori );
nomimage="mountain1.bmp";
carcatex();
glEnable(GL_TEXTURE_2D);
glBegin( GL_QUADS );
/* Superior, horizontal */
glTexCoord2f(0.0, 0.0);
glVertex3f( 1, 1, 1 );
glTexCoord2f(1.0, 0.0);
glVertex3f( 0, 1, 1 );
glTexCoord2f(1.0, 1.0);
glVertex3f( 0, 1, 0 );
glTexCoord2f(0.0, 1.0);
glVertex3f( 1, 1, 0 );
glEnd();
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, colorf );
nomimage="mountain2.bmp";
carcatex();
glEnable(GL_TEXTURE_2D);
glBegin( GL_QUADS );
/*Vertical delantera*/
glTexCoord2f(0.0, 0.0);
glVertex3f( 1, 0, 1 );
glTexCoord2f(1.0, 0.0);
glVertex3f( 1, 0, 0 );
glTexCoord2f(1.0, 1.0);
glVertex3f( 1, 1, 0 );
glTexCoord2f(0.0, 1.0);
glVertex3f( 1, 1, 1 );
glEnd();
glMaterialfv(GL_FRONT, GL_EMISSION, colorin );
nomimage="mountain3.bmp";
carcatex();
glEnable(GL_TEXTURE_2D);
glBegin( GL_QUADS );
/*Inferior */
glTexCoord2f(0.0, 0.0);
glVertex3f( 0, 0, 1 );
glTexCoord2f(1.0, 0.0);
glVertex3f( 0, 0, 0 );
glTexCoord2f(1.0, 1.0);
glVertex3f( 0, 1, 0 );
glTexCoord2f(0.0, 1.0);
glVertex3f( 0, 1, 1 );
glEnd();
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, colora );
/* Costados */
nomimage="mountain4.bmp";
carcatex();
glEnable(GL_TEXTURE_2D);
glBegin( GL_QUADS );
glTexCoord2f(0.0, 0.0);
glVertex3f( 1, 0, 1 );
glTexCoord2f(1.0, 0.0);
glVertex3f( 1, 0, 0 );
glTexCoord2f(1.0, 1.0);
glVertex3f( 0, 0, 0 );
glTexCoord2f(0.0, 1.0);
glVertex3f( 0, 0, 1 );
glEnd();
glMaterialfv(GL_FRONT, GL_AMBIENT, colors );
nomimage="aide.bmp"; //fotografia
carcatex();
glEnable(GL_TEXTURE_2D);
glBegin( GL_QUADS );
glTexCoord2f(0.0f, 1.0f);
glVertex3f( 1, 0, 1 );
glTexCoord2f(1.0f, 1.0f);
glVertex3f( 1, 1, 1 );
glTexCoord2f(1.0f, 0.0f);
glVertex3f( 0, 1, 1 );
glTexCoord2f(0.0f, 0.0f);
glVertex3f( 0, 0, 1 );
glEnd();
glPopMatrix();
}
void cmaterial1 (x,y){
float colorf[4]={0.0,0.4,0,1};
float colora[4]={0.2,.4,1,1};
float colord[4]={0.3,0,1,1};
float colori[4]={0.5,.0,0,1};
float colors[4]={0.5,.6,0,1};
float colorin[4]={0.0,.6,0,1};
glShadeModel(GL_SMOOTH);
glPushMatrix();
glRotatef(45,0,1,1);
glTranslatef(x,y,0);
/* Caras transversales */
glBegin( GL_QUADS );
/* Vertical hacia atras */
glVertex3f( 1, 0, 0 );
glVertex3f( 0, 0, 0 );
glVertex3f( 0, 1, 0 );
glVertex3f( 1, 1, 0 );
glEnd();

glMaterialfv(GL_FRONT,GL_SPECULAR, colori );
glBegin( GL_QUADS );
/* Superior, horizontal */
glVertex3f( 1, 1, 1 );
glVertex3f( 0, 1, 1 );
glVertex3f( 0, 1, 0 );
glVertex3f( 1, 1, 0 );
glEnd();
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, colorf );
glBegin( GL_QUADS );
/*Vertical delantera*/
glVertex3f( 1, 0, 1 );
glVertex3f( 1, 0, 0 );
glVertex3f( 1, 1, 0 );
glVertex3f( 1, 1, 1 );
glEnd();
glMaterialfv(GL_FRONT, GL_EMISSION, colorin );
glBegin( GL_QUADS );
/*Inferior */
glVertex3f( 0, 0, 1 );
glVertex3f( 0, 0, 0 );
glVertex3f( 0, 1, 0 );
glVertex3f( 0, 1, 1 );
glEnd();
glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, colora );
/* Costados */
glBegin( GL_QUADS );
glVertex3f( 1, 0, 1 );
glVertex3f( 1, 0, 0 );
glVertex3f( 0, 0, 0 );
glVertex3f( 0, 0, 1 );
glEnd();
glMaterialfv(GL_FRONT, GL_AMBIENT, colors );
glBegin( GL_QUADS );
glVertex3f( 1, 0, 1 );
glVertex3f( 1, 1, 1 );
glVertex3f( 0, 1, 1 );
glVertex3f( 0, 0, 1 );
glEnd();
glPopMatrix();
}
void display(void)
{
GLfloat light_ambient[]={0.0, 0.0, 0.0, 1.0};
GLfloat light_diffuse[]={1.0, 1.0, 1.0, 1.0};
GLfloat light_specular[]={1.0, 1.0, 1.0, 1.0};
GLfloat light_position[]={xRot, yRot, 1.0, 1.0};
GLfloat light1_ambient[]={0.0, 0.0, 0.0, 1.0};
GLfloat light1_diffuse[]={.5, .5, .5, .5};
GLfloat light1_specular[]={.1, .1, .1, .1};
GLfloat light1_position[]={1.0, 1.0, 10, 10.0};
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity (); /* clear the matrix */
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glLightfv(GL_LIGHT0, GL_AMBIENT, light_ambient);
glLightfv(GL_LIGHT0, GL_DIFFUSE, light_diffuse);
glLightfv(GL_LIGHT0, GL_SPECULAR, light_specular);
glLightfv(GL_LIGHT0, GL_POSITION, light_position);
glLightfv(GL_LIGHT1, GL_AMBIENT, light1_ambient);
glLightfv(GL_LIGHT1, GL_DIFFUSE, light1_diffuse);
glLightfv(GL_LIGHT1, GL_SPECULAR, light1_specular);
glLightfv(GL_LIGHT1, GL_POSITION, light1_position);
glEnable(GL_LIGHT0);
glEnable(GL_LIGHT1);
glEnable( GL_LIGHTING );
if(bi==1){
glDisable( GL_LIGHT0 );
glEnable( GL_LIGHT1 );}
if(bi==2){
glEnable( GL_LIGHT0 );
glDisable( GL_LIGHT1 );}
cmaterial(-1,1);
cmaterial1(-1,-1);
glFlush ();
}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}
void onMouse(int button, int state, int x, int y)
{
int aux;
if ( (button == GLUT_LEFT_BUTTON) & (state == GLUT_DOWN) ) {
bi=1;
}
if ( (button == GLUT_RIGHT_BUTTON) & (state == GLUT_DOWN) ) {
bi=2;
}
display();
}
void keyboard(int key, int x, int y)
{
if(key == GLUT_KEY_UP)
xRot-= 0.2f;
if(key == GLUT_KEY_DOWN)
xRot += 0.2f;
if(key == GLUT_KEY_LEFT)
yRot -= 0.2f;
if(key == GLUT_KEY_RIGHT)
yRot += 0.2f;
if(key > 1.0f)
xRot = 0.0f;
if(key < 0.0f)
xRot = 1.0f;
if(key > 1.0f)
yRot = 0.0f;
if(key < 0.0f)
yRot = 1.0f;
// Refresh the Window
glutPostRedisplay();
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (300,230);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutMouseFunc(onMouse);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

LIBRERIA AUXILIAR PARA CARGAR LA TEXTURA BITMAP.C

#include "bitmap.h"
#include stdio.h
#include stdlib.h
#include errno.h

#ifdef WIN32
GLubyte * /* O - Bitmap data */
LoadDIBitmap(const char *filename, /* I - File to load */
BITMAPINFO **info) /* O - Bitmap information */
{
FILE *fp; /* Open file pointer */
GLubyte *bits; /* Bitmap pixel bits */
int bitsize; /* Size of bitmap */
int infosize; /* Size of header information */
BITMAPFILEHEADER header; /* File header */

/* Try opening the file; use "rb" mode to read this *binary* file. */
if ((fp = fopen(filename, "rb")) == NULL)
return (NULL);
/* Read the file header and any following bitmap information... */
if (fread(&header, sizeof(BITMAPFILEHEADER), 1, fp) < 1)
{
/* Couldn't read the file header - return NULL... */
fclose(fp);
return (NULL);
}
if (header.bfType != 'MB') /* Check for BM reversed... */
{
/* Not a bitmap file - return NULL... */
fclose(fp);
return (NULL);
}
infosize = header.bfOffBits - sizeof(BITMAPFILEHEADER);
if ((*info = (BITMAPINFO *)malloc(infosize)) == NULL)
{
/* Couldn't allocate memory for bitmap info - return NULL... */
fclose(fp);
return (NULL);
}
if (fread(*info, 1, infosize, fp) < infosize)
{
/* Couldn't read the bitmap header - return NULL... */
free(*info);
fclose(fp);
return (NULL);
}
/* Now that we have all the header info read in, allocate memory for *
* the bitmap and read *it* in... */
if ((bitsize = (*info)->bmiHeader.biSizeImage) == 0)
bitsize = ((*info)->bmiHeader.biWidth *
(*info)->bmiHeader.biBitCount + 7) / 8 *
abs((*info)->bmiHeader.biHeight);
if ((bits = malloc(bitsize)) == NULL)
{
/* Couldn't allocate memory - return NULL! */
free(*info);
fclose(fp);
return (NULL);
}
if (fread(bits, 1, bitsize, fp) < bitsize)
{
/* Couldn't read bitmap - free memory and return NULL! */
free(*info);
free(bits);
fclose(fp);
return (NULL);
}
/* OK, everything went fine - return the allocated bitmap... */
fclose(fp);
return (bits);
}

/*
* 'SaveDIBitmap()' - Save a DIB/BMP file to disk.
*
* Returns 0 on success or -1 on failure...
*/
int /* O - 0 = success, -1 = failure */
SaveDIBitmap(const char *filename, /* I - File to load */
BITMAPINFO *info, /* I - Bitmap information */
GLubyte *bits) /* I - Bitmap data */
{
FILE *fp; /* Open file pointer */
int size, /* Size of file */
infosize, /* Size of bitmap info */
bitsize; /* Size of bitmap pixels */
BITMAPFILEHEADER header; /* File header */

/* Try opening the file; use "wb" mode to write this *binary* file. */
if ((fp = fopen(filename, "wb")) == NULL)
return (-1);
/* Figure out the bitmap size */
if (info->bmiHeader.biSizeImage == 0)
bitsize = (info->bmiHeader.biWidth *
info->bmiHeader.biBitCount + 7) / 8 *
abs(info->bmiHeader.biHeight);
else
bitsize = info->bmiHeader.biSizeImage;
/* Figure out the header size */
infosize = sizeof(BITMAPINFOHEADER);
switch (info->bmiHeader.biCompression)
{
case BI_BITFIELDS :
infosize += 12; /* Add 3 RGB doubleword masks */
if (info->bmiHeader.biClrUsed == 0)
break;
case BI_RGB :
if (info->bmiHeader.biBitCount > 8 &&
info->bmiHeader.biClrUsed == 0)
break;
case BI_RLE8 :
case BI_RLE4 :
if (info->bmiHeader.biClrUsed == 0)
infosize += (1 <<>bmiHeader.biBitCount) * 4;
else
infosize += info->bmiHeader.biClrUsed * 4;
break;
}
size = sizeof(BITMAPFILEHEADER) + infosize + bitsize;
/* Write the file header, bitmap information, and bitmap pixel data... */
header.bfType = 'MB'; /* Non-portable... sigh */
header.bfSize = size;
header.bfReserved1 = 0;
header.bfReserved2 = 0;
header.bfOffBits = sizeof(BITMAPFILEHEADER) + infosize;
if (fwrite(&header, 1, sizeof(BITMAPFILEHEADER), fp) < sizeof(BITMAPFILEHEADER))
{
/* Couldn't write the file header - return... */
fclose(fp);
return (-1);
}
if (fwrite(info, 1, infosize, fp) < infosize)
{
/* Couldn't write the bitmap header - return... */
fclose(fp);
return (-1);
}
if (fwrite(bits, 1, bitsize, fp) < bitsize)
{
/* Couldn't write the bitmap - return... */
fclose(fp);
return (-1);
}
/* OK, everything went fine - return... */
fclose(fp);
return (0);
}

#else /* !WIN32 */
/*
* Functions for reading and writing 16- and 32-bit little-endian integers.
*/
static unsigned short read_word(FILE *fp);
static unsigned int read_dword(FILE *fp);
static int read_long(FILE *fp);
static int write_word(FILE *fp, unsigned short w);
static int write_dword(FILE *fp, unsigned int dw);
static int write_long(FILE *fp, int l);

/*
* 'LoadDIBitmap()' - Load a DIB/BMP file from disk.
*
* Returns a pointer to the bitmap if successful, NULL otherwise...
*/
GLubyte * /* O - Bitmap data */
LoadDIBitmap(const char *filename, /* I - File to load */
BITMAPINFO **info) /* O - Bitmap information */
{
FILE *fp; /* Open file pointer */
GLubyte *bits; /* Bitmap pixel bits */
GLubyte *ptr; /* Pointer into bitmap */
GLubyte temp; /* Temporary variable to swap red and blue */
int x, y; /* X and Y position in image */
int length; /* Line length */
int bitsize; /* Size of bitmap */
int infosize; /* Size of header information */
BITMAPFILEHEADER header; /* File header */

/* Try opening the file; use "rb" mode to read this *binary* file. */
if ((fp = fopen(filename, "rb")) == NULL)
return (NULL);
/* Read the file header and any following bitmap information... */
header.bfType = read_word(fp);
header.bfSize = read_dword(fp);
header.bfReserved1 = read_word(fp);
header.bfReserved2 = read_word(fp);
header.bfOffBits = read_dword(fp);
if (header.bfType != BF_TYPE) /* Check for BM reversed... */
{
/* Not a bitmap file - return NULL... */
fclose(fp);
return (NULL);
}
infosize = header.bfOffBits - 18;
if ((*info = (BITMAPINFO *)malloc(sizeof(BITMAPINFO))) == NULL)
{
/* Couldn't allocate memory for bitmap info - return NULL... */
fclose(fp);
return (NULL);
}
(*info)->bmiHeader.biSize = read_dword(fp);
(*info)->bmiHeader.biWidth = read_long(fp);
(*info)->bmiHeader.biHeight = read_long(fp);
(*info)->bmiHeader.biPlanes = read_word(fp);
(*info)->bmiHeader.biBitCount = read_word(fp);
(*info)->bmiHeader.biCompression = read_dword(fp);
(*info)->bmiHeader.biSizeImage = read_dword(fp);
(*info)->bmiHeader.biXPelsPerMeter = read_long(fp);
(*info)->bmiHeader.biYPelsPerMeter = read_long(fp);
(*info)->bmiHeader.biClrUsed = read_dword(fp);
(*info)->bmiHeader.biClrImportant = read_dword(fp);
if (infosize > 40)
if (fread((*info)->bmiColors, infosize - 40, 1, fp) < 1)
{
/* Couldn't read the bitmap header - return NULL... */
free(*info);
fclose(fp);
return (NULL);
}
/* Now that we have all the header info read in, allocate memory for *
* the bitmap and read *it* in... */
if ((bitsize = (*info)->bmiHeader.biSizeImage) == 0)
bitsize = ((*info)->bmiHeader.biWidth *
(*info)->bmiHeader.biBitCount + 7) / 8 *
abs((*info)->bmiHeader.biHeight);
if ((bits = malloc(bitsize)) == NULL)
{
/* Couldn't allocate memory - return NULL! */
free(*info);
fclose(fp);
return (NULL);
}
if (fread(bits, 1, bitsize, fp) < bitsize)
{
/* Couldn't read bitmap - free memory and return NULL! */
free(*info);
free(bits);
fclose(fp);
return (NULL);
}
/* Swap red and blue */
length = ((*info)->bmiHeader.biWidth * 3 + 3) & ~3;
for (y = 0; y < (*info)->bmiHeader.biHeight; y ++)
for (ptr = bits + y * length, x = (*info)->bmiHeader.biWidth;
x > 0;
x --, ptr += 3)
{
temp = ptr[0];
ptr[0] = ptr[2];
ptr[2] = temp;
}
/* OK, everything went fine - return the allocated bitmap... */
fclose(fp);
return (bits);
}

/*
* 'SaveDIBitmap()' - Save a DIB/BMP file to disk.
*
* Returns 0 on success or -1 on failure...
*/
int /* O - 0 = success, -1 = failure */
SaveDIBitmap(const char *filename, /* I - File to load */
BITMAPINFO *info, /* I - Bitmap information */
GLubyte *bits) /* I - Bitmap data */
{
FILE *fp; /* Open file pointer */
int size, /* Size of file */
infosize, /* Size of bitmap info */
bitsize; /* Size of bitmap pixels */

/* Try opening the file; use "wb" mode to write this *binary* file. */
if ((fp = fopen(filename, "wb")) == NULL)
return (-1);
/* Figure out the bitmap size */
if (info->bmiHeader.biSizeImage == 0)
bitsize = (info->bmiHeader.biWidth *
info->bmiHeader.biBitCount + 7) / 8 *
abs(info->bmiHeader.biHeight);
else
bitsize = info->bmiHeader.biSizeImage;
/* Figure out the header size */
infosize = sizeof(BITMAPINFOHEADER);
switch (info->bmiHeader.biCompression)
{
case BI_BITFIELDS :
infosize += 12; /* Add 3 RGB doubleword masks */
if (info->bmiHeader.biClrUsed == 0)
break;
case BI_RGB :
if (info->bmiHeader.biBitCount > 8 &&
info->bmiHeader.biClrUsed == 0)
break;
case BI_RLE8 :
case BI_RLE4 :
if (info->bmiHeader.biClrUsed == 0)
infosize += (1 <<>bmiHeader.biBitCount) * 4;
else
infosize += info->bmiHeader.biClrUsed * 4;
break;
}
size = sizeof(BITMAPFILEHEADER) + infosize + bitsize;
/* Write the file header, bitmap information, and bitmap pixel data... */
write_word(fp, BF_TYPE); /* bfType */
write_dword(fp, size); /* bfSize */
write_word(fp, 0); /* bfReserved1 */
write_word(fp, 0); /* bfReserved2 */
write_dword(fp, 18 + infosize); /* bfOffBits */
write_dword(fp, info->bmiHeader.biSize);
write_long(fp, info->bmiHeader.biWidth);
write_long(fp, info->bmiHeader.biHeight);
write_word(fp, info->bmiHeader.biPlanes);
write_word(fp, info->bmiHeader.biBitCount);
write_dword(fp, info->bmiHeader.biCompression);
write_dword(fp, info->bmiHeader.biSizeImage);
write_long(fp, info->bmiHeader.biXPelsPerMeter);
write_long(fp, info->bmiHeader.biYPelsPerMeter);
write_dword(fp, info->bmiHeader.biClrUsed);
write_dword(fp, info->bmiHeader.biClrImportant);
if (infosize > 40)
if (fwrite(info->bmiColors, infosize - 40, 1, fp) < 1)
{
/* Couldn't write the bitmap header - return... */
fclose(fp);
return (-1);
}
if (fwrite(bits, 1, bitsize, fp) < bitsize)
{
/* Couldn't write the bitmap - return... */
fclose(fp);
return (-1);
}
/* OK, everything went fine - return... */
fclose(fp);
return (0);
}

/*
* 'read_word()' - Read a 16-bit unsigned integer.
*/
static unsigned short /* O - 16-bit unsigned integer */
read_word(FILE *fp) /* I - File to read from */
{
unsigned char b0, b1; /* Bytes from file */
b0 = getc(fp);
b1 = getc(fp);
return ((b1 << 8) b0);
}

/*
* 'read_dword()' - Read a 32-bit unsigned integer.
*/
static unsigned int /* O - 32-bit unsigned integer */
read_dword(FILE *fp) /* I - File to read from */
{
unsigned char b0, b1, b2, b3; /* Bytes from file */
b0 = getc(fp);
b1 = getc(fp);
b2 = getc(fp);
b3 = getc(fp);
return ((((((b3 << 8) b2) << 8) b1) << 8) b0);
}

/*
* 'read_long()' - Read a 32-bit signed integer.
*/
static int /* O - 32-bit signed integer */
read_long(FILE *fp) /* I - File to read from */
{
unsigned char b0, b1, b2, b3; /* Bytes from file */
b0 = getc(fp);
b1 = getc(fp);
b2 = getc(fp);
b3 = getc(fp);
return ((int)(((((b3 << 8) b2) << 8) b1) << 8) b0);
}

/*
* 'write_word()' - Write a 16-bit unsigned integer.
*/
static int /* O - 0 on success, -1 on error */
write_word(FILE *fp, /* I - File to write to */
unsigned short w) /* I - Integer to write */
{
putc(w, fp);
return (putc(w >> 8, fp));
}

/*
* 'write_dword()' - Write a 32-bit unsigned integer.
*/
static int /* O - 0 on success, -1 on error */
write_dword(FILE *fp, /* I - File to write to */
unsigned int dw) /* I - Integer to write */
{
putc(dw, fp);
putc(dw >> 8, fp);
putc(dw >> 16, fp);
return (putc(dw >> 24, fp));
}

/*
* 'write_long()' - Write a 32-bit signed integer.
*/
static int /* O - 0 on success, -1 on error */
write_long(FILE *fp, /* I - File to write to */
int l) /* I - Integer to write */
{
putc(l, fp);
putc(l >> 8, fp);
putc(l >> 16, fp);
return (putc(l >> 24, fp));
}
#endif /* WIN32 */

LIBRERIA AUXILIAR BITMAP.H
#ifndef _BITMAP_H_
# define _BITMAP_H_
/*
* Include necessary headers.
*/
# include
# ifdef WIN32
# include
# include
# endif /* WIN32 */
/*
* Make this header file work with C and C++ source code...
*/
# ifdef __cplusplus
extern "C" {
# endif /* __cplusplus */

/*
* Bitmap file data structures (these are defined in under
* Windows...)
*
* Note that most Windows compilers will pack the following structures, so
* when reading them under MacOS or UNIX we need to read individual fields
* to avoid differences in alignment...
*/
# ifndef WIN32
typedef struct /**** BMP file header structure ****/
{
unsigned short bfType; /* Magic number for file */
unsigned int bfSize; /* Size of file */
unsigned short bfReserved1; /* Reserved */
unsigned short bfReserved2; /* ... */
unsigned int bfOffBits; /* Offset to bitmap data */
} BITMAPFILEHEADER;
# define BF_TYPE 0x4D42 /* "MB" */
typedef struct /**** BMP file info structure ****/
{
unsigned int biSize; /* Size of info header */
int biWidth; /* Width of image */
int biHeight; /* Height of image */
unsigned short biPlanes; /* Number of color planes */
unsigned short biBitCount; /* Number of bits per pixel */
unsigned int biCompression; /* Type of compression to use */
unsigned int biSizeImage; /* Size of image data */
int biXPelsPerMeter; /* X pixels per meter */
int biYPelsPerMeter; /* Y pixels per meter */
unsigned int biClrUsed; /* Number of colors used */
unsigned int biClrImportant; /* Number of important colors */
} BITMAPINFOHEADER;
/*
* Constants for the biCompression field...
*/
# define BI_RGB 0 /* No compression - straight BGR data */
# define BI_RLE8 1 /* 8-bit run-length compression */
# define BI_RLE4 2 /* 4-bit run-length compression */
# define BI_BITFIELDS 3 /* RGB bitmap with RGB masks */
typedef struct /**** Colormap entry structure ****/
{
unsigned char rgbBlue; /* Blue value */
unsigned char rgbGreen; /* Green value */
unsigned char rgbRed; /* Red value */
unsigned char rgbReserved; /* Reserved */
} RGBQUAD;
typedef struct /**** Bitmap information structure ****/
{
BITMAPINFOHEADER bmiHeader; /* Image header */
RGBQUAD bmiColors[256]; /* Image colormap */
} BITMAPINFO;
# endif /* !WIN32 */
/*
* Prototypes...
*/
extern GLubyte *LoadDIBitmap(const char *filename, BITMAPINFO **info);
extern int SaveDIBitmap(const char *filename, BITMAPINFO *info,
GLubyte *bits);
# ifdef __cplusplus
}
# endif /* __cplusplus */
#endif /* !_BITMAP_H_ */

Nota: Para observar el texturizado es necesario tener las imagenes

Componentes de la Iluminacion Especular

2007-05-02T11:39:00.000-07:00

Previo Practica 7

2007-04-16T14:54:00.000-07:00

#include string.h
#include stdio.h
#include GL/glut.h
#include GL/gl.h
#include windows.h
#include math.h
#include stdarg.h
#include malloc.h
/* Windows parameters */
#define WIDTH 600
#define HEIGHT 600
#define TITLE "GLUT Demo: Using Subwindows"
void conv(void);
void onMouse(int button, int state, int x, int y);
void mano(void);
void Humanoide(void);
void Movimiento(void);
void onMouse2(int button, int state, int x, int y);
void onMotion2(int x, int y) ;
void onMotion(int x, int y);
void idle2(void);
int winIdMain;
int winIdSub;
int xo,im,yo,alpha,beta,ven,ven2,inif,aux;
int winIdSub2;
float xf,yf;
char xm[3]="000";
char ym[3]="000";
float r1,r2,r3,r4,r5,r6,rmu1,xmu,ymu,zmu,zp,xp;
float r7,r8,r9,r10,r11,r12,r13,r14,r15;
float x,y,z,brazod, brazoi, pied, piei;
int k=0;
xf=150;
yf=200;
ven=0;
ven2=0;
inif=0;
void init(void)
{
glClear (GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT);
}
void text(GLuint x, GLuint y, GLfloat scale,char *format,char *format2) { //Funcion que escribe texto
va_list args;
char buffer[255], *p;
GLfloat font_scale = 119.05f + 33.33f;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0,
glutGet(GLUT_WINDOW_HEIGHT));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glTranslatef(x, y, 0.0);
glScalef(scale/font_scale, scale/font_scale, scale/font_scale);
//len = (int) strlen(format);
glutStrokeCharacter(GLUT_STROKE_ROMAN, 40);
for(p = buffer; *p; p++)
glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
glutStrokeCharacter(GLUT_STROKE_ROMAN, 44);
va_start(args, format2);
vsprintf(buffer, format2, args);
va_end(args);
//len = (int) strlen(format2);
for(p = buffer; *p; p++)
glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
glutStrokeCharacter(GLUT_STROKE_ROMAN, 41);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
void fractal(void){ //Funcion que calcula el fractal
int ran;
ran = rand()%4;
if(ran==1){
xf=(50+xf)/2;
yf=(200+yf)/2;
}
if(ran==2){
xf=(250+xf)/2;
yf=(200+yf)/2;
}
if(ran==3){
xf=(150+xf)/2;
yf=(50+yf)/2;
}
}
void pinta(void){ //Funcion que pinta fractal
int xe,ze;
float x2,y2;
glColor3f(1.0,1.0,0.0);
glBegin(GL_POINTS);
glVertex3f(50.0f,200.0f,0.0f);
glVertex3f(250.0f,200.0f,0.0f);
glVertex3f(150.0f,50.0f,0.0f);
glEnd();
if(k==0){
glBegin(GL_POINTS);
glVertex3f(xf,yf,0);
glEnd();
k=1;
}
fractal();
glBegin(GL_POINTS);
glVertex3f(xf,yf,0);
glEnd();
}
void Display (void) //Funcion que muestra panatalla principal
{
/* Clean drawing board */
glutSetWindow(winIdMain);
//glLoadIdentity ();
pinta();
glFlush();
}
/* Another display function, this one will be
used to update the graphic subwindow */
void subDisplay (){ //Funcion que muestra contenido de las subventanas
/* Clear subwindow */
if(im==1){
glutSetWindow (winIdSub);
glutSetCursor (GLUT_CURSOR_CYCLE);
glutPositionWindow (20, 20);
glClearColor (0.0, 0.0, 1.0, 0.0);
glClear (GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT);
itoa(xo,xm,10);
itoa(yo,ym,10);
glColor3f(1.0,1.,0.0) ;
glutPassiveMotionFunc(onMotion2);
text(xo,(500-yo),20,xm,ym);
}
if(im==2){
glutSetWindow (winIdSub2);
glutSetCursor (GLUT_CURSOR_SPRAY);
glutPositionWindow (100, 100);
glClearColor (1.0, 0.0,0.0, 0.0);
glClear (GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT);
glColor3f(1.0,1.0,0.0);
glutMouseFunc(onMouse2);
glPushMatrix();
glScalef(0.2,.2,.2);
//glTranslatef(0,0,0.0f);
glPushMatrix();
glScalef(0.4,2.4,2.0);
glTranslatef(-21,2.75f,0.0f);
glRotatef(90,0,0,1);
mano( );
glPopMatrix();
glPushMatrix();
glScalef(0.4,2.4,2.0);
glTranslatef(21,2.75f,0.0f);
glRotatef(-90,0,0,1);
mano();
glPopMatrix();
Humanoide();
glPopMatrix();
glutSwapBuffers ();
}
}
/* Callback function for reshaping the main window */
void Reshape (int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, w, h, 0);
glMatrixMode(GL_MODELVIEW);
}
/* Callback function for reshaping the subwindow */
void subReshape (int w, int h)
{
glViewport (0, 0, w, h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
gluOrtho2D (0.0F, 1.0F, 0.0F, 1.0F);
}
void idle2(void) //maneja a la subventana
{
Movimiento();
subDisplay();
}
void idle (void) //maneja ventana principal
{
glutSetWindow (winIdMain);
glutPostRedisplay ();
glutSetWindow (winIdSub);
glutPostRedisplay ();
glutSetWindow (winIdSub2);
glutPostRedisplay ();
}
void onMouse(int button, int state, int x, int y) //Funcion de mouse ventana principal
{
if ( (button == GLUT_LEFT_BUTTON) & (state == GLUT_DOWN) ) {
if(ven2==1){
ven2=0;
glutDestroyWindow (winIdSub2);
goto yy;
}
if(ven==0){
winIdSub = glutCreateSubWindow (winIdMain, 500,500, 500 , 500);
glutMouseFunc(onMouse);
im=1;
glutDisplayFunc (subDisplay);
ven=1;
xo=x;
yo=y;
}
else ven=1;
yy: aux=0;
}
if ( (button == GLUT_RIGHT_BUTTON) & (state == GLUT_DOWN) ) {
if(ven==1){
ven=0;
glutDestroyWindow(winIdSub);
goto xx;
}
if(ven2==0){
winIdSub2 = glutCreateSubWindow (winIdMain, 500,500, 500 , 500);
glutMouseFunc(onMouse2);
im=2;
glutDisplayFunc (subDisplay);
glutIdleFunc (idle2);
ven2=1;
xo=x;
yo=y;
}
else ven2=1;
}
xx: aux=1;
}
void onMouse2(int button, int state, int x, int y) //Funcion mouse subventana
{
if ( (button == GLUT_LEFT_BUTTON) & (state == GLUT_DOWN) ) {
if(ven2==1){
ven2=0;
glutSetWindow (winIdMain);
main();
glutDestroyWindow (winIdSub2);
goto yy;
}
if(ven==0){
winIdSub = glutCreateSubWindow (winIdMain, 500,500, 500 , 500);
glutMouseFunc(onMouse);
im=1;
glutDisplayFunc (subDisplay);
ven=1;
xo=x;
yo=y;
}
else ven=1;
yy: aux=0;
}
}
void onMotion(int x, int y) { //Funcion de movimiento del mouse ventana principal
alpha = (alpha + (y - yo));
beta = (beta + (x - xo));
xo = x; yo = y;
glutPostRedisplay();
}
void onMotion2(int x, int y) { //Funcion de movimiento del mouse subventana
alpha = (alpha + (y - yo));
beta = (beta + (x - xo));
xo = x; yo = y;
glutPostRedisplay();
}
void keyboard(unsigned char key, int x, int y) //Evento de teclado
{
switch (key) {
case 27:
exit(0);
break;
}
}
int main (int argc, char **argv)
{
/* Glut initializations */
glutInit (&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGBA GLUT_DEPTH);
glutInitWindowPosition (20,20);
glutInitWindowSize (WIDTH, HEIGHT);
/* Main window creation and setup */
winIdMain = glutCreateWindow (TITLE);
// glutSetWindow (winIdMain);
init ();
glutDisplayFunc (Display);
glutReshapeFunc (Reshape);
glutMouseFunc(onMouse);
glutPassiveMotionFunc(onMotion);
glutKeyboardFunc(keyboard);
glutIdleFunc (idle);
glutMainLoop ();
return 0;
}
void Movimiento(void) //Movimiento aleatorio del humanoide
{
x=rand() %2;
y=rand() %2;
z=rand() %2;
brazod=rand()%80;
brazoi=rand()%80;
pied=rand()%80;
piei=rand()%80;
//ejes de rotación de la muñeca
xmu=rand() %2;
ymu=rand() %2;
zmu=rand() %2;
//àngulo de la muñeca
rmu1=rand()%90;
//angulos de los grados de libertad del dedo medio
r1=rand()%180;
r2=rand()%180;
r3=rand()%180;
//angulos de los grados de libertad del dedo indice
r4=rand()%180;
r5=rand()%180;
r6=rand()%180;
//angulos de los grados de libertad del dedo anular
r7=rand()%180;
r8=rand()%180;
r9=rand()%180;
//angulos de los grados de libertad del dedo meñique
r10=rand()%180;
r11=rand()%180;
r12=rand()%180;
//angulos de los grados de libertad del dedo pulgar
r13=rand()%180;
r14=rand()%180;
r15=rand()%180;
//ejes de rotación del dedo pulgar
zp=1;
xp=0;
}
void Humanoide(void) //Funcion del Humanoide
{
glPushMatrix();
//cabeza
glTranslatef(0.0f,2.5f,0.0f);
glutWireCube (0.5);
//tronco
glScalef(2.5,2.5,2.0);
glTranslatef(0.0f,-0.45f,0.0f);
glutWireCube (0.5);
//piernas
glPushMatrix();
glPushMatrix();
//pierna izquierda
glRotatef(piei,x,y,z);
glTranslatef(-0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);
glPushMatrix();
glTranslatef(0.0f,-0.7f,0.0f);
glutWireCube (0.5);
glPushMatrix();
glTranslatef(0.0f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();
//pies
glPushMatrix();
glTranslatef(.3f,-1.0f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();
//pierna derecha
glRotatef(pied,x,y,z);
glTranslatef(0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);
glPushMatrix();
glTranslatef(0.0f,-0.7f,0.0f);
glutWireCube (0.5);
glPushMatrix();
glTranslatef(0.0f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();
//pies
glTranslatef(-.3f,-1.0f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);

glPopMatrix();
//brazo derecho
glPushMatrix();
glRotatef(brazod,x,y,z);
glTranslatef(0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);
glPushMatrix();
glTranslatef(0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);
glPopMatrix();
glTranslatef(0.7f,0.0f,0.0f);
glScalef(.7,1,1.0);
glutWireCube (0.5);
//brazo izquierdo
glPopMatrix();
glRotatef(brazoi,x,y,z);
glTranslatef(-0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);
glPushMatrix();
glTranslatef(-0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);
glPopMatrix();
glTranslatef(-0.7f,0.0f,0.0f);
glScalef(.7,1,1.0);
glutWireCube (0.5);
glPopMatrix();

}
void mano(void) //Funcion de la mano
{
glRotatef(rmu1,xmu,ymu,zmu);
glPushMatrix();
glTranslatef(-0.1,0.0,0.0f);
glScalef(1.7,2.5,1.0);
glutWireCube (0.5);
glPopMatrix();
//dedo medio
glPushMatrix();
glTranslatef(0.0,0.9,0.0f);
glRotatef(r1,1,0,0);
glScalef(.3,1.2,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.45,0.0f);
glRotatef(r2,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.47,0.0f);
glRotatef(r3,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glPopMatrix();
//dedo indice
glPushMatrix();
glTranslatef(0.2,0.0,0.0f);
glTranslatef(0.0,0.9,0.0f);
glRotatef(r4,1,0,0);
glScalef(.3,1.2,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.45,0.0f);
glRotatef(r5,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.47,0.0f);
glRotatef(r6,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glPopMatrix();
//dedo anular
glPushMatrix();
glTranslatef(-0.2,0.0,0.0f);
glTranslatef(0.0,0.9,0.0f);
glRotatef(r7,1,0,0);
glScalef(.3,1.2,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.45,0.0f);
glRotatef(r8,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.47,0.0f);
glRotatef(r9,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glPopMatrix();
//dedo meñique
glPushMatrix();
glTranslatef(-0.4,0.0,0.0f);
glTranslatef(0.0,0.9,0.0f);
glRotatef(r10,1,0,0);
glScalef(.3,1.2,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.45,0.0f);
glRotatef(r11,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.47,0.0f);
glRotatef(r12,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glPopMatrix();
//dedo pulgar
glPushMatrix();
glTranslatef(0.45,-0.8,0.0f);
glTranslatef(0.0,0.9,0.0f);
glRotatef(r13,xp,0,zp);
glScalef(.3,1.2,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.45,0.0f);
glRotatef(r14,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glTranslatef(0.0,.47,0.0f);
glRotatef(r15,1,0,0);
glScalef(1.0,0.7,1.0);
glutWireCube (0.5);
glPopMatrix();
}

IMPLEMENTACION DE CURVAS Y SUPERFICIES CON NURBS

2007-04-15T11:53:00.001-07:00

Los NURBS (Non-Uniform Rational B-Splines) son entes matemáticos que definen exactamente una curva o superfice a partir de varios puntos de control, no necesariamente pertenecientes a la trayectoria, y unos pesos asociados a los mismos.
Cuanto mayor sea la complejidad de la curva, mayor será el número de puntos de control que deberá especificarse, pero, en todo caso, el número de puntos generados será menor que el necesario utilizando la aproximación tradicional por tramos rectos.

Curvas Nurbs
Son una herramienta importante para trabajar en 3D. Pueden ser una forma simple de modelar una superficie o un avanzado control para la animación, se definen por puntos de control, que controlan la forma de la curva. También consta de otros tipos de punto como los editables, que indica el principio o final de un segmento, y rectas que unen los puntos de control en una curva.

La geometría de la curva se define por: grados, puntos de control, nodos y regla de calculo.

Superficies Nurbs
Tienen los principios de las curvas nurbs, y se aplican igual, sin embargo una diferencia entre curvas y superficies es que las curvas se sometena una sola direccion y la superficie es bidireccional, estas bidireccion tiene un origen llamado normal, que determina la parte frontal o trasera de la misma.

Funciones básicas B-spline
Sea U = {u0, u1, . . . , ul} una secuencia no decreciente de números reales, es decir,
ui ≤ ui+1, i = 0, . . . , l−1. Los ui se denominan nodos y U vector de nodos. La i-esima función básica B-spline de grado p (orden p + 1), denotada por Ni,p(u), está definida recursivamente:
Nótese que las funciones Ni,0(u), i = 0, . . . , m son funciones salto, idénticamente nulas excepto en el intervalo semiabierto [ui, ui+1) (el cual puede tener longitud cero, pues ambos nodos pueden ser iguales). En cambio, para p > 0 la función Ni,p(u) es una combinación lineal de dos funciones básicas de grado (p−1). Por supuesto, la computación de las funciones básicas requiere especificar el vector de nodos U y
el grado p. La derivada de una función básica viene dada por:
Derivando sucesivas veces la expresión (2) obtenemos Nk i,p(u), la derivada k-esima de Ni,p(u), como
2.2 Superficies NURBS
Las superficies mas ampliamente usadas en los procesos de diseño en la industria son las superficies NURBS. Ello se explica por sus grandes ventajas, entre las que figuran sus capacidades para el diseño interactivo y su habilidad para representar de manera precisa formas cerradas, como cónicas y cuadricas. Además, las superficies NURBS incluyen a las superficies B-spline como casos particulares.
De hecho, muchas aplicaciones de CAD/CAM, realidad virtual, animación y visualización usan modelos basados en superficies NURBS y estas superficies están incluidas en muchos de los formatos mas populares en la industria, como IGES. También muchos estándares gráficos mas recientes, tales como PHIGS+ y OpenGL incluyen las superficies NURBS entre sus primitivas gráficas.
Una superficie NURBS9 S(u,v) de grado (p, q) es una función racional bivariada de la forma:
donde {wij}i,j representan los valores escalares de los pesos asociados a los puntos de control {Pij}i=0,...,n;j=0,...,m y con vectores de nodos U y V definidos .
2.3 Derivadas de superficies NURBS
Las derivadas de una superficie NURBS pueden calcularse a partir de las derivadas de A(u, v) y w(u, v) (el numerador y el denominador de la expresión (4) respectivamente) como:
donde dichas derivadas pueden ser fácilmente calculadas a partir de la expresión (3). La expresión (5) indica también que las derivadas de una superficie NURBS se obtienen de forma recursiva y que es posible su computación aplicando un esquema distribuido.

REPORTE PRACTICA 6

2007-04-12T08:15:00.000-07:00

//Segun la numeracion esta seria el reporte de la practica 5
//Programa que dibuja lineas, triangulos, y cuadros, se limpia la ventana cada 30 segundos
#include string.h
#include GL/glut.h
#include stdarg.h
#include windows.h
#include stdio.h
#include malloc.h

void pinta(void);
int opcion;
float r,b,g;
float x1,y1,z1;
char string[]="00:00:00";
x0=24;
opcion=1;

void init(void)
{
glClear(GL_COLOR_BUFFER_BIT);
}

void pinta(void){

int xe,ze;
float x2,y2;

if(opcion==1)
{

if(r>=1 b>=1 g>=1){
r=0;
b=0;
g=0;

}
r= r+.1;
b= b+.2;
g= g+.3;
glColor3f(r,b,g);
x1= rand()%500;
y1= rand()%500;
z1= rand()%500;
glBegin(GL_LINES);
glVertex3f(x1,y1,0);
x1= rand()%500;
y1= rand()%500;
z1= rand()%500;
glVertex3f(x1,y1,0);
glEnd();
}

if(opcion==3)
{
if(r>=1 b>=1 g>=1){
r=0;
b=0;
g=0;

}
r= r+.3;
b= b+.1;
g= g+.2;
glColor3f(r,b,g);
y1= rand()%12;
z1= rand()%12;
x2= rand()%500;
y2= rand()%500;

glPushMatrix();
glTranslatef(x2,y2,0);
glScalef(z1,y1,0);

glBegin(GL_LINES);
glVertex3f(10,2,0);
glVertex3f(20,2,0);
glEnd();

glBegin(GL_LINES);
glVertex3f(10,2,0);
glVertex3f(10,12,0);
glEnd();

glBegin(GL_LINES);
glVertex3f(20,2,0);
glVertex3f(20,12,0);
glEnd();

glBegin(GL_LINES);
glVertex3f(10,12,0);
glVertex3f(20,12,0);
glEnd();
glPopMatrix();
}

if(opcion==2)
{
if(r>=1 b>=1 g>=1){
r=0;
b=0;
g=0;

}
r= r+.2;
b= b+.3;
g= g+.1;
glColor3f(r,b,g);
x1= rand()%15;
y1= rand()%15;
x2= rand()%500;
y2= rand()%500;
glPushMatrix();
glTranslatef(x2,y2,0);
glScalef(x1,y1,0);
glBegin(GL_LINES);
glVertex3f(-10,1,0);
glVertex3f(10,1,0);
glEnd();

glBegin(GL_LINES);
glVertex3f(0,20,0);
glVertex3f(-10,1,0);
glEnd();

glBegin(GL_LINES);
glVertex3f(0,20,0);
glVertex3f(10,1,0);
glEnd();

glPopMatrix();
}
}

void display(void)
{
pinta();
glFlush();
}

void reshape(int w, int h)
{
glViewport(0, 0, w, h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluOrtho2D(0, w, h, 0);
glMatrixMode(GL_MODELVIEW);
}
//MANEJO DEL RETARDO
void TimerFunction()
{
glutPostRedisplay();
glutTimerFunc(3000, TimerFunction, 1);
}
void TimerFunction2()
{
glutPostRedisplay();
glClear(GL_COLOR_BUFFER_BIT);
glutTimerFunc(30000, TimerFunction2, 2);

}

//ACCIONES DEL MOUSE
void onMouse(int button, int state, int x, int y) {

if ( (button == GLUT_RIGHT_BUTTON) & (state == GLUT_DOWN) ) {
if(opcion==1)
opcion=1;
if(opcion==2)
opcion=1;
if(opcion==3)
opcion=2;
TimerFunction();
}

if ( (button == GLUT_LEFT_BUTTON) & (state == GLUT_DOWN) ) {
if(opcion==3)
opcion=3;
if(opcion==2)
opcion=3;
if(opcion==1)
opcion=2;
TimerFunction();
}
}

int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE GLUT_RGB);
glutInitWindowSize(500, 500);
glutCreateWindow("Reporte Practica 6");
glClearColor(0.0, 0.0, 0.0, 1.0);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutMouseFunc(onMouse);
glutTimerFunc(3000, TimerFunction, 1);
glutTimerFunc(30000, TimerFunction2, 2);
glutMouseFunc(onMouse);
glutMainLoop();
return 0;
}

Mejoramiento del algoritmo para pendientes de m=1 y m=-1 o mayores

2007-04-10T06:50:00.000-07:00

Mejoramiento del algoritmo de linea de Bresenham

void lineaBresenham(int xo,yo,x1,y1){
int dx=x1-xo;
int dy=y1-yo;
int x=xo;
int y=yo;
int do=2*dy-dx;
int dE=2*dy;
int dNE=2*(dy-dx);
int d=do;
int m= (y1-yo)/(x1-xo);
while(x != x1){
if(d <= 0){ //Direccion E
punto(x,y);
x=x+m;
d=d+dE;
}
else{ //Direccion NE
punto(x,y);
x=x+m;
y=y+1;
d=d+dNE;
}
}
}

En este codigo se hace uso de la pendiente para sumarloa la x para calcular la detla d, y asi poder manejar pendientesde m=1 y m=-1 o mayores en valor.

Previo Practica 5 Bitmap Mejorado version2

2007-04-10T06:46:00.000-07:00

La version pasada no hace grande y chico el nombre esta si.

#include GL/glut.h
#include stdlib.h
#include stdio.h
#include windows.h
#include math.h

void text(GLuint x, GLuint y, char* format); //Pinta el nombre
void onMouse(int button, int state, int x, int y); //Eventos boton del mouse
void onMotion(int x, int y); //Evento de movimiento del mouse
GLint incrementa = 0;
float alpha, beta;
int xo, yo;
void init(void)
{
glClearColor (0.0, 0.0, 1.0, 0.0);
glShadeModel (GL_FLAT);
}
void text(GLuint x, GLuint y, char* format) {
va_list args;
char buffer[255], *p;
GLfloat font_scale = 119.05f + 33.33f;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0,
glutGet(GLUT_WINDOW_HEIGHT));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glTranslatef(x, y, 0.0);
glRasterPos3f (90,180,0);
if(incrementa == 0)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_10, *p);
if(incrementa == 1)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_HELVETICA_10, *p);
if(incrementa == 2)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_8_BY_13, *p);
if(incrementa == 3)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_HELVETICA_12, *p);
if(incrementa == 4)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, *p);
if(incrementa == 5)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, *p);
if(incrementa == 6)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, *p);
if(incrementa >=7)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_24, *p);
if(incrementa <= -1)
for(p = buffer; *p; p++)
glutBitmapCharacter(GLUT_BITMAP_TIMES_ROMAN_10, *p);
//glRasterPos3f(500,0,0);
//glReadPixels(85,165,150,50,GL_RGB,GL_BITMAP,pix);
//glDrawPixels(150,50,GL_RGB,GL_BITMAP,pix);
//glColor3f(1.0,1.0,0.0);
//glBitmap (80,70,80, 180,10, 10,*p);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
void onMouse(int button, int state, int x, int y)
{
if ( (button == GLUT_LEFT_BUTTON) & (state == GLUT_DOWN) ) {
incrementa++;
xo=x;
yo=y;
}
if ( (button == GLUT_RIGHT_BUTTON) & (state == GLUT_DOWN) ) {
incrementa--;
xo=x;
yo=y;
}
}
void onMotion(int x, int y) {
alpha = (alpha + (y - yo));
beta = (beta + (x - xo));
xo = x; yo = y;
glutPostRedisplay();
}
void display(void)
{
GLint command = 1;
glClear (GL_COLOR_BUFFER_BIT);
//glColor3f (1.0, 1.0, 1.0);
glLoadIdentity (); /* clear the matrix */
/* viewing transformation */
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
if (command) {
glColor3f(1.0,1.,0.0) ;
text(250,200, "%s", "aide");
}
glFlush ();
}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}
/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (0,0);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutMouseFunc(onMouse);
glutMotionFunc(onMotion);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

Previo Practica 5 glutBitmapCharacter Creacion del Nombre

2007-04-09T16:56:00.000-07:00

#include GL/glut.h
#include stdlib.h
#include stdio.h
#include windows.h
#include math.h

void text(GLuint x, GLuint y, GLfloat scale, char* format);

GLint CrearFuente ();
void EscribirCadena (GLint fuente, char *cadena);
void aux(void);

void init(void)
{
glClearColor (0.0, 0.0, 1.0, 0.0);
glShadeModel (GL_FLAT);
}

void text(GLuint x, GLuint y, GLfloat scale, char* format) {
GLvoid *pix;
va_list args;
char buffer[255], *p;
GLfloat font_scale = 119.05f + 33.33f;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
pix=NULL;
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0,
glutGet(GLUT_WINDOW_HEIGHT));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);

glRasterPos3f (90,180,0);
for(p = buffer; *p; p++){
glutBitmapCharacter(GLUT_BITMAP_9_BY_15, *p);
//

}

glRasterPos3f(500,0,0);
glReadPixels(85,165,150,50,GL_RGB,GL_BITMAP,pix);
glDrawPixels(150,50,GL_RGB,GL_BITMAP,pix);
//glColor3f(1.0,1.0,0.0);
//glBitmap (80,70,80, 180,10, 10,*p);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
void aux(void){
GLvoid *pix;
pix=NULL;
glReadPixels(0,0,500,500,GL_RGB,GL_BITMAP,pix);
glRasterPos3f(0,250,0);
glColor3f(1.0,0.0,0.0);
glDrawPixels(500,500,GL_RGB,GL_BITMAP,pix);
}

void display(void)
{
GLint command = 1;
glClear (GL_COLOR_BUFFER_BIT);
//glColor3f (1.0, 1.0, 1.0);
glLoadIdentity (); /* clear the matrix */
/* viewing transformation */
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

if (command) {
glColor3f(1.0,1.,0.0) ;
text(100,100, 80, "%s", "AIDE");
}
//aux();
glFlush ();
}

void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (0,0);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();

return 0;
}

Previo Practica 5 glutStrokeCharacter Creacion del Nombre

2007-04-09T16:54:00.000-07:00

#include GL/glut.h
#include stdlib.h
#include stdio.h
#include windows.h
#include math.h

void text(GLuint x, GLuint y, GLfloat scale, char* format);
void onMouse(int button, int state, int x, int y);
void onMotion(int x, int y);
GLint incrementa = 10;
float alpha, beta;
int xo, yo;

void init(void)
{
glClearColor (0.0, 0.0, 1.0, 0.0);
glShadeModel (GL_FLAT);
}

void text(GLuint x, GLuint y, GLfloat scale, char* format) {
va_list args;
char buffer[255], *p;
GLfloat font_scale = 119.05f + 33.33f;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0,
glutGet(GLUT_WINDOW_HEIGHT));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glTranslatef(x, y, 0.0);
glScalef(scale/font_scale, scale/font_scale, scale/font_scale);
for(p = buffer; *p; p++)
glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
void onMouse(int button, int state, int x, int y)
{
if ( (button == GLUT_LEFT_BUTTON) & (state == GLUT_DOWN) ) {
incrementa = incrementa + 5;
xo=x;
yo=y;
}
if ( (button == GLUT_RIGHT_BUTTON) & (state == GLUT_DOWN) ) {
incrementa = incrementa - 5;
xo=x;
yo=y;
}
}

void onMotion(int x, int y) {
alpha = (alpha + (y - yo));
beta = (beta + (x - xo));
xo = x; yo = y;
glutPostRedisplay();
}

void display(void)
{
GLint command = 1;
glClear (GL_COLOR_BUFFER_BIT);
//glColor3f (1.0, 1.0, 1.0);
glLoadIdentity (); /* clear the matrix */
/* viewing transformation */
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

if (command) {
glColor3f(1.0,1.,0.0) ;
text(250,200, incrementa, "%s", "aide");
}

glFlush ();
}

void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (0,0);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutMouseFunc(onMouse);
glutMotionFunc(onMotion);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();

return 0;
}

PREVIO PRACTICA 5 RELOJ USO DE FUNCION TIMER

2007-04-09T16:49:00.000-07:00

#include GL/glut.h
#include stdlib.h
#include stdio.h
#include windows.h
#include math.h

void text(GLuint x, GLuint y, GLfloat scale, char* format);
void onMouse(int button, int state, int x, int y);
void onMotion(int x, int y);
void auxiliar(void);
void TimerFunction(int value);

int h1,h2,m1,m2,s1,s2;
GLint incrementa = 20;
float alpha, beta;
int xo, yo,sigue;
s1=0;
m1=0;
h1=0;
s2=0;
m2=0;
h2=0;
sigue=0;
void init(void)
{
glClearColor (0.0, 0.0, 1.0, 0.0);
glShadeModel (GL_FLAT);
}

void text(GLuint x, GLuint y, GLfloat scale, char *format) {
va_list args;
char buffer[255], *p;
GLfloat font_scale = 119.05f + 33.33f;
va_start(args, format);
vsprintf(buffer, format, args);
va_end(args);
glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, glutGet(GLUT_WINDOW_WIDTH), 0,
glutGet(GLUT_WINDOW_HEIGHT));
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glPushAttrib(GL_ENABLE_BIT);
glDisable(GL_LIGHTING);
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glTranslatef(x, y, 0.0);
glScalef(scale/font_scale, scale/font_scale, scale/font_scale);
for(p = buffer; *p; p++)
glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
glutStrokeCharacter(GLUT_STROKE_ROMAN, h2+48);
glutStrokeCharacter(GLUT_STROKE_ROMAN, h1+48);
glutStrokeCharacter(GLUT_STROKE_ROMAN, 58);
glutStrokeCharacter(GLUT_STROKE_ROMAN, m2+48);
glutStrokeCharacter(GLUT_STROKE_ROMAN, m1+48);
glutStrokeCharacter(GLUT_STROKE_ROMAN, 58);
glutStrokeCharacter(GLUT_STROKE_ROMAN, s2+48);
glutStrokeCharacter(GLUT_STROKE_ROMAN, s1+48);
glPopAttrib();
glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}
void TimerFunction(int value)
{
s1++;
if(s1==10){
s2++;
s1=0;
if(s2==6){
s2=0;
m1++;
if(m1==10){
m1=0;
m2++;
if(m2==6){
m2=0;
h1++;
if(h1==10){
h1=0;
if(h2==2){
m1=m2=s1=s2=h1=h2=0;
}
}
}
}
}
}
glutPostRedisplay();
if(sigue==1)
glutTimerFunc(1000,TimerFunction,1);
}

void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}
void onMouse(int button, int state, int x, int y)
{
if ( (button == GLUT_LEFT_BUTTON) & (state == GLUT_DOWN)) {
sigue=1;
auxiliar();
xo=x;
yo=y;
}

if ( (button == GLUT_RIGHT_BUTTON) & (state == GLUT_DOWN) ) {
sigue=0;

xo=x;
yo=y;
}

}

void onMotion(int x, int y) {
alpha = (alpha + (y - yo));
beta = (beta + (x - xo));
xo = x; yo = y;
glutPostRedisplay();
}

void display(void)
{
GLint command = 1;
glClear (GL_COLOR_BUFFER_BITGL_DEPTH_BUFFER_BIT);

glLoadIdentity (); /* clear the matrix */
/* viewing transformation */
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

if (command) {
glColor3f(1.0,1.,0.0) ;
text(250,200, incrementa, "%s","Reloj ");
}

glutSwapBuffers();
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (0,0);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutMouseFunc(onMouse);
glutMotionFunc(onMotion);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

void auxiliar(void){
if(sigue==1)
glutTimerFunc(1000,TimerFunction,1);

}

Previo Practica 5 parte 1

2007-04-09T16:15:00.000-07:00

API_GLUT

int glutCreateWindow (char *nombre)
Crea la ventana, y el parámetro es el nombre de la misma. nombre: cadena de caracteres con el nombre de la ventana. Devuelve un entero que es el identificador único de la ventana. Esta función crea una ventana principal. Cuando se crea una ventana, la ventana activa pasa a ser esta nueva ventana. Toda ventana lleva implícito un contexto de visualización de OpenGL. Este contexto es el que permite que la ventana creada con GLUT (o en su caso, con cualquier entorno de ventanas) se ponga en contacto con OpenGL. Las ventanas creadas con esta función no son visualizadas todavía. La visualización la llevará a cabo una función de respuesta al evento de redibujado de la ventana.

void glutInit (int *argc, char **argv)
argc: puntero al parámetro argc de la función main del programa.
argv: parámetro argv de la función main.
glutInit inicializa la librería GLUT, pudiéndosele pasar algún parámetro por línea de comandos a través de argc y argv. Esta rutina debe ser llamada una única vez al principio del programa. Ninguna otra función que no sea de inicialización puede llamarse antes. Si utilizamos alguna
función de inicialización (con el prefijo glutInit-) delante de ésta función, estamos fijando el estado por defecto de la aplicación al inicializarse.

void glutInitWindowSize (int ancho, int alto)
ancho: anchura de la ventana en pixels
alto: altura de la ventana en pixels
Esta rutina sirve para indicar el tamaño inicial de las ventanas que se creen.

void glutInitWindowPosition (int x, int y)
x: posición en x de la ventana en pixels
y: posición en y de la ventana en pixels
Con esta función fijamos la posición inicial de las ventanas que se creen. Inicializar la posición de la ventana en el escritorio.

void glutInitDisplayMode (unsigned int modo)
Inicializa el modo de visualización.
modo: modo de display. Es una composición mediante conectores “” de algunos de
los valores siguientes:
GLUT_RGBA: Selecciona una ventana en modo RGBA. Es el valor por defecto si no se indican ni GLUT_RGBA ni GLUT_INDEX.
GLUT_RGB: Lo mismo que GLUT_RGBA.
GLUT_INDEX: Seleciona una ventana en modo de índice de colores. Se impone sobre GLUT_RGBA.
GLUT_SINGLE: Selecciona una ventana en modo buffer simple. Es el valor por defecto.
GLUT_DOUBLE: Selecciona una ventana en modo buffer doble. Se impone sobre GLUT_SINGLE.
GLUT_ACCUM: Selecciona una ventana con un buffer acumulativo.
GLUT_ALPHA: Selecciona una ventana con una componente alfa del buffer de color.
GLUT_DEPTH: Selecciona una ventana con un buffer de profundidad.
GLUT_STENCIL: Selecciona una ventana con un buffer de estarcido.
GLUT_MULTISAMPLE: Selecciona una ventana con soporte multimuestra.
GLUT_STEREO : Selecciona una ventana estéreo.
GLUT_LUMINANCE: Selecciona una ventana con un modelo de color en tonos de gris.
Esta función fija el modo de display inicial con que se crearán las ventanas. Los dos valores que suelen darse en la mayoría de las aplicaciones son GLUT_RGBA, para fijar un modelo de color RGB con componente alfa, y GLUT_DOUBLE para seleccionar una ventana con doble buffer.

glutDisplayFunc(void (*func)(void));
La función func() se llamará cada vez que haya que redibujar la ventana.
GLUT no proporciona una función de respuesta por defecto para el redibujado, por lo que es obligatorio escribir una función de este tipo para cada ventana creada. Si se crea una ventana y no se registra la función de respuesta al redibujado, se produce un error.

glutInitPosition(int x, int y);
Posición x e y de la esquina superior izquierda de la nueva ventana, con respecto al escritorio en el que se trabaje.

glutKeyboardFunc(void (*func)(unsigned char key, int x, int y));
func: función de respuesta al evento.
Se utiliza para registrar la función que responde a eventos del teclado sobre la ventana activa. La función de respuesta debe tener como parámetros la tecla que se ha pulsado (su carácter ASCII) y la posición (x,y) del puntero del ratón en ese momento, relativa a la ventana. No es posible detectar las teclas de modificadores directamente (CTRL, ALT, ...). Debemos utilizar para ello la función glutGetModifiers. Si no se registra ninguna función, los eventos de teclado son ignorados.

glutMainLoop();
Esta rutina debe llamarse una vez en el programa. Puesto que implementa un bucle infinito (realmente el bucle termina cuando se produce un evento de cerrar aplicación), la función no termina nunca. Por ello es necesario registrar previamente las funciones callback y que, además, la llamada a esta función sea la última de main.

glutMouseFunc(void (*func)(int button, int state, int x, int y));
Registra para la ventana activa la función de respuesta a eventos del ratón. Los eventos de ratón se producen tanto cuando se pulsa como cuando se suelta un botón del ratón. Los parámetros de la función de respuesta deben ser el botón (GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON o GLUT_RIGHT_BUTTON), el estado del botón (GLUT_UP o GLUT_DOWN) y la posición (x,y) del puntero relativa a la ventana.
Cuando existe un menú asociado a un botón del ratón, el evento de pulsar ese botón es ignorado, prevaleciendo el menú sobre otras funcionalidades. Como en el caso del teclado, es posible detectar el uso de modificadores con la función glutGetModifiers. Si no registra una función de respuesta a eventos del ratón, éstos son ignorados.

glutReshapeFunc(void (*func)(int ancho, int alto));
Registra la función de respuesta al evento de redimensionamiento de la ventana activa. La función de respuesta debe tener como parámetros la anchura y la altura de la ventana tras el redimensionamiento. GLUT dispone, en este caso, de una función de respuesta por defecto, que se utiliza cuando no se registra ninguna función para este evento. El redimensionamiento de la ventana principal no genera ningún evento de redimensionamiento de sus subventanas, por lo que es necesario realizarlo explícitamente.

glutPostRedisplay();
Solicita el redibujado de la ventana actual.

glutSolidCone(Gldouble base, Gldouble height, Glint slices, Glint stacks);
Dibuja un cono sólido, con un radio de longitud base, una altura height, numero de divisiones alrededor del eje z (slices) y numero de divisiones a lo largo del eje z.

glutWireCone(Gldouble base, Gldouble height, Glint slices, Glint stacks);
Dibuja un cono con líneas, con un radio de longitud base, una altura height, numero de divisiones alrededor del eje z (slices) y numero de divisiones a lo largo del eje z.

glutSolidCube(Gldouble size);
Dibuja un cubo sólido, con size de longitud por lado.

glutWireCube(Gldouble size);
Dibuja un cubo con líneas, con size de longitud por lado.

glutSolidDodecahedron();
Dibuja un dodecaedro sólido.

glutWireDodecahedron();
Dibuja un dodecaedro con líneas.

glutSolidIcosahedron();
Dibuja un icosaedro sólido.

glutWireIcosahedron();
Dibuja un icosaedro con líneas.

glutSolidOctahedron();
Dibuja un octaedro sólido.

glutWireOctahedron();
Dibuja un octaedro con líneas.

glutSolidSphere(Gldouble radius, Glint slices, Glint stacks);
Dibuja una esfera sólido, los parámetros son el radio, numero de divisiones alrededor del eje z (slices) y numero de divisiones a lo largo del eje z.

glutWireSphere(Gldouble radius, Glint slices, Glint stacks);
Dibuja una esfera con líneas, los parámetros son el radio, numero de divisiones alrededor del eje z (slices) y numero de divisiones a lo largo del eje z.

glutSolidTetrahedron();
Dibuja un tetraedro sólido.

glutWireTetrahedron();
Dibuja un tetraedro con líneas.

glutSolidTorus(Gldouble innerRadius, Gldouble outerRadius, Glint nSides, Glint nRings);
Dibuja un toroide sólido, los parámetros son el radio interior, radio exterior, numero de divisiones radiales para cada sección nSides, y numero de secciones radiales nRings.

glutWireTorus(Gldouble innerRadius, Gldouble outerRadius, Glint nSides, Glint nRings);
Dibuja un toroide con líneas, los parámetros son el radio interior, radio exterior, numero de divisiones radiales para cada sección nSides, y numero de secciones radiales nRings.

glutSolidTeapot(Gldouble size);
Dibuja una tetera sólida, con un radio size.

glutWireTeapot(Gldouble size);
Dibuja una tetera con líneas con un radio size.

glutSpecialFunc(void (*func)(int key, int x, int y));
Registra para la ventana activa el evento de pulsar una tecla especial. El parámetro tecla puede ser GLUT_KEY_Fn para teclas de función (n=1, 2, ..., 12), GLUT_KEY_RIGHT, GLUT_KEY_LEFT, GLUT_KEY_UP, GLUT_KEY_DOWN, GLUT_KEY_PAGE_UP, GLUT_KEY_PAGE_DOWN, GLUT_KEY_HOME, GLUT_KEY_END , GLUT_KEY_INSERT, GLUT KEY F1 , GLUT KEY F2,GLUT KEY F3,GLUT KEY F4,GLUT KEY F5,GLUT KEY F6, GLUT KEY F7,GLUT KEY F8,GLUT KEY F9,GLUT KEY F10, GLUT KEY F11, GLUT KEY F12.

void glutSwapBuffers (void)
Intercambia los buffers de la ventana actual. Se utiliza en el modo de doble buffer. Esta importante característica de OpenGL (y de GLUT por extensión) hace que se reduzcan al mínimo los parpadeos durante el redibujado, especialmente si hay animaciones. La ventana tiene dos buffers: uno de ellos visible y el otro invisible. El dibujo se realiza en el buffer oculto y, al intercambiarlos, se dibuja todo de una vez, eliminando así el parpadeo. Este tema lo trataremos con detalle cuando veamos OpenGL.

glutTimerFunc(unsigned int msecs, (*func)(int value), int value);
msecs: Número de milisegundos del temporizador
func: Función de respuesta al evento
value: Valor que debe utilizarse para llamar a la función de respuesta Registra tanto un temporizador como la función de respuesta al mismo.
Debemos indicar el tiempo en milisegundos, un valor de identificación del temporizador y la función que responde al mismo, cuyo único parámetro debe ser el identificador del temporizador.

int glutGet (GLenum estado)
estado: variable concreta de estado para la que deseamos obtener información.
Devuelve un entero indicando el valor de la variable referida.
Esta función devuelve el valor de una variable de estado. El parámetro estado hace referencia a la variable de la que deseamos conocer su valor. Este parámetro es un valor de una enumeración, entre cuyos valores encontramos GLUT_WINDOW_X, GLUT_WINDOW_Y, para obtener la posición de la ventana activa, GLUT_WINDOW_WIDTH, GLUT_WINDOW_HIGHT, para obtener el tamaño de la ventana activa, GLUT_WINDOW_PARENT, para obtener el identificador de la ventana padre de la activa, etc.
GLUT WINDOW X X localizacion en pixeles respecto al origen,GLUT WINDOW Y Y localizacion relativa,GLUT WINDOW WIDTH ancho,GLUT WINDOW HEIGHT alto,GLUT WINDOW BUFFER SIZE numero de bits de la ventana para color puede ser tambien GLUT WINDOW RED SIZE para tono rojo, GLUT WINDOW GREEN SIZE tono verde,
GLUT WINDOW BLUE SIZE tono azul, y GLUT WINDOW ALPHA SIZE alfa.
GLUT WINDOW STENCIL SIZE numero de bits en el stencil buffer.
GLUT WINDOW DEPTH SIZE Number of bits in the current window’s depth buffer.
GLUT WINDOW ACCUM RED SIZE numero de bits acumulados en el buffer que son rojos,GLUT WINDOW ACCUM GREEN SIZE verdes, GLUT WINDOW ACCUM BLUE SIZE azules y GLUT WINDOW ACCUM ALPHA SIZE alfa.GLUT WINDOW DOUBLEBUFFER si esta activado el doble buffer, GLUT WINDOW RGBA si esta en modo RGBA, GLUT WINDOW PARENT numero de ventanas padres, GLUT WINDOW NUM CHILDREN numero de ventanas hijas, GLUT WINDOW COLORMAP SIZE tamaño del indice de color, GLUT WINDOW NUM SAMPLES numero de ejemplos, GLUT WINDOW STEREO si maneja stereo, GLUT WINDOW CURSOR para el cursor,GLUT SCREEN WIDTH ancho de pantalla en pixeles,GLUT SCREEN HEIGHT alto en pixeles en pantalla, GLUT SCREEN WIDTH MM ancho de pantalla en milimetros,GLUT SCREEN HEIGHT MM alto de pantalla en milimetros, GLUT MENU NUM ITEMS numero de items en el menu, GLUT DISPLAY MODE POSSIBLE modo de pantalla soportado, GLUT INIT DISPLAY MODE pantalla incial con mascara, GLUT INIT WINDOW X valor inicial de la x, GLUT INIT WINDOW Y valor inicial de la posicion y,GLUT INIT WINDOW WIDTH ancho inicial de la pantalla, GLUT INIT WINDOW HEIGHT alto inicial de la pantalla, GLUT ELAPSED TIME numero en milisegundos desde que glutIni llamo a glutGet.

int glutDeviceGet (GLenum info)
info: dispositivo sobre el que obtener información
Devuelve información sobre el dispositivo indicado
Obtener información sobre los dispositivos del sistema. El parámetro info indica el dispositivo: GLUT_HAS_KEYBOARD, GLUT_HAS_MOUSE, GLUT_NUM_MOUSE_BUTTONS, etc. En los dos primeros casos, la función devuelve 0 si no existe el dispositivo y otro valor si existe. En el tercer caso, devuelve el número de botones del ratón. Existen valores de la enumeración para otros dispositivos.

int glutGetModifiers (void)
Devuelve un valor que indica el modificador que se ha pulsado.
Devuelve la tecla modificadora que ha sido pulsada: GLUT_ACTIVE_SHIFT, GLUT_ACTIVE_CTRL o GLUT_ACTIVE_ALT. La librería GLUT permite realizar otras muchas acciones, referentes al manejo del color, a la visualización de texto, al control de las capas y al diseño de algunas primitivas geométricas.

void glutIdleFunc (void (*funcion) (void))
funcion: función de respuesta al evento
Registra la función de respuesta al evento idle. Este evento se produce cada vez que el sistema no tiene ningún otro evento que atender. En OpenGL se suele utilizar para hacer animaciones. La función que da respuesta al evento debe ser lo más pequeña posible para evitar mermas en la capacidad de interacción de la aplicación.

void glutMenuStatusFunc (void (*funcion) (int estado, int x, int y))
funcion: función de respuesta al evento
Registra la función que responde al evento que se produce cuando se despliega o se pliega un menú. El parámetro estado puede valer GLUT_MENU_IN_USE cuando se despliega un menú, o GLUT_MENU_NOT_IN_USE cuando se pliega. Los valores (x,y) son la posición del puntero del ratón en cada caso.

void glutMotionFunc (void (*funcion) (int x, int y))
La función func(x, y) se llamará cuando el mouse se mueva mientras está pulsado uno de sus botones.
Registra para la ventana activa la función de respuesta a movimientos del ratón cuando se mantiene pulsado algún botón del mismo. Los parámetros (x,y) indican la posición del puntero en coordenadas relativas a la ventana.

void glutPassiveMotionFunc (void (*funcion) (int x, int y))
Registra para la ventana activa la función de respuesta a movimientos del ratón cuando no se mantiene pulsado ningún botón del mismo. Los parámetros (x,y) indican la posición del puntero en coordenadas relativas a la ventana.

void glutVisibilityFunc (void (*funcion) (int estado)):
Registra para la ventana activa la función de respuesta al evento de cambios en la visibilidad de la ventana. El parámetro estado puede ser GLUT_NOT_VISIBLE o GLUT_VISIBLE.

void glutEntryFunc (void (*funcion) (int estado)):
Registra para la ventana activa la función de respuesta al evento de entrada y salida del ratón en el área de la ventana. El parámetro estado puede ser GLUT_LEFT o GLUT_ENTERED.

int glutCreateSubWindow (int idVentanaPadre, int x, int y, int ancho, int alto)
idVentanaPadre: identificador de la ventana padre de la subventana
x, y: posición (x,y) en pixels de la subventana, relativa a la ventana padre ancho, alto: anchura y altura de la subventana en pixels. Devuelve un identificador único para la subventana
Esta rutina crea una subventana, hija de la ventana identificada por idVentanaPadre. La ventana activa de la aplicación pasa a ser la nueva subventana. Como en el caso de las ventanas principales, las subventanas llevan asociado un contexto de visualización, y su modo de display viene dado por las especificaciones iniciales (no así su tamaño y su posición, que en este caso son dados explícitamente).

void glutSetWindow (int idVentana)
idVentana: identificador de la ventana
Fija la ventana identificada por idVentana como ventana activa.

int glutGetWindow (void)
Devuelve el identificador de la ventana activa

void glutDestroyWindow (int idVentana)
idVentana: identificador de la ventana. Destruye la ventana identificada por idVentana.

void glutPositionWindow (int x, int y)
x, y: posición (x,y) en pixels de la ventana
Solicita el cambio de la posición de la ventana actual en la pantalla. Si la ventana actual es principal, (x,y) se toma con referencia al origen de la pantalla. Si es una subventana, la distancia se toma con referencia al origen de la ventana padre.

void glutReshapeWindow (int ancho, int alto)
ancho: anchura de la ventana en pixels
alto: altura de la ventana el pixels
Solicita el cambio del tamaño de la ventana actual, dándole al ancho y el alto especificados.
Otras funciones referentes a las ventanas se muestran a continuación junto con una breve descripción.

void glutFullScreen (void):
Solicita que la ventana actual sea maximizada. Sólo funciona para ventanas principales.

void glutPopWindow (void):
Adelanta la ventana actual una posición en la pila de ventanas.

void glutPushWindow (void):
Retrasa la ventana actual una posición en la pila de ventanas.

void glutShowWindow (void):
Muestra la ventana actual.

void glutHideWindow (void):
Oculta la ventana actual.

void glutIconifyWindow (void):
Solicita la minimización de la ventana actual y su conversión en icono.

void glutSetWindowTitle (char *nombre):
Cambia el nombre de la ventana actual.

void glutSetIconTitle (char *nombre):
Da nombre a la ventana actual cuando está minimizada.

void glutSetCursor (int cursor):
Cambia el puntero del ratón cuando sobrevuela la ventana actual. El parámetro es un valor de una enumeración.
GLUT CURSOR RIGHT ARROW, GLUT CURSOR LEFT ARROW,GLUT CURSOR INFO,GLUT CURSOR DESTROY,GLUT CURSOR HELP,GLUT CURSOR CYCLE,GLUT CURSOR SPRAY,
GLUT CURSOR WAIT,GLUT CURSOR TEXT, GLUT CURSOR CROSSHAIR, GLUT CURSOR UP DOWN, GLUT CURSOR LEFT RIGHT, GLUT CURSOR TOP SIDE, GLUT CURSOR BOTTOM SIDE, GLUT CURSOR LEFT SIDE, GLUT CURSOR RIGHT SIDE, GLUT CURSOR TOP LEFT CORNER, GLUT CURSOR TOP RIGHT CORNER, GLUT CURSOR BOTTOM RIGHT CORNER, GLUT CURSOR BOTTOM LEFT CORNER, GLUT CURSOR FULL CROSSHAIR, GLUT CURSOR CROSSHAIR).,GLUT CURSOR NONE,GLUT CURSOR INHERIT.

int glutCreateMenu (void (*funcion) (int valor))
Esta función crea un menú (todavía sin opciones), y le asigna la función func(value). Esta función se llamará cada vez que una de las opciones del menú sea seleccionada por el usuario, y recibirá en value el código identificativo de la opción seleccionada. De esta manera, podremos definir que hace cada opción de menú. Devuelve un identificador de menú, que nos
servirá cuando tengamos que referirnos a él.
funcion: Función callback a la que se llama cuando se selecciona un ítem del menú.
El valor que se le pasa a la función identifica al ítem del menú.
Devuelve un identificador único para el menú.
Esta función crea un menú flotante asociado a la ventana actual y devuelve un identificador único para el mismo. Este menú pasa a ser el menú activo.

void glutSetMenu (int idMenu)
Esta función hace que el menú identificado como idmenu sea el menú actual.
Por defecto, el menú actual es el último que se ha creado.
idMenu: identificador del menú.
Esta función pone el menú identificado por idMenu como menú activo.

int glutGetMenu (void)
Devuelve un identificador de menú. Devuelve el identificador del menú activo.

void glutDestroyMenu (int idMenu)
idMenu: identificador del menú. Destruye el menú identificado por idMenu.

void glutAddMenuEntry (char *nombre, int valor)
Añade una opción de menú al menú actual. Esta opción se llamará nombre y
se identificará por el número valor.
nombre: cadena de caracteres que aparece en la opción del menú valor: identificador para el ítem del menú. Este valor es el que se pasa a la función de respuesta al menú.
Añade una entrada al final del menú activo, y la cadena que se visualiza es el nombre. Cuando el usuario selecciona esa opción, se llama a la función de respuesta con el valor como parámetro.

void glutAddSubMenu (char *nombre, int idMenu)
Añade una opción de menú que abrirá un submenú.
nombre: cadena de caracteres que aparece en la opción del menú principal.
idMenu: identificador del submenú asociado al ítem.
Crea un ítem del menú y le asocia un submenú que se despliega al ser seleccionada la entrada del menú principal. El submenú debe haber sido creado previamente como cualquier otro menú.

void glutChangeToSubMenu (int entrada, char *nombre, int valor):
Cambia un submenú por otro.

void glutRemoveMenuItem (int entrada):
Elimina una entrada del menú.

void glutDetachMenu (int boton):
Elimina la asociación entre el menú activo y el botón del ratón.

void glutAttachMenu (int boton)
boton: botón del ratón al que asociamos el menú.
Asocia el menú activo a un botón del ratón en la ventana activa, de manera que el menú se despliega cuando se pulsa el botón del ratón. El botón puede valer GLUT_LEFT_BUTTON, GLUT_MIDDLE_BUTTON o GLUT_RIGHT_BUTTON, para asociarlo al botón izquierdo, central o derecho respectivamente.

void glutChangeToMenuEntry (int entrada, char *nombre, int valor):
Cambia la entrada (el parámetro entrada indica el índice de la misma, empezando en 1) por otra diferente. Esta función sirve para modificar una opción del menú actual. El parámetro entry nos indica la opción a modificar (por ejemplo, para modificar la primera, entry = 1), name será el nuevo nombre de la opción y value el nuevo identificador que se le pasará a la función controladora de menú.

void glutEstablishOverlay(void);
Establece la capa.

void glutUseLayer(GLenum layer);
Usar capa.

void glutRemoveOverlay(void);
Remueve la capa actual.

void glutPostOverlayRedisplay(void);
Mostra la capa siguiente.

void glutShowOverlay(void);
Mostrar capa.

void glutHideOverlay(void);
Muestra la textura de la capa.

void glutOverlayDisplayFunc(void (*func)(void));
Crea una funcion que devulve la capa a mostrar.

void glutSpaceballMotionFunc(void (*func)(int x, int y, int z));
Pone el movimiento del Spaceball en la ventana actual.

void glutSpaceballRotateFunc(void (*func)(int x, int y, int z));
Pone el Spaceball dependiendo la rotación en la ventana actual.

void glutSpaceballButtonFunc(void (*func)(int button, int state));
Pone el Spaceball en la ventana actual.

void glutButtonBoxFunc(void (*func)(int button, int state));
Pone la caja dial & button box a través de un callback en la ventana actual.

void glutDialsFunc(void (*func)(int dial, int value));
Pone la caja dial & button box a través de un callback en la ventana actual.

void glutTabletMotionFunc(void (*func)(int x, int y));
Coloca el teclado especial a través de un callback en la ventana actual.

void glutSetColor(int cell, GLfloat red, GLfloat green, GLfloat blue);
Pone el color de mapa entre la capa en uso y la actual ventana.

GLfloat glutGetColor(int cell, int component);
Regresa verde, rojo o azul de un color dado en el índice de color de mapa entre la capa en uso y la capa actual.

void glutCopyColormap(int win);
Copia el color del mapa para la capa en uso de una especifica ventana.

int glutLayerGet(GLenum info);
Regresa el estado de GLUT perteneciente a las capas de la ventana actual. La información es sobre:
GLUT OVERLAY ,GLUT LAYER IN USE, GLUT NORMAL, GLUT OVERLAY, GLUT HAS OVERLAY, GLUT TRANSPARENT INDEX, GLUT NORMAL DAMAGED, GLUT OVERLAY DAMAGED.

int glutDeviceGet(GLenum info);
Recupera informacion acerca del recurso de GLUT representado por enteros.
GLUT HAS KEYBOARD, GLUT HAS MOUSE, GLUT HAS SPACEBALL, GLUT HAS DIAL AND BUTTON BOX,
GLUT HAS TABLET, regresan No-cero si es viable, cero si no es viable.
GLUT NUM MOUSE BUTTONS Numeros de botones soportados por el mouse. Si no existe maouse regresa 0.
GLUT NUM SPACEBALL BUTTONS Numero de botones que soporta el Spaceball.
GLUT NUM BUTTON BOX BUTTONS Numero de botones que soporta el dial&buttonbox.
GLUT NUM Numero de selectores para la caja dial&button
GLUT NUM TABLET BUTTONS Numero de botones soportada por la tableta.

int glutGetModifiers(void);
Regresa la modificacion de las llaves de estado cuando ciertos callbacks son generados.
GLUT ACTIVE SHIFT si el modificador shift o caps fueron activados.
GLUT ACTIVE CTRL si fue presionado Ctrl.
GLUT ACTIVE ALT si fue modificado Alt.

int glutExtensionSupported(char *extension);
Ayuda a facilitar si algunas determinadas extensiones son soportadas por OpenGL.

void glutBitmapCharacter(void *font, int character);
Regresa el ancho en pixeles de un caracter tipo mapa de bits dependiendo de la fuente que puede ser:
GLUT BITMAP 8 BY 13 Fija una fuente donde cada cara ter tiene un rectangulo de tamaño 8 por 13 pixeles.
GLUT BITMAP 9 BY 15 Fija una fuente donde cada cara ter tiene un rectangulo de tamaño 9 por 15 pixeles.
GLUT BITMAP TIMES ROMAN 10 Proporcional al Times Roman tamaño 10.
GLUT BITMAP TIMES ROMAN 24 Proporcional al Times Roman tamaño 24.
GLUT BITMAP HELVETICA 10 Proporcional a la Helveltica tamaño 10.
GLUT BITMAP HELVETICA 12 10 Proporcional a la Helveltica tamaño 12.
GLUT BITMAP HELVETICA 18 10 Proporcional a la Helveltica tamaño 18.

int glutBitmapWidth(GLUTbitmapFont font, int character);
Regresa el ancho en pixeles de un caracter tipo mapa de bits dependiendo de la fuente.

void glutStrokeCharacter(void *font, int character);
Representa un caracter tipo stroke, con un definido font que puede ser:
GLUT STROKE ROMAN A proporciona una fuente tipo Romano su tamaño maximo es de 119.05 unidades y minimo de 33.33 unidades.
GLUT STROKE MONO ROMAN A .

int glutStrokeWidth(GLUTstrokeFont font, int character);
Regresa el ancho en pixeles de un caracter tipo stroke dependiendo del font.

REPORTE PRACTICA 4

2007-04-09T16:08:00.000-07:00

En la práctica se hablo del doble buffering que en GLUT esta dado por DoubleBuffer, que indica el espacio de almacenamiento doble, en este espacio se almacenan datos y reduce el parpadeo en la imagen, ya que cuando se dibuja una imagen y se borra el tiempo de ejecución aumenta, con esta función el tiempo se reduce por que se tienen en lugar de 1 solo bufer se tienen dos.

Los parámetros de la función son los siguientes:

glutInitDisplayMode(GLUT_DOUBLEGLUT_RGBGLUT_DEPTH) ;

donde :

GLUT_DOUBLE : Evita parpadeo, doble buffer.
GLUT_RGB : Indica el color en rojo, verde y azul.
GLUT_DEPTH: Indica pruebas de profundidad, también llamado z buffer.

Como se ha visto en las practicas se ha utilizado la función glFlush(), esta función se encarga de vaciar el contenido del Frame Buffer en la pantalla de video.

Para el doble buffering se utiliza una función similar a glFlush() llamado glutSwapBuffers(), que se encarga de intercambiar los buffers, cuando se utiliza esta función, glFhush() es redundante y se puede omitir.

También se hablo de funciones como:

glClear(GL_COLOR_BUFFER_BITGL_DEPTH_BUFFER_BIT); que se encarga de limpiar la pantalla donde estan los píxeles.

glutPostRedisplay(); Genera un elemento de redibujado según las modificaciones, se fuerza el evento de redibujado.

glutSpecialFunc(); Que se utiliza para definir las teclas F1-F12, y otras especiales.

Estas funciones se explican más a detalle en el API_GLUT mostrado en este blog

2007-04-08T10:46:00.000-07:00

ALGORITMO MEJORADO
Void linea(int xo, yo, x1, y1)
{
int y=y0;
flot mint x=x0;
m=(y1-y0)/(x1-x0);
punto(x,y);if (m<0) m="m*(-1);
">do { x=x+1; y=y+m+0.5;
punto (x,y);
}while(y!=y1);

2007-03-20T08:15:00.000-07:00

PRACTICA 3

Humaniode con manos

#include
#include
#include
#include
#include

void mano(float ang,float rpy,float rpz,float rpyf123,float rpyf23,float rpyf3,float rixf123,float rixf23,float rixf3,float rmxf123,float rmxf23,float rmxf3,float raxf123,float raxf23,float raxf3,float rmexf123,float rmexf23,float rmexf3,float rmaz,float rmax,float rmay);

void mueveExtremidades(float abd, float abi, float apd,float api,float x1,float y1,float z1);

void init(void)
{
glClearColor (0.0, 0.0, 1.0, 0.0);
glShadeModel (GL_FLAT);
}

void display(void)
{

glClear (GL_COLOR_BUFFER_BIT);
glColor3f (1.0, 1.0, 1.0);
glLoadIdentity (); /* clear the matrix */
/* viewing transformation */
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glScalef (1.0, 1.0, 1.0); /* modeling transformation */

glPushMatrix();
glScalef(0.1,.6,1.0);
glTranslatef(-21,2.75f,0.0f);
glRotatef(90,0,0,1);
mano(0,1,45,0,0, 45,0,0, 45,0,0, 45,0,0, -20,0,0, -15, 0,1,0 );
glPopMatrix();

glPushMatrix();
glScalef(0.1,.6,1.0);
glTranslatef(21,2.75f,0.0f);
glRotatef(-90,0,0,1);
mano(0,1,45,0,0, 45,0,0, 45,0,0, 45,0,0, -20,0,0, -15, 0,1,0 ,);
glPopMatrix();

mueveExtremidades(8,-8,8,-8,0,0,0);

glFlush ();
}

void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}

nt main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (500, 500);
glutInitWindowPosition (300,230);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();

return 0;
}

void mueveExtremidades(float abd, float abi, float apd,float api,float x1,float y1,float z1)
{
float x,y,z,brazod, brazoi, pied, piei;
x=x1;
y=y1;
z=z1;
brazod=abd;
brazoi=abi;
pied=apd;
piei=api;

glPushMatrix();
//cabeza
glTranslatef(0.0f,2.5f,0.0f);
glutWireCube (0.5);

//tronco
glScalef(2.5,2.5,2.0);
glTranslatef(0.0f,-0.45f,0.0f);
glutWireCube (0.5);
//piernas

glPushMatrix();
glPushMatrix();
//pierna izquierda
glRotatef(piei,x,y,z);
glTranslatef(-0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);
glPushMatrix();

glTranslatef(0.0f,-0.7f,0.0f);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(0.0f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();
//pies
glPushMatrix();
glTranslatef(.3f,-1.0f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();

//pierna derecha
glRotatef(pied,x,y,z);
glTranslatef(0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);
glPushMatrix();

glTranslatef(0.0f,-0.7f,0.0f);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(0.0f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();

//pies
glTranslatef(-.3f,-1.0f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);

glPopMatrix();
//brazo derecho
glPushMatrix();
glRotatef(brazod,x,y,z);
glTranslatef(0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);

glPushMatrix();

glTranslatef(0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);

glPopMatrix();
glTranslatef(0.7f,0.0f,0.0f);
glScalef(.7,1,1.0);
glutWireCube (0.5);
//brazo izquierdo
glPopMatrix();
glRotatef(brazoi,x,y,z);
glTranslatef(-0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(-0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);

glPopMatrix();
glTranslatef(-0.7f,0.0f,0.0f);
glScalef(.7,1,1.0);
glutWireCube (0.5);
glPopMatrix();

}

void mano(float ang,float rpy,float rpz,float rpyf123,float rpyf23,float rpyf3,float rixf123,float rixf23,float rixf3,float rmxf123,float rmxf23,float rmxf3,float raxf123,float raxf23,float raxf3,float rmexf123,float rmexf23,float rmexf3,float rmaz,float rmax,float rmay)
{

glRotatef(ang,rmax,rmay,rmaz);
glPushMatrix();
//palma

glScalef(4,3,2);
glutWireCube (0.5);
glPopMatrix();

glPushMatrix();
//pulgar
//falange1
glRotatef(rpyf123,0,1,0);
glTranslatef(1.25f,-0.55f,0.0f);
glScalef(1.25,1,1);
glutWireCube (0.5);

//falange2
glRotatef(rpyf23,0,1,0);
glTranslatef(.5f,0.0f,0.0f);
glScalef(1,1,1);
glutWireCube (0.5);

//falange3
glRotatef(rpyf3,0,1,0);
glTranslatef(0.39f,0.0f,0.0f);
glScalef(.5,1,1);
glutWireCube (0.5);

glPopMatrix();

glPushMatrix();
//indice
//falange1
glRotatef(rixf123,1,0,0);
glScalef(1,1.5,1);
glTranslatef(0.75f,0.75f,0.0f);
glutWireCube (0.5);

//falange2
glRotatef(rixf23,1,0,0);
glScalef(1,1.25,1);
glTranslatef(0.0f,0.45f,0.0f);
glutWireCube (0.5);

//falange3
glRotatef(rixf3,1,0,0);
glScalef(1,.5,1);
glTranslatef(0.0f,.75f,0.0f);
glutWireCube (0.5);

glPopMatrix();

glPushMatrix();
//medio
//falange1
glRotatef(rmxf123,1,0,0);
glScalef(1,1.5,1);
glTranslatef(0.25f,0.75f,0.0f);
glutWireCube (0.5);

//falange2
glRotatef(rmxf23,1,0,0);
glScalef(1,1.25,1);
glTranslatef(0.0f,0.45f,0.0f);
glutWireCube (0.5);

//falange3
glRotatef(rmxf3,1,0,0);
glScalef(1,.75,1);
glTranslatef(0.0f,.60f,0.0f);
glutWireCube (0.5);

glPopMatrix();

glPushMatrix();
//Angular
//falange1
glRotatef(raxf123,1,0,0);
glScalef(1,1.25,1);
glTranslatef(-0.25f,0.860f,0.0f);
glutWireCube (0.5);

//falange2
glScalef(1,1.25,1);
glRotatef(raxf23,1,0,0);
glTranslatef(0.0f,.45f,0.0f);
glutWireCube (0.5);

//falange3
glRotatef(raxf3,1,0,0);
glScalef(1,1,1);
glTranslatef(0.0f,.5f,0.0f);
glutWireCube (0.5);

glPopMatrix();

glPushMatrix();
//meñique
//falange1
glRotatef(rmexf123,1,0,0);
glScalef(1,1.2,1);
glTranslatef(-0.75f,0.86f,0.0f);
glutWireCube (0.5);

//falange2
glRotatef(rmexf23,1,0,0);
glScalef(1,1,1);
glTranslatef(0.0f,0.5f,0.0f);
glutWireCube (0.5);

//falange3
glRotatef(rmexf3,1,0,0);
glScalef(1,1,1);
glTranslatef(0.0f,.5f,0.0f);
glutWireCube (0.5);

glPopMatrix();

}

2007-03-16T11:56:00.000-07:00

Matriz de Transformación
El orden es primero rotación (z a x) y luego traslación por -d, dado que mover la cámara es como mover el mundo en la dirección opuesta.
Otro método para generar la matriz de transformación y rotación consiste en calcular los vectores unitarios uvn y formar la matriz de rotación compuesta de manera directa. Dados los vectores N y V, se calculan estos vectores unitarios como
n = N / çN ç= ( n1, n2, n3 )
u= VxN / ç VxN ç= ( u1, u2, u3 )
v = nxu = ( v1, v2, v3 )
Este método también ajusta en forma automática la dirección de V de modo que v sea perpendicular a n.
La matriz de rotación compuesta para la transformación de vista es

que transforma u en el eje mundial de xw, v en el eje de yw y n en el eje de zw. Esta matriz lleva a cabo de manera automática la reflexión necesaria para transformar un sistema de vista de lado izquierdo en un sistema mundial de lado derecho.
La transformación completa de coordenadas mundiales a coordenadas de vista se obtiene como el producto de matriz

MVC ¬WC = R · T-1

glViewport(0, 0, width, height);

Esta función define la porción de ventana donde puede dibujar ogl. Los parámetros son x e y, esquina superior izquierda del "cuadro" donde puede dibujar (con
referencia la ventana), y ancho y alto. En este caso coje el width y height, que son los parámetros de reshape(), es decir, los datos que acaba de recibir por culpa
del reescalado de la ventana.

2007-03-13T15:08:00.000-07:00

Espacio vectorial

Un espacio vectorial (o espacio lineal) es el objeto básico de estudio en la rama de la matemática llamada álgebra lineal. Las operaciones que podemos realizar entre ellos son: la suma de vectores y la multiplicación por un escalar,el producto punto, el producto vectorial y el triple preduco escalar con algunas restricciones naturales como el cierre de estas operaciones, la asociatividad de estas y la combinación de estas operaciones, siguiendo, llegamos a la descripción de una estructura matemática llamada espacio vectorial.

Definición formal
Dado un cuerpo conmutativo de escalares K (como el cuerpo de los números reales o el cuerpo de los números complejos), en el que llamaremos por:
0 (cero) al elemento nulo.
1 (uno) al elemento unidad.
Un conjunto V dotado de una ley de composición interna (+), (suma de vectores), y una ley de composición externa (·), (producto por un escalar), respecto al cuerpo K, es un espacio vectorial si y solo si:
V tiene estructura de grupo conmutativo, respecto a la ley de composición interna (+), (suma de vectores).
Respecto a su ley de composición externa (·), (producto por un escalar), se cumple:

Campo vectorial

En matemática un campo vectorial es una construcción del cálculo vectorial que asocia un vector a cada punto en el espacio euclídeo.
Los campos vectoriales se utilizan a menudo en la física para, por ejemplo, modelar la velocidad y la dirección de un líquido móvil a través del espacio, o la intensidad y la dirección de una cierta fuerza, tal como la fuerza electromagnética o la gravitatoria, pues cambian punto a punto.
En el tratamiento matemático riguroso, los campos vectoriales se definen en variedades diferenciables como secciones del fibrado tangente de la variedad.

Anillo

Dados, un conjunto no vacío A y dos leyes de composición interna y , la terna ordenada (A , , ) tiene estructura de Anillo si y solo si

a) es asociativa. Es decir , , : a, b, c A

b) posee elemento neutro en A. Es decir / , si

c) Todo elemento de A es invertible en A respecto de .
Es decir , /

d) es conmutativa. Es decir , : a, b A

Estas 4 propiedades muestran que ( A , ) es un grupo abeliano.

e) es asociativa. Es decir , , : a, b, c A (a b) c = a ( b c)

Esta propiedad muestra que ( A , ) es un semigrupo.

f) distribuye doblemente sobre . Es decir, , , : a, b, c A
a (b c ) = ( a b ) (a c ) y (b c ) a = (b a ) ( c a )

Resumiendo podemos decir que:

(A , , ) es un Anillo sii (A , ) es un grupo abeliano ; ( A , ) es un semigrupo y la segunda operación distribuye sobre la primera.

DEMOSTRACION MATRIZ DE ROTACIO EJE Y

2007-03-12T14:20:00.000-07:00

Previo Practica No.2

Este es el archivo del humanoide que se mueve segun los parametro es en la función muevete.

#include
#include
#include
#include
#include

void pinta(float ejex, float ejey, float ejez,float r,char c);
void muevete(float abd, float abi, float apd,float api);

void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}

void display(void)
{
glClear (GL_COLOR_BUFFER_BIT);
glColor3f (0.1, 0.1, 0.1);
glLoadIdentity ();
gluLookAt (0.0, 0.0, 5.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
glScalef (1.0, 1.0, 1.0);

glEnable(GL_DEPTH_TEST);
glPushMatrix();
glLoadIdentity();
muevete(8,-8,8,-8);
glPopMatrix();
Sleep(1000);
pinta(0,0,1,-15,'r');
glutPostRedisplay();
Sleep(1000);
glDisable(GL_DEPTH_TEST);
glPushMatrix();
Sleep(1000);
muevete(8,-8,8,-8);
glPopMatrix();
glLoadIdentity();
pinta(0,0,1,-15,'r');
glutSwapBuffers();
glFlush ();
}

void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}

/* ARGSUSED1 */
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (500, 300);
glutInitWindowPosition (300,230);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();

return 0;
}

void pinta(float ejex, float ejey, float ejez,float r,char c)
{
float x1,y1,z1,r1;
char c1;
x1=ejex;
y1=ejey;
z1=ejez;
r1=r;
c1=c;
glPushMatrix();
if(c1=='r')
glRotatef(r1, x1,y1,z1);
else if(c1=='t')
glTranslatef(x1,y1,z1);

//cabeza
glTranslatef(0.0f,2.5f,0.0f);
glutWireCube (0.5);
glScalef(2.5,2.5,2.0);
glTranslatef(0.0f,-0.45f,0.0f);
glutWireCube (0.5);
//tronco
glPushMatrix();
glTranslatef(-0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);
glPopMatrix();
//piernas
glPushMatrix();
glTranslatef(0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(0.0f,-0.7f,0.0f);
glutWireCube (0.5);
glPopMatrix();

glTranslatef(0.7f,-0.7f,0.0f);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(0.0f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();

glPushMatrix();
glTranslatef(-0.7f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();
//pies
glPushMatrix();
glTranslatef(.3f,-.3f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);
glPopMatrix();

glTranslatef(-.8f,-.3f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);

glPopMatrix();
//brazo derecho
glPushMatrix();
glTranslatef(0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);

glPopMatrix();
glTranslatef(0.8f,0.0f,0.0f);
glutWireCube (0.5);
//brazo izquierdo
glPopMatrix();
glTranslatef(-0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(-0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);

glPopMatrix();
glTranslatef(-0.8f,0.0f,0.0f);
glutWireCube (0.5);
glPopMatrix();

}

void muevete(float brader, float braizq, float pieder,float pieizq)
{
float brazod, brazoi, pied, piei;

brazod=brader;
brazoi=braizq;
pied=pieder;
piei=pieizq;

glPushMatrix();
//cabeza
glTranslatef(0.0f,2.5f,0.0f);
glutWireCube (0.5);

//tronco
glScalef(2.5,3.0,2.0);
glTranslatef(0.0f,-0.45f,0.0f);
glutWireCube (0.5);
//piernas

glPushMatrix();
glPushMatrix();
//pierna izquierda
glRotatef(piei,0,0,1);
glTranslatef(-0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);
glPushMatrix();

glTranslatef(0.0f,-0.7f,0.0f);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(0.0f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();
//pies
glPushMatrix();
glTranslatef(.3f,-1.0f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();

//pierna derecha
glRotatef(pied,0,0,1);
glTranslatef(0.1f,-0.55f,0.0f);
glScalef(-.3,1.2,1.0);
glutWireCube (0.5);
glPushMatrix();

glTranslatef(0.0f,-0.7f,0.0f);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(0.0f,.35f,0.0f);
glScalef(1.1,.4,1.0);
glutWireCube (0.5);
glPopMatrix();
glPopMatrix();

//pies
glTranslatef(-.3f,-1.0f,0.0f);
glScalef(1.6,.2,1.0);
glutWireCube (0.5);

glPopMatrix();
//brazo derecho
glPushMatrix();
glRotatef(brazod,0,0,1);
glTranslatef(0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);

glPushMatrix();

glTranslatef(0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);

glPopMatrix();
glTranslatef(0.8f,0.0f,0.0f);
glutWireCube (0.5);
//brazo izquierdo
glPopMatrix();
glRotatef(brazoi,0,0,1);
glTranslatef(-0.35f,0.1f,0.0f);
glScalef(0.5,0.4,.5);
glutWireCube (0.5);

glPushMatrix();
glTranslatef(-0.4f,0.0f,0.0f);
glScalef(0.5,1.2,1.0);
glutWireCube (0.5);

glPopMatrix();
glTranslatef(-0.8f,0.0f,0.0f);
glutWireCube (0.5);
glPopMatrix();

}

Previo Practica 2

2007-03-06T07:33:00.001-08:00

Laboratorio de Computación Gráfica

Cuestionario previo #2

- Modelado Geométrico -

1. ¿Qué es una transformación geométrica? ¿Cuáles son las transformaciones básicas y sus matrices?

Transformaciones: una transformación T es una función que nos cambia un punto Q o un vector v en otro punto P o en otro vector u: P = T (Q); u = T (v), una transformación cualquiera debería ser aplicada punto a punto a todos los puntos de una escena.
Las transformaciones nos ayudan a:
Manipular objetos en el espacio 3D
Ayuda para visualizar y examinar objetos

Tipos de transformaciones afines:
– Traslación
– Rotación
– Escalado
– Cizallado
– Reflexión

Traslación: Desplazamos el origen y los ejes de forma paralela. En dos y tres dimensiones, siendo dx, dy, dz las distancias de traslación:

Rotación: En dos dimensiones: si giramos los ejes un ángulo (positivo si gira en sentido anti-horario)

En tres dimensiones: ahora tenemos tres rotaciones diferentes respecto cada uno de los ejes coordenados (igualmente, consideramos sentido positivo si gira en sentido anti-horario) La rotación sobre Z es prácticamente igual que antes, aunque ahora tenemos que usar una matriz (3x3):

Para la rotación sobre X, también es prácticamente igual que antes, solamente que el eje que antes era X será ahora Y, y el que antesera Y, Z (igualmente, consideramos sentido positivo si gira en sentido anti-horario)

Si rotamos respecto de Y, lo que en Rz era X ahora será Z, y donde teníamos Y, ahora habrá que poner Z. Por tanto hay queintercambiar también filas y columnas en la matriz de rotación...

Las matrices de rotación son ortonormales. Podemos invertirlas por transposición.
La rotación sobre un eje cualquiera va a necesitar, en general, ser realizada como una composición de varias transformaciones:
1. Traslación del eje de rotación (y los objetos a rotar) de forma que el eje pase por el origen
2. Descomposición de la rotación en rotaciones simples respecto a los tres ejes de coordenadas X, Y y Z
3. Deshacer la traslación, efectuando la inversa que se hizo en (1)
Escalado uniforme y no uniforme: Variamos la escala en los ejes coordenados con el mismo factor de escala o diferente para cada eje (factores de escala si iguales o diferentes)

Cizallado:
• No mantiene los ángulos, aunque sí las rectas y el paralelismo
• Menos utilizada en gráficos
• En tres dimensiones es análoga, si bien nos aparecen nuevos coeficientes adicionales

2. Escriba los comandos que en OpenGL permiten aplicar transformaciones geométricas, las variantes de dichos comandos y describa sus parámetros.

Translación: void glTranslate(x,y,z); nos va a permitir trasladar un objeto en el espacio
Rotación: void glRotate(angulo,x,y,z); nos va a permitir rotar un objeto
Escalado: void glScale(x,y,z); nos va a permitir escalar un objeto

Donde: x,y,z son las coordenadas de un punto.

3. Describa en OpenGL qué son las matrices GL_MODELVIEW y GL_PROJECTION. ¿Para qué sirven? ¿Cómo se puede intercambiar entre una y otra? ¿Cuál es la matriz activa por defecto? ¿Para que sirve el comando glLoadIdentity()?

GL_MODELVIEW: la matriz que contiene las transformaciones originadas por los
cambios de modelado y posición de la cámara.
GL_PROJECTION: la matriz con las transformaciones que realizan la proyección de la
escena de 3 a 2 dimensiones.

Estas dos matrices sirven para hacer una operación de transformación. Se especifica con la función glMatrixMode(Glenum mode) que tiene como argumento una de las tres constantes enumeradas. Se comporta como un estado, por tanto, hasta que se especifique un nuevo estado todas las transformaciones se realizan sobre la última matriz especificada.
En el código de la función resaphe() del capítulo anterior:
void reshape(int width, int height) {
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0, (GLfloat)height / (GLfloat)width, 1.0, 128.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
gluLookAt(0.0, 1.0, 3.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);
}
Se observa que se utiliza la función glMatrixMode() dos veces, la primera con
GL_PROJECTION y la segunda con GL_MODELVIEW .
Despues de la primera llamada a glMatrixMode(), la matriz sobre la que se realizarán
las transformaciones es GL_PROJECTION, la primera operación es inicializar la matriz con la función glLoadIdentity() que carga la matriz identidad y se define una proyección perspectiva con la función gluPerspective(). Esta función se explica en el siguiente capítulo.
Despues de la segunda llamada a glMatrixMode(), la matriz sobre la que se realizarán
las transformaciones es GL_MODELVIEW, igualmente, la primera operación es inicializar la matriz con la función glLoadIdentity() y a continuación se establece la posición de la cámara con gluLookAtAl comportarse OpenGL como una máquina de estados, las siguientes operaciones de transformación que se realicen en el código, que estarán fuera de la función resaphe(), se realizarán sobre la última matriz especificada, es decir sobre GL_MODELVIEW.

4. ¿Para qué son los comandos glPushMatrix() y glPopMatrix()? Describa su uso a través de un ejemplo en código.

glPushMatrix(); // 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, al llamar a la función glPushMatrix() se duplica la matriz superior. Las siguientes transformaciones que se realizan se aplican sólo a la matriz superior de la pila, quedando la anterior con los valores que tenía en el momento de llamar a la función glPushMatrix().
glPopMatrix(); 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().

glColor4f(1.0,0.0,0.0,1.0);
dibujarCuadro(1.0);
glPushMatrix();
glTranslatef(0.0, 2.0, 0.0);
dibujarCuadro(0.5);
glPopMatrix();
glPushMatrix();
glTranslatef(0.0, -2.0, 0.0);
dibujarCuadro(0.5);
glPopMatrix();

5. ¿Para qué sirven los comandos glBegin() y glEnd()? Describa su uso, sus parámetros y ejemplifique a través de una pieza de código.

Para crear cualquier figura geométrica en OpenGL hay que definir los vértices entre un par de llamadas a las funciones glBegin() y glEnd(). A la función glBegin se le puede pasar un argumento que determina qué tipo de figura geométrica se va construir. Después se definen los vértices mediante llamadas a la función glVertex. A continuación vemos un ejemplo en el que se define el polígono.
glBegin (GL_POLYGON);
glVertex2f (0.0, 0.0);
glVertex2f (0.0, 3.0);
glVertex2f (3.0, 3.0);
glVertex2f (4.0, 1.5);
glVertex2f (3.0, 0.0);
glEnd ();
void glBegin (GLenum mode); Marca el principio de una lista de vértices que describen una primitiva geométrica. El parámetro mode índica el tipo de primitiva(GL_POINTS Puntos individuales. GL_LINES Cada Par de vértices forman un segmento individual.
GL_POLYGON Vértices de polígono simple y conexo. GL_TRIANGLES Cada terna determina un triángulo. GL_QUADS Cada cuátrupla determina un cuadrado. GL_LINE_STRIP Series de segmentos conectados. GL_LINE_LOOP Series de segmentos conectados y cerrados. GL_TRIANGLE_STRIP Cadenas de triángulos conectados. GL_TRIANGLE_FAN Cadenas de polystrip (el centro es el primer
vértice). GL_QUAD_STRIP Cuadriláteros encadenados.)
void glEnd (void); Marca el final de una lista de vértices.

6. ¿Qué es modelado geométrico? Describa los tipos de modelado geométrico que existen.

Modelado Geométrico: es una técnica que puede generar distintos tipos de objetos.
Los modelos pueden clasificarse en: alambritos, de superficies (planas o curvas) y sólidos. Los modelos de superficies curvas se dividen en: paramétricas(analíticas y sintéticas) y no paramétricas(explícitas e implícitas). Los modelos sólidos más importantes son: semi-espacios,frontera,CSG, barrido, enumeración espacial,etc.
Entre los modelos no convencionales se encuentran: los fractales, los de gramáticas, los sistemas de partículas, los blobs, y los basados en propiedades físicas.

7. Construya código para dibujar un cubo (revisar en la clase de teoría), y a partir de éste modele jerárquicamente el humanoide de la ilustración y escriba el programa que lo dibuja. Las medidas corren por su cuenta.

#include
#include

void init(void)
{
glClearColor (0.0, 0.0, 1.0, 0.0);
glShadeModel (GL_FLAT);
}

void cube(void){
GLfloat vertices[][]={{0.55,0.5,0.5},
{-0.5,-0.5,0.5},
{0.5,-0.5,0.5},
{-0.5,0.5,0.5},
{-0.5,-0,5,-0.5},
{-0.5,0.5,-0.5},
{0.5,0.5,-0.5}};
glBegin(GL_QUADS);
glVertex3fv(vertices[0]);
glVertex3fv(vertices[1]);
glVertex3fv(vertices[2]);
glVertex3fv(vertices[3]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[5]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[7]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[1]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[5]);
glVertex3fv(vertices[2]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[0]);
glVertex3fv(vertices[3]);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[7]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[0]);
glVertex3fv(vertices[7]);
glVertex3fv(vertices[6]);
glVertex3fv(vertices[1]);
glEnd();
glBegin(GL_QUADS);
glVertex3fv(vertices[2]);
glVertex3fv(vertices[5]);
glVertex3fv(vertices[4]);
glVertex3fv(vertices[3]);
glEnd();
}
void display(void)
{

glPushMatrix();
glTranslatef(0.0,1.25,0.0);
glPushMatrix();
glTranslatef(0.25,1.5,0.0);
glScalef(1.5,0.5,0.5);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(0.25,2.0,0.0);
glScalef(1.0,2.0,0.5);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(-4.75,1.75,0.0);
glScalef(0.5,2.0,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(1.5,0.0,0.0);
glScalef(2.0,1.5,0.5);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(2.0,0.0,0.0);
glScalef(2.0,0.5,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(-1.5,0.0,0.0);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(-2.0,0.0,0.0);
glScalef(2.0,1.5,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(-2.0,0.75,0.0);
glScalef(2.0,0.5,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(0.0,-2.0,0.0);
cube();
glPopMatrix();

glPushMatrix();
glTranslatef(0.75,-2.5,0.0);
glScalef(2.0,3.0,0.5);
cube();
glPopMatrix();
glPushMatrix();
glScalef(0.5,2.0,0.5);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(0.25,-2.0,0.0);
glScalef(1.0,2.0,1.0);
cube();
glPopMatrix();
glPushMatrix();
glTranslatef(0.5,-1.5,0.0);
glScalef(1.5,0.5,0.5);
cube();
glPopMatrix();
glPopMatrix();

}
void reshape (int w, int h)
{
glViewport (0, 0, (GLsizei) w, (GLsizei) h);
glMatrixMode (GL_PROJECTION);
glLoadIdentity ();
glFrustum (-1.0, 1.0, -1.0, 1.0, 1.5, 20.0);
glMatrixMode (GL_MODELVIEW);
}
/* ARGSUSED1 */
/*void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
exit(0);
break;
}
}*/
int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode (GLUT_SINGLE GLUT_RGB);
glutInitWindowSize (500, 300);
glutInitWindowPosition (300,230);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

8. ¿Para qué sirven los comandos glClearColor() y glClear()? Descríbalos su funcionamiento, sus parámetros y ejemplifique a través de una pieza de código.

void glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
Activa el color de fondo actual, siguiendo el modelo de representación RGB. Cada argumento representa la cantidad del color indicado que tiene el color de fondo, y toma valores en el intervalo [0, 1. El valor por defecto es el color NEGRO que se representa por el valor: (0, 0, 0, 0).
void display(void)
{
glClearColor(0.0,0.0,0.0,0.0);
// Color de fondo: negro
glClear(GL_COLOR_BUFFER_BIT);
// Boramos la pantalla
glMatrixMode(GL_PROJECTION);
// Modo proyección
glLoadIdentity();
// Cargamos la matriz identidad
glOrtho(-1.0,1.0,-1.0,1.0,-1.0,1.0);
// Proyección ortográfica, dentro del cubo señalado
glMatrixMode(GL_MODELVIEW);
// Modo de modelado
glBegin(GL_TRIANGLES);
// Dibujamos un triángulo
glColor3f(1.0,0.0,0.0);
// Color del primer vértice: rojo
glVertex3f(0.0,0.8,0.0);
// Coordenadas del primer vértice
glColor3f(0.0,1.0,0.0);
// Color del segundo vértice: verde
glVertex3f(-0.6,-0.2,0.0);
// Coordenadas del segundo vértice
glColor3f(0.0,0.0,1.0);
// Color del tercer vértice: azúl
glVertex3f(0.6,-0.2,0.0);
// Coordenadas del tercer vértice
glEnd();
// Terminamos de dibujar
glFlush();
// Forzamos el dibujado
sleep(10);
// Esperamos 10 segundos
exit(0);
// Salimos del programa
}

void glClear (GLbitfield mask);
Limpia el buffer especificado por el parámetro, inicializándolo al valor que tenía asignada la variable de estado anteriormente. Los posibles valores del argumento, es decir los posibles buffers que tenemos son los siguientes:
Color Buffer GL_COLOR_BUFFER_BIT
Depth Buffer GL_DEPTH_BUFFER_BIT
Accumulate Buffer GL_ACCUM_BUFFER_BIT
Stencil Buffer GL_STENCIL_BUFFER_BIT

void display(void) {
glClear(GL_COLOR_BUFFER_BIT GL_DEPTH_BUFFER_BIT);
glPushMatrix();
glMultMatrixd(mModel);
glColor3f(1.0,1.0,0.0) ;
drawTurtle();
glPopMatrix();
displayTrace();
glutSwapBuffers();
}
9. Describa los comandos glutInit(), glutInitDisplayMode (), glutInitWindowSize (), glutInitWindowPosition (), glutCreateWindow (), glutDisplayFunc(), glutReshapeFunc(), glutKeyboardFunc() y glutMainLoop(). Describa su funcionamiento, uso y parámetros.

Void glutInit(&argc, argv); que inicializa la GLUT, y negocia con el sistema de ventanas para abrir una. Los parámetros deben ser los mismos argc y argv sin modificar de la main(). Glut entiende una serie de parámetros que pueden ser pasados por línea de comandos.

void glutDisplayFunc( void (*func) (void)) La función func() se llamará cada vez que haya que redibujar la ventana. Inicializa el buffer de la pantalla inicial, esn este caso es el modo y tipo de colores en la pantalla(RGB/RGBA)

void glutReshapeFunc(void (*func) (int width, int height)) La función func(width, height) se llamará cada vez
que la ventana cambie de tamaño, y recibirá como parámetros la nueva anchura y altura.

glutInitDisplayMode. Inicializar el modo de visualización. En este caso, estamos activando el buffer de profundidad (GLUT_DEPTH), el doble buffering (GLUT_DOUBLE) y la renderización en RGB (GLUT_RGB).

glutInitWindowSize (anchura, altura). Inicializar el tamaño de la ventana.

glutInitWindowPosition(x, y). Inicializar la posición de la ventana en el escritorio.

glutCreateWindow(char* titulo). Crear la ventana. Esta función muestra una ventana del tamaño y posición definidas y con el título que le hayamos puesto.

Void glutKeyboardFun(void (*func)(unsigned char key, int x,int y)): Se encarga de la interacción de eventos en el teclado. maneja el control del teclado, haciendo un transición ente ASCII y GLUT

Void glutMainLoop(); es el bucle principal de la visualización, se encarga de interaccionar con eventos. esta función inicializa el framework running de GLUT, y procesa los mensajes de sistema operativo

10. ¿Qué es un Function Callback en GLUT?

La ejecución de esta función espera a que se produzcan eventos. Cada vez que se produce un evento lo atiende y ejecuta la función registrada, encargada de responder al evento (función de callback).

Reporte Practica no.1 Laboratorio Computación Grafica

2007-02-22T07:37:00.001-08:00

Laboratorio de Computación Grafica

Reporte Practica No. 1

Objetivo:

Empezar a familiarizarse con el ambiente de trabajo, que es Visual Studio y utilizar librerías externas de la aplicación.

Desarrollo:

Bajar las librerías de OpenGL, ir a la pagina www.opengl.org seleccionar couding resources, GLUT and utility libraries, escoger About GLUT, y bajar Pre-compiled Win32 for Intel Glut 37 DLLs for Windows 95 & NT, y GLUT 3.7 Source Code Download for Win32.

Descomprimir estas dos carpeta en Mis Documentos y crear los siguientes subdirectorios Mis Documentos/lib/, Mis Documentos/dll/, Mis Documentos/include/GL/, agregar los archivos descomprimidos de glutdlls37beta a estas carpetas los .lib a /lib/, .dll a /dll/ y el .h a /GL/.

Copiar la ruta de acceso donde están los archivos .zip antes descomprimidos, ir a Mi PC clic derecho, elegir propiedades, seleccionar opciones avanzadas, variables de entorno y en variables de usuario cambiar el path pegando la ruta de acceso antes copiada, si ya existiera el path colocar ; después de su contenido y pegar la ruta finalizando con otro ; y finalmente seleccionar aceptar.

Abrir Visual Studio 2005, seleccionar File, New Proyect, Visual C++, Win32, elegir Win32 Console Application, Nombrar el proyecto(practica1) y el Solution Name (en este caso LCG2007-2), debe estar habilitado la creación del directorio para Solution Name, seleccionar OK.

Aparece otra ventana, seleccionar Application Settings, habilitar la aplicación de tipo Console application, la opción adicional de Empty Project y las otras opciones deshabilitadas, dar clic en finalizar, aparecerá en el Solution Explorer el proyecto con 3 carpetas para añadir archivos de cabecera y códigos.

Regresar a la ruta donde se encuentra la carpeta de glut37, entrar a la carpeta progs, redbook, y copiar el archivo cube.c.

En visual estudio en la división de Solution Explorer seleccionar Source Files dar clic derecho y elegir Add, Existing Item, pegar el archivo cube.c y add.

Para compilar el archivo seleccionar en la barra de menú Build, Build seguido del nombre del proyecto (Build Practica1), manda un error.

Para solucionarlo en la barra de menú seleccionar Project, Practica1 Properties, Configuration Properties, C/C++, General, Additional Incluye Directories y hacer clic en un boton en el cual aparecen 3 puntos, dar clic en el espacio en blanco al igual aparecerán 3 puntos seleccionarlo e introducir la dirección de la carpeta GL antes creada.

Una vez ingresado, seleccionar Linker, General, se parecerá mucho al paso 9 pero aquí la ruta a especificar es la de lib, abrir y aceptar.

Verificar que en la carpeta creada para la Solution(LCG2007-2), en la carpeta debug se encuentre el archivo glut32.dll, esto con el fin de que compile perfectamente.

Cerrar visual studio para que hagan efecto los cambios, al abrirlo de nuevo compilar el archivo cube.c, y generara una aplicación donde aparece un cubo.

Por ultimo agregar mas archivos a la carpeta Source Files, pero removiendo el archivo existente, y compilarlo.

Agragar lo hecho a una carpeta .zip.

Conclusiones:

Se logro utilizar la librería de OpenGl para ver algunos demos, y como se compila un archivo en Visual Studio.

Me pareció muy interesante y creo que la herramienta de OpenGl es muy interesante.

Do You Yahoo!? La mejor conexión a Internet y 2GB extra a tu correo por $100 al mes. http://net.yahoo.com.mx

Tarea no. 1 INVETIGACION DVI Y HDMI

2007-02-22T07:28:00.001-08:00

INVETIGACION DVI Y HDMI

DVI

La interfaz de vídeo digital o interfaz visual digital (en inglés DVI, "digital visual interface" o "digital video interface") es un conector de vídeo diseñado para obtener la máxima calidad de visualización posible en pantallas digitales tales como los monitores de cristal líquido de pantalla plana y los proyectores digitales. Fue desarrollada por el consorcio industrial DDWG ("Digital Display Working Group", Grupo de Trabajo para la Pantalla Digital).

El brillo de los píxeles se transmite en forma de lista de números binarios. Cuando la pantalla está establecida a su resolución nativa, sólo tiene que leer cada número y aplicar ese brillo al píxel apropiado. De esta forma, cada píxel del buffer de salida de la fuente se corresponde directamente con un píxel en la pantalla.

El DVI emplea TMDS ("Transition Minimized Differential Signaling", Señal Diferencial con Transición Minimizada). Un enlace DVI consiste en un cable de cuatro pares trenzados: uno para cada color primario (rojo, verde, y azul) y otro para el "reloj" (que sincroniza la transmisión), la pantalla entera se transmite constantemente.

El conector DVI normalmente posee pins para transmitir las señales digitales nativas de DVI. En los sistemas de doble enlace, se proporcionan pins adicionales para la segunda señal. También puede tener pins para transmitir las señales analógicas del estándar VGA.

Los conectores DVI se clasifican en tres tipos en función de qué señales admiten:

DVI-D (sólo digital)

DVI-A (sólo analógica)

DVI-I (digital y analógica)

A veces se denomina DVI-DL a los conectores que admiten dos enlaces.

Especificaciones

Frecuencia mínima de reloj: 21.76 MHz

Frecuencia máxima de reloj para enlace único: 165 MHz

Frecuencia máxima de reloj para doble enlace: limitada sólo por el cable

Píxeles por ciclo de reloj: 1 (enlace único) o 2 (doble enlace)

Bits por píxel: 24

Conector

Números de pin (vista del enchufe hembra)

1 2 3 4 5 6 7 8 C1 C2

9 10 11 12 13 14 15 16 C5

17 18 19 20 21 22 23 24 C3 C4

Funciones de los pins Pin Nombre Función

1 Datos TMDS 2- Rojo digital - (Link 1)

2 Datos TMDS 2+ Rojo digital + (Link 1)

3 Protección datos TMDS 2/4

4 Datos TMDS 4- Verde digital - (Enlace 2)

5 Datos TMDS 4+ Verde digital + (Enlace 2)

6 Reloj DDC

7 Datos DDC

8 Sincronización vertical analógica

9 Datos TMDS 1- Verde digital - (Enlace 1)

10 Datos TMDS 1+ Verde digital + (Enlace 1)

11 Protección datos TMDS 1/3

12 Datos TMDS 3- Azul digital - (Enlace 2)

13 Datos TMDS 3+ Azul digital + (Enlace 2)

14 +5V Energía para el monitor en espera

15 Tierra Retorno para pin 14 y sincronización analógica

16 Detección Hot Plug

17 Datos TMDS 0- Azul digital - (Enlace 1) y sincronización digital

18 Datos TMDS 0+ Azul digital + (Enlace 1) y sincronización digital

19 Protección datos TMDS 0/5

20 Datos TMDS 5- Rojo digital - (Enlace 2)

21 Datos TMDS 5+ Rojo digital + (Enlace 2)

22 Protección reloj TMDS

23 Reloj TMDS+ Reloj digital + (Enlaces 1 y 2)

24 Reloj TMDS- Reloj digital - (Enlaces 1 y 2)

C1 Rojo analógico

C2 Verde analógico

C3 Azul analógico

C4 Sincronización horizontal analógica

C5 Tierra (analógico) Retorno para señales de Rojo, Verde y Azul

HDMI

HDMIHigh-Definition Multi-media Interface (HDMI) -Interfaz multimedia de alta definición- es una norma de audio y vídeo digital, sin compresión y apoyado por la industria, se prevé que sea el sustituto del euroconector. HDMI provee un interfaz entre cualquier fuente de audio y vídeo digital.

HDMI permite el uso de vídeo estándar, mejorado o de alta definición, así como audio digital multicanal en un único cable. Es independiente de los varios estándares DTV como ATSC, DVB (-T,-S,-C), que no son más que encapsulaciones de datos MPEG. Tras ser enviados a un descodificador, se obtienen los datos de vídeo sin comprimir, pudiendo ser de alta definición. Estos datos se codifican en TMDS para ser transmitidos digitalmente por medio de HDMI. HDMI incluye también 8 canales de audio digital sin compresión. A partir de la versión 1.2, HDMI puede utilizar hasta 8 canales de audio de un bit. El audio de un bit es el usado en los Super audio CDs.

Conectores

El conector estándar de HDMI tipo A tiene 19 pines. Se ha definido también una versión de mayor resolución -tipo B-, pero su uso aún no se ha generalizado. El tipo B tiene 29 pines, permitiendo llevar un canal de vídeo expandido para pantallas de alta resolución. El tipo B fue diseñado para resoluciones más altas que las del formato 1080p.

El HDMI tipo A es compatible con un enlace simple DVI, usado por los monitores de ordenador y tarjetas gráficas modernas. Esto quiere decir que una fuente DVI puede conectarse a un monitor HDMI, o viceversa, por medio de un adaptador o cable adecuado, pero el audio y las características de control remoto HDMI no estarán disponibles. Además, sin el uso de HDCP, la calidad de vídeo y la resolución podrían ser degradadas artificialmente por la fuente de la señal para evitar al usuario final ver o, mayormente, copiar contenido protegido. El HDMI tipo B es, de forma similar, compatible hacia atrás con un enlace dual DVI.

Especificaciones técnicas

Lleva audio, video y datos auxiliares.

Método de señalización: de acuerdo a las especificaciones DVI 1.0, enlace simple (HDMI tipo A) o enlace doble (HDMI tipo B).

Frecuencia de píxels de vídeo: de 25 MHz a 165 MHz (tipo A) o a 330 MHz (tipo B). Formatos de vídeo por debajo de 25MHz (ej.: 13.5MHz para el 480i/NTSC) son transmitidos usando un esquema de repetición de píxels. Se pueden transmitir hasta 24 bits por pixel, independientemente de la frecuencia.

Codificación de los píxels: RGB 4:4:4, YCbCr 4:2:2, YCbCr 4:4:4.

Frecuencias de muestreo del audio: 32 kHz, 44.1 kHz, 48 kHz, 88.2 kHz, 96kHz, 176.4 kHz, 192 kHz.

Canales de audio: hasta 8.

Detalles del conector (Conector ejemplo: Molex 500254-1907)

Asignación de pines de un conector tipo A Pin Asignación de señal

pin funcion

1 TMDS Data2+

2 TMDS Data2 Shield

3 TMDS Data2

4 TMDS Data1+

5 TMDS Data1 Shield

6 TMDS Data1

7 TMDS Data0+

8 TMDS Data0 Shield

9 TMDS Data0

10 TMDS Clock+

11 TMDS Clock Shield

12 TMDS Clock

13 CEC

14 Reservado

15 SCL

16 SDA

17 Tierra DDC/CEC

18 +5V Power

19 Detección de conexión "en caliente" (Hot Plug)

Do You Yahoo!? La mejor conexión a Internet y 2GB extra a tu correo por $100 al mes. http://net.yahoo.com.mx

2007-02-16T07:26:00.000-08:00

COMPUTACION GRAFICA GRUPO 2