Nos vemos el viernes para ver le videojuego
aqui mostraré el código fuente y el video de como se ve el juego, además de todo el proyecto completo.
KEyland
domingo, 9 de diciembre de 2007
Tarea 11
Un vertex shader es una función que recibe como parámetro un vértice. Sólo trabaja con un vértice a la vez, y no puede eliminarlo, sólo transformarlo. Para ello, modifica propiedades del mismo para que repercutan en la geometría del objeto al que pertenece. Con ésto se puede lograr ciertos efectos específicos, como los que tienen que ver con la deformación en tiempo real de un elemento; por ejemplo, el movimiento de una ola. Donde toma una gran importancia es en el tratamiento de las superficies curvas, y su avance se vio reflejado en los videojuegos más avanzados de la actualidad. Particularmente, en el diseño de los personajes y sus expresiones corporales.
En cambio, un píxel shader no interviene en el proceso de la definición del “esqueleto” de la escena (Wireframe), sino que forma parte de la segunda etapa: la rasterización (Rendering). Allí es donde se aplican las texturas y se tratan los pixeles que forman parte de ellas. Básicamente, un píxel shader especifica el color de un píxel. Este tratamiento individual de los pixeles permite que se realicen cálculos principalmente relacionados con la iluminación del elemento del cual forman parte en la escena, y en tiempo real. Teniendo la posibilidad de iluminar cada píxel por separado es como se lograron crear los fabulosos efectos de este estilo que se pueden apreciar en Doom 3, Far Cry y Half Life 2, por mencionar sólo los más conocidos. La particularidad de los píxel shaders es que, a diferencia de los vertex shaders, requieren de un soporte de hardware compatible. En otras palabras, un juego programado para hacer uso de píxel shaders requiere si o si de una tarjeta de video con capacidad para manipularlos.
Tarea 10
Animación
La animación es una simulación de movimiento producida mediante imágenes que se crearon una por una; al proyectarse sucesivamente estas imágenes (denominadas cuadros) se produce una ilusión de movimiento, pero el movimiento representado no existió en la realidad. Se basa en la ilusión de movimiento, en la que intervienen la persistencia de la visión y el fenómeno phi.
La animación pertenece al ámbito del cine y la televisión, aunque, como puede verse, está en relación directa con las artes visuales clásicas, dibujo, pintura y escultura, así como con la fotografía.
Para realizar animación existen numerosas técnicas que van más allá de los familiares dibujos animados. Los cuadros se pueden generar dibujando, pintando, o fotografiando los minúsculos cambios hechos repetidamente a un modelo de la realidad o a un modelo tridimensional virtual; también es posible animar objetos de la realidad y actores.
keyframes
Los keyframes son dibujos principales para definir puntos de inicio y de fin en una transición. Una secuencia de keyframes define cual movimiento se verá, mientras que la posición de éstos en la película definen el tiempo del movimiento. Para dar la ilusión de un movimiento continúo por segundo, se agregan keyframes llamados “in-betweens” o intermedios.
Cinemática Directa
Se denomina cinemática directa a una técnica usada en gráficos 3D por computadora, para calcular la posición de partes de una estructura articulada a partir de sus componentes fijas y las transformaciones inducidas por las articulaciones de la estructura.
Un ejemplo típico de estructura jerárquica sobre el que realizar éstos cálculos es un robot, formado por cuerpos rígidos enlazados por articulaciones. Se puede establecer un sistema de referencia fijo situado en la base del robot, y describir la localización de cada uno de los eslabones con respecto a dicho sistema de referencia. Una pieza rígida A depende jerárquicamente de otra B si, para alcanzar la parte fija de la estructura (base del robot) desde A, se debe pasar por B. Para calcular la posición de una pieza rígida de la estructura se deben calcular las posiciones de todas las piezas de las que depende. Bibliotecas gráficas de uso generalizado, como OpenGL, están diseñadas para facilitar estos cálculos y llevarlos a cabo eficientemente mediante pilas de matrices.
Cinemática inversa
En el área de mecánica y Robótica se denomina Cinemática Inversa al proceso algorítmico por el cual en base a las parámetros de la posición final de una cadena de enlaces (por ejemplo, un brazo robótico) se determina la posición requerida de cada una de las articulaciones.
El objetivo de la cinemática inversa consiste en encontrar el gesto que deben adoptar las diferentes articulaciones para que el final del sistema articulado llegue a una posición concreta.
Captura de movimiento
Es el proceso de grabar a alguna persona o animal realizando o ejecutando una acción, y capturarlo para mapearlo en un modelo 3D.
El actor protagonista lleva un traje con pequeños marcadores denominados LED. Cada uno de estos puntos sigue el cuerpo de manera exacta y muestra cómo se mueve.
MOTION CAPTOR RT es un sistema óptico de captura del movimiento en tiempo real, desarrollado íntegramente por STT, para las industrias de animación, televisión y video juegos. Al emplear marcadores reflectantes pasivos, no existen las restricciones derivadas de la utilización de cableado u otro tipo de elementos que restringen el movimiento a realizar por los actores.
MOTION CAPTOR RT consiste en una solución completa (Hardware + Software) para la captura del movimiento. Incluye todos los dispositivos como cámaras, cableado e iluminadores, además del equipo informático adecuado. Todo el sistema funciona de todo completamente automático y se maneja desde un interfaz muy sencillo.
http://www.simtechniques.com/descargas/descripcion_MotionCaptor.pdf
La animación es una simulación de movimiento producida mediante imágenes que se crearon una por una; al proyectarse sucesivamente estas imágenes (denominadas cuadros) se produce una ilusión de movimiento, pero el movimiento representado no existió en la realidad. Se basa en la ilusión de movimiento, en la que intervienen la persistencia de la visión y el fenómeno phi.
La animación pertenece al ámbito del cine y la televisión, aunque, como puede verse, está en relación directa con las artes visuales clásicas, dibujo, pintura y escultura, así como con la fotografía.
Para realizar animación existen numerosas técnicas que van más allá de los familiares dibujos animados. Los cuadros se pueden generar dibujando, pintando, o fotografiando los minúsculos cambios hechos repetidamente a un modelo de la realidad o a un modelo tridimensional virtual; también es posible animar objetos de la realidad y actores.
keyframes
Los keyframes son dibujos principales para definir puntos de inicio y de fin en una transición. Una secuencia de keyframes define cual movimiento se verá, mientras que la posición de éstos en la película definen el tiempo del movimiento. Para dar la ilusión de un movimiento continúo por segundo, se agregan keyframes llamados “in-betweens” o intermedios.
Cinemática Directa
Se denomina cinemática directa a una técnica usada en gráficos 3D por computadora, para calcular la posición de partes de una estructura articulada a partir de sus componentes fijas y las transformaciones inducidas por las articulaciones de la estructura.
Un ejemplo típico de estructura jerárquica sobre el que realizar éstos cálculos es un robot, formado por cuerpos rígidos enlazados por articulaciones. Se puede establecer un sistema de referencia fijo situado en la base del robot, y describir la localización de cada uno de los eslabones con respecto a dicho sistema de referencia. Una pieza rígida A depende jerárquicamente de otra B si, para alcanzar la parte fija de la estructura (base del robot) desde A, se debe pasar por B. Para calcular la posición de una pieza rígida de la estructura se deben calcular las posiciones de todas las piezas de las que depende. Bibliotecas gráficas de uso generalizado, como OpenGL, están diseñadas para facilitar estos cálculos y llevarlos a cabo eficientemente mediante pilas de matrices.
Cinemática inversa
En el área de mecánica y Robótica se denomina Cinemática Inversa al proceso algorítmico por el cual en base a las parámetros de la posición final de una cadena de enlaces (por ejemplo, un brazo robótico) se determina la posición requerida de cada una de las articulaciones.
El objetivo de la cinemática inversa consiste en encontrar el gesto que deben adoptar las diferentes articulaciones para que el final del sistema articulado llegue a una posición concreta.
Captura de movimiento
Es el proceso de grabar a alguna persona o animal realizando o ejecutando una acción, y capturarlo para mapearlo en un modelo 3D.
El actor protagonista lleva un traje con pequeños marcadores denominados LED. Cada uno de estos puntos sigue el cuerpo de manera exacta y muestra cómo se mueve.
MOTION CAPTOR RT es un sistema óptico de captura del movimiento en tiempo real, desarrollado íntegramente por STT, para las industrias de animación, televisión y video juegos. Al emplear marcadores reflectantes pasivos, no existen las restricciones derivadas de la utilización de cableado u otro tipo de elementos que restringen el movimiento a realizar por los actores.
MOTION CAPTOR RT consiste en una solución completa (Hardware + Software) para la captura del movimiento. Incluye todos los dispositivos como cámaras, cableado e iluminadores, además del equipo informático adecuado. Todo el sistema funciona de todo completamente automático y se maneja desde un interfaz muy sencillo.
http://www.simtechniques.com/descargas/descripcion_MotionCaptor.pdf
lunes, 3 de diciembre de 2007
Tarea 8
void linea( int x0,y0,xf,yf){
int Δ0=2*((yf-y0)+(x0-xf));
int ΔE=2*(yf-y0);
int ΔNE=2*((yf-y0)+(x0-xf));
int x=x0;
int y=y0;
if(x0>xf)
{
x=xf;
y=yf;
xf=x0;
yf=x0;
}
if((yf-y0) ≤ (xf-x0))
{
while(x≠xf)
{
punto(x,y)
if(Δ0≤0)
{
x++;
y++;
Δ0=Δ0+ΔE;
}
else
{
x++;
y++;
Δ0=Δ0+ΔNE;
}
punto(x,y)
}
}
else
{
while(x!=xf)
{
punto(x,y)
if(Δ0≤0)
{
x++;
y++;
Δ0=Δ0+ΔNE;
}
else
{
x++;
y++;
Δ0=Δ0+E;
}
punto(x,y)
}
}
}
int Δ0=2*((yf-y0)+(x0-xf));
int ΔE=2*(yf-y0);
int ΔNE=2*((yf-y0)+(x0-xf));
int x=x0;
int y=y0;
if(x0>xf)
{
x=xf;
y=yf;
xf=x0;
yf=x0;
}
if((yf-y0) ≤ (xf-x0))
{
while(x≠xf)
{
punto(x,y)
if(Δ0≤0)
{
x++;
y++;
Δ0=Δ0+ΔE;
}
else
{
x++;
y++;
Δ0=Δ0+ΔNE;
}
punto(x,y)
}
}
else
{
while(x!=xf)
{
punto(x,y)
if(Δ0≤0)
{
x++;
y++;
Δ0=Δ0+ΔNE;
}
else
{
x++;
y++;
Δ0=Δ0+E;
}
punto(x,y)
}
}
}
Tarea 7
Algoritmo Incremental básico:
La estrategia más sencilla para discretizar líneas es calcular la pendiente ,n como z e incrementar x en 1 a partir del punto del extremo izquierdo para calcular y, = mx + B de cada x, e intensificar el pixel en (x, round(y,)), donde round(y,) = floor(0.5 + y,). Con este cálculo se obtiene el pixel más cercano, o sea, aquel cuya distancia a la línea verdadera sea menor. Sin embargo, esta estrategia burda no es muy eficiente, ya que cada iteración requiere una multiplicación y una suma de punto flotante (o de fracción binaria), además de invocar afloor. Podemos eliminar la multiplicación al observar que
yi+1 = mxi+1 + B = m(xi+ Δ x) + B = yi + mΔx
y que si x = Δx, entonces yi+1 = yi + m
De esta manera, un cambio unitario en x cambia y por m, que es la pendiente de la línea. Para todos los puntos (xi, yi) en la línea (no los puntos en la versión de trama de la línea), sabemos que si xi+1 = xi + 1, entonces yi+1 = yi + m; es decir, los valores de x y y se definen en función de sus valores anteriores. Esto es lo que define un algoritmo incremental: en cada paso se realizan cálculos incrementales basados en el paso anterior.
Comenzamos el cálculo incremental en (x0, y0), las coordenadas enteras de un punto extremo. Observe que esta técnica incremental evita la necesidad de tratar con la intersección del eje y, es decir, B. Si |m| > 1, un incremento en x crea un incremento en y mayor que 1. Por lo tanto, tenemos que invertir los papeles de x y y asignando un incremento unidad a y y aumentando x en Δx = Δy/m = l/m. La función línea del programa 3.1 implanta la técnica incremental. El punto de partida debe ser el punto extremo de la izquierda. Así mismo, está limitado al caso -1 <=m <=1, pero las otras pendientes pueden acomodarse por simetría. Se omite la revisión de los casos especiales de líneas horizontales, verticales o diagonales.
La función escribir_pixel, que utiliza línea, es una función de bajo nivel proporcionada por el software de la pantalla que coloca un valor en un lienzo para un pixel cuyas coordenadas se especifican como los dos primeros argumentos. Supondremos aquí que únicamente discretizamos en modo de reemplazo; para los otros modos de escritura de SRGP tenemos que usar una función de bajo nivel leer_pixel para leer el pixel en la localidad destino, combinar lógica mente este valor con el del pixel fuente y escribir el resultado en el destino con escribir pixel.
Este algoritmo se conoce como algoritmo analizador diferencial digital (DDA, digital differential analyzer). El DDA es un dispositivo mecánico que resuelve ecuaciones diferenciales usando métodos numéricos: rastrea valores (x, y) sucesivos incrementando simultáneamente x y y en pequeñas cantidades proporcionales a la primera derivada de x y de y. En nuestro caso, el incremento de x es 1 y el incremento de y es dy/dx =m. Como las variables reales tienen precisión limitada, la suma repetida de una m inexacta produce una acumulación de errores y por último una desviación con respecto a un valor round(y0) verdadero; esta situación no ocasionará problemas en la mayoría de las líneas (cortas).
void Linea(int x0, int y0, intx1, int y1, int valor)
{
int x;
float dy, dx, y, m;
dy=y1-y0;
dx=x1-x0;
m=dy/dx,
y=y0;
for(x=x0;x<= x1;x++){
escribirpixel(x,(int)floor(y+0.5,valor);
y+=m;
}
}
Algoritmo de línea de punto medio
Las desventajas de la función línea son que el redondeo de y a un entero requiere tiempo y que las variables y y m deben ser reales o binarias fraccionarias, ya que la pendiente es una fracción. Bresenham desarrolló un algoritmo clásico que resulta atractivo porque sólo emplea aritmética entera con lo cual se evita el empleo de la función round, y permite efectuar incrementalmente el cálculo de (x i+1, yi+1 ), es decir, usando el cálculo efectuado para (x i, yi ). Se puede aplicar una versión de punto flotante de este algoritmo a líneas con coordenadas de puntos extremos con valores arbitrarios de punto flotante. Así mismo, la técnica incremental de Bresenham se puede aplicar también al cálculo entero de círculos, aunque no es fácil de generalizar a cónicas arbitrarias. Por ello usaremos una formulación un poco distinta, la técnica de punto medio, publicada por primera vez por Pitteway y adaptada por Van Aken y otros investigadores. En el caso de líneas y círculos enteros, la formulación de punto medio, como demuestra Van Aken se reduce a la formulación de Bresenham y por ende genera los mismos pixeles. Bresenham demostró que sus algoritmos de líneas y círculos enteros ofrecen las aproximaciones de mejor ajuste a las líneas y los círculos verdaderos, minimizando el error (distancia) a la primitiva verdadera.
Suponemos que la pendiente de la línea está entre 0 y 1. Las demás pendientes se pueden manejar con una reflexión adecuada respecto a los ejes principales. Al punto extremo inferior izquierdo lo llamaremos (x 0, y0) y al superior derecho, (x 1, y1).
Considere la línea que se presenta en la figura 3.6, donde el pixel previa mente seleccionado aparece como un círculo negro y los dos pixeles de los cuales podemos escoger en la etapa siguiente se presentan como círculos huecos. Suponga que acabamos de seleccionar el pixel P en (xp, yp) y ahora tenemos que elegir entre el pixel que está un incremento a la derecha (llamado pixel este, E) el pixel que se halla un incremento hacia la derecha y un incremento hacia arriba (llamado pixel noreste, NE). Sea Q el punto de intersección de la línea que se discretiza y la línea de malla x = xp+ 1. En la formulación de Bresenham se calcula la diferencia entre las distancias verticales de E y NE a Q, y se usa el signo de la diferencia para seleccionar como mejor aproximación de la línea el pixel cuya distancia de Q sea la menor. En la formulación de punto medio se observa a qué lado de la línea se encuentra el punto medio M. Es fácil ver que si el punto medio está por encima de la línea, el pixel E es el más cerca no a la línea; si el punto medio está debajo, el pixel NE es el más cercano. La línea puede pasar entre E y NE o ambos pixeles pueden estar del mismo lado; en cualquier caso, la prueba de punto medio elige el más cercano. Además, el error (la distancia vertical entre el pixel elegido y la línea real) siempre es menor o igual que ½.
El algoritmo escoge NE como el siguiente pixel para la línea presentada en la figura 3.6. Ahora lo que necesitamos es una forma de calcular en qué lado de la línea se encuentra el punto medio. Representemos la línea por medio de una función implícita con coeficientes a, b y c: F(x, y) = ax + by + c = 0 (el coeficiente b de y no está relacionado con la intersección B del eje y en la forma de intersección de pendiente). Si dy = y1 - y0 y dx = x1- x0 la forma de intersección de pendiente se puede escribir como y=dy·x/dx+B por lo tanto, F(x,y) = dy·x— dx·y + B·dx = 0.
Aquí, a = dy, b = -dx y c = B·dx en la forma implícita.
Es sencillo verificar que F(x, y) es cero en la línea, positiva para los puntos debajo de la línea y negativa para los puntos encima de la línea. Para aplicar el criterio del punto medio, sólo tenemos que calcular F(M) = F(xp+1, yp + ½) y evaluar su signo. Como nuestra decisión se basa en el valor de la función en (xp + 1, yp + ½), definimos una variable de decisión d = F(xp + 1, yp + ½). Por definición, d = a·(xp + 1) + b(yp + ½) + c. Si d > 0, elegimos el pixel NE; si d < O, escogemos E; y si d = 0, podemos elegir cualquiera y seleccionamos E.
Después nos preguntamos qué sucede con la ubicación de M y por ende con el valor de d para la siguiente línea de la trama; por supuesto, los dos valores dependen de la elección de E o de NE. Si elegimos E, M se incrementa una vez en la dirección x. Por lo tanto,
dnuevo=F(xp + 2, yp + ½) = a(xp + 2) + b(yp + ½) + c
Pero
dviejo=a(xp + 1) + b(yp + ½) + c
Al restar d de dnuevo para obtener la diferencia incremental, escribimos dnuevo= dviejo+ a.
El incremento que se usa después de elegir E se denomina ΔE; ΔE= a = dy. En otras palabras, con sólo sumar ΔE podemos obtener en forma incremental el valor de la variable de decisión en el siguiente paso a partir del valor en el paso actual, sin tener que calcular F(M) directamente.
Si elegimos NE, M se incrementa una unidad tanto en la dirección x como
en la y. Entonces,
dnuevo=F(xp + 2, yp +3/2) = a(xp + 2) + b(yp + 3/2) + c .
Al restar dviejo a dnuevo para obtener la diferencia incremental, escribimos
dnuevo= dviejo+ a+b.
El incremento que sumamos a d después de elegir NE se llama ΔNE; ΔNE= a +b = dy -dx.
Resumamos la técnica incremental del punto medio. En cada paso, el algoritmo escoge entre dos pixeles con base en el signo del cálculo de la variable de decisión en la iteración anterior; después la variable de decisión se actualiza su mando ΔE o ΔNE al valor anterior, dependiendo de la elección del pixel.
Como el primer pixel es el primer punto extremo (x0, y0) y podemos calcular en forma directa el valor inicial de d eligiendo entre E y NE. El primer punto medio está en (x0+1, y0+½) y
F(x0+1, y0+½) = a(x0+1) + b( y0+½) + c=a·x0 +b·y0+c+ a+ b/2=F(x0, y0)+a+b/2
Sin embargo, (x0, y0) es un punto en la línea y F(x0, y0) y es por lo tanto 0; entonces, dinicio es simplemente a + b/2 = dy - dx/2. Con base en dinicio elegimos el segundo pixel, etcétera. Para eliminar la fracción en dinicio redefinimos nuestra F original multiplicándola por 2; F(x, y) = 2(ax + by + c). Así se multiplican por 2 cada constante y la variable de decisión (así como los incrementos ΔE y ΔNE) pero no se afecta el signo de la variable de decisión, que es lo que nos interesa para la prueba del punto medio.
La aritmética necesaria para evaluar dnuevo para cualquier iteración es una suma entera sencilla. No se requieren multiplicaciones que consuman mucho tiempo. Además, el ciclo interior es bastante sencillo, como se ve en el algoritmo de punto medio del programa 3.2. El primer enunciado en el ciclo, la evaluación de d, determina la elección del pixel, pero en realidad incrementamos x y y a la posición de ese pixel después de actualizar la variable de decisión (por cuestiones de compatibilidad con los algoritmos para círculos). Observe que esta versión del algoritmo sirve únicamente para líneas con pendiente entre O y 1; la generalización del algoritmo queda como tarea para el lector en el ejercicio 3.2. En [ Sproull ofrece una elegante derivación de la formulación de Bresenham del algoritmo como una serie de transformaciones de programa a partir del burdo algoritmo original. Aún no se ha presentado ningún equivalen te de la derivación para los círculos, pero sí se puede generalizar la técnica de punto medio, como veremos más adelante.
Void línea_punto_medio (int x0, int y0, int x1, int y1, int valor)
{
int dx, dy, inca_E, inca_NE, d, x, y;
dx=x1-x0;
dy=ty1-y0;
d=dy*2-dx;
inca_E=dx*2;
inca_ne=(dy-dx)*2;
y=x0;
y=y0;
escribir_pixel(x,y,valor)
While(x
If (d<=0){
d+=incr_E;
x++;
}else{
d+=inca_NE;
x++;
y++,
}
escribir_pixel(x,y,valor);
}
}
Para una línea que parte del punto (5, 8) al punto (9, 11), los valores sucesivos de d son 2, 0, 6 y 4, con lo cual se obtiene la selección de NE, E, NE y luego NL respectivamente, como se ilustra en la figura 3.7. La línea tiene una fuerte apariencia de escalera por la escala muy amplificada del dibujo y el espaciado artificialmente grande entre los pixeles que se usa para que quede clara la geometría del algoritmo. Por la misma razón, los dibujos en las secciones siguientes también hacen que las primitivas aparezca más irregulares que como se verían en realidad en la pantalla.
Examen
1. ¿Qué es una tubería de rendering?
Es la que permite pasar del espacio objeto hacia el espacio dispositivo
2. Haga la composición de transformaciones tales que:
- Se traslada un objeto sobre el vector(2,-3,1)
- Se escala en los factores α=0.5, β=1, γ=2
- Se rota sobre el eje z en 45°
3. Aplique la composición sobre los vectores
- (0,0,0)
[2.82 -1.41 2 1]
- (1,1,1)
[2.47 -.35 4 1]
- (2,0.5,1)
[3.18 -.35 4 1]
- (-1,0,1)
[2.47 -1.76 4 1]
4. Diseñe la matriz para una proyección isométrica a 45°
5. Proyecte los vectores del punto 3 utilizando la matriz de proyección del punto 4
[0 -0.29 1.70 1]
[0-70 -1.14 1.8 1]
[-1.41 0 0 1]
Hola profe
perdon por el retraso pero andaba algo apurado con las demas materias
pero aqui estan als demás tareas.
pero aqui estan als demás tareas.
miércoles, 10 de octubre de 2007
tarea 6
Algoritmo de Recorte de Cohen - Sutherland
The Cohen-Sutherland Line-Clipping Algorithm
The more efficient Cohen-Sutherland Algorithm performs initial tests on a line to determine whether intersection calculations can be avoided.
Steps for Cohen-Sutherland algorithm
- End-points pairs are check for trivial acceptance or trivial rejected using the outcode.
- If not trivial-accepance or trivial-rejected, divided into two segments at a clip edge.
- Iteratively clipped by testing trivial-acceptance or trivial-rejected, and divided into two segments until completely inside or trivial-rejected.
Pseudo-code of Cohen-Sutherland Algorithm.
Trivial acceptance/reject test
To perform trivial accept and reject tests, we extend the edges of the clip rectangle to divide the plane of the clip rectangle into nine regions. Each region is assigned a 4-bit code deteermined by where the region lies with respect to the outside halfplanes of the clip-rectangle edges. Each bit in the outcode is set to either 1 (true) or 0 (false); the 4 bits in the code correspond to the following conditions:
- Bit 1 : outside halfplane of top edge, above top edge
Y > Ymax - Bit 2 : outside halfplane of bottom edge, below bottom edge
Y <> - Bit 3 : outside halfplane of right edge, to the right of right edge
X > Xmax - Bit 4 : outside halfplane of left edge, to the left of left edge
X <>
In summary, the C-S algorithm is efficient when outcode testing can be done cheaply (for example, by doing bitwise operations in assembly language) and trivial acceptance or rejection is applicable to the majority of line segments .(For example, large windows - everything is inside , or small windows - everything is outside).
http://www.cc.gatech.edu/grads/h/Hao-wei.Hsieh/Haowei.Hsieh/code1.html
1 Examen CG
Genere un humanoide con posiciones establecidas por default y ademas hacer que reciba los parametros necesarios para poder generar cualquier pose.
http://hkeyland.googlepages.com/examen.zip
http://hkeyland.googlepages.com/examen.zip
martes, 9 de octubre de 2007
Tarea 5
Descargar el archivo pdf
Proyección Perspectiva
La palabra clave perspective determina la cámara perspectiva, que simula la típica cámara con objetivo. El ángulo de visión horizontal es determinado por la proporción entre la longitud del vector direction y la longitud del vector right, o por la palabra clave opcional angle, que es el modo aconsejado. El ángulo de visión ha de ser mayor de 0 y menor de 180 grados.
Proyección Ortográfica
La cámara ortográfica tiene dos modos de operación:
La proyección ortográfica pura. Esta proyección utiliza rayos paralelos para crear una imagen de la escena. El área de visión está determinada por las longitudes de los vectores right y up, que, por cierto, han de ser especificados, ya que con este tipo de proyección no se utilizan los de la cámara por defecto. En caso de ser omitidos, se usará el segundo método de proyección ortográfico de la cámara.
Si, en una cámara perspectiva, reemplazamos la palabra clave perspective por orthographic, y dejamos los demás parámetros igual, obtendremos una vista ortográfica con la misma área de imagen. Se puede conseguir lo mismo añadiendo la palabra clave angle a una cámara ortográfica. El valor de los ángulos es opcional. Ergo, este modo se activa si up y right no están presentes en la declaración de la cámara, o cuando la palabra clave angle sí lo está.
Debemos prestar atención al hecho de que las partes visibles de la escena pueden variar cuando cambiamos entre las vistas perspectiva y ortográfica. Mientras los objetos de interés estén cerca del punto look_at, seguirán visibles cuando cambiemos a la cámara ortográfica. Los objetos más lejanos pueden salir del encuadre mientras los cercanos permanecen a la vista.
Si los objetos están demasiado cerca a la situación de la cámara pueden desparecer. Demasiado cerca quiere decir, detrás del plano de proyección de la cámara ortográfica (el plano que atraviesa el punto look_at).
Proyección Perspectiva
La palabra clave perspective determina la cámara perspectiva, que simula la típica cámara con objetivo. El ángulo de visión horizontal es determinado por la proporción entre la longitud del vector direction y la longitud del vector right, o por la palabra clave opcional angle, que es el modo aconsejado. El ángulo de visión ha de ser mayor de 0 y menor de 180 grados.
Proyección Ortográfica
La cámara ortográfica tiene dos modos de operación:
La proyección ortográfica pura. Esta proyección utiliza rayos paralelos para crear una imagen de la escena. El área de visión está determinada por las longitudes de los vectores right y up, que, por cierto, han de ser especificados, ya que con este tipo de proyección no se utilizan los de la cámara por defecto. En caso de ser omitidos, se usará el segundo método de proyección ortográfico de la cámara.
Si, en una cámara perspectiva, reemplazamos la palabra clave perspective por orthographic, y dejamos los demás parámetros igual, obtendremos una vista ortográfica con la misma área de imagen. Se puede conseguir lo mismo añadiendo la palabra clave angle a una cámara ortográfica. El valor de los ángulos es opcional. Ergo, este modo se activa si up y right no están presentes en la declaración de la cámara, o cuando la palabra clave angle sí lo está.
Debemos prestar atención al hecho de que las partes visibles de la escena pueden variar cuando cambiamos entre las vistas perspectiva y ortográfica. Mientras los objetos de interés estén cerca del punto look_at, seguirán visibles cuando cambiemos a la cámara ortográfica. Los objetos más lejanos pueden salir del encuadre mientras los cercanos permanecen a la vista.
Si los objetos están demasiado cerca a la situación de la cámara pueden desparecer. Demasiado cerca quiere decir, detrás del plano de proyección de la cámara ortográfica (el plano que atraviesa el punto look_at).
Tarea 4
Modelar el puerco araña (puerco potter) de manera jerárquica
Codigo fuente
#include
#include "glut.h"
#include "Cubo.h"
using namespace std;
float angleX = 0.0f;
float angleY = 0.0f;
float angleZ = 0.0f;
float transZ = -10.0f;
float transY = 0.0f;
float transX = 0.0f;
float xScale=1;
float yScale=1;
float zScale=1;
int camina=0;
float caminar=0.0f,aux=0;
float codo=0;
float hom=0;
float cintu=0;
float rod=0;
float tor=0;
float al,an,pro;
GLint venAncho=600;
GLint venAlto=600;
float hum_camina(float cam);
void humanoide();
void reshape(int width, int height);
void keyboard(unsigned char key, int x, int y);
void init();
void cilindro(float r1,float r2,float an){
GLUquadricObj *qobj;
qobj = gluNewQuadric ();
gluQuadricDrawStyle(qobj,GLU_FILL);
gluCylinder(qobj, r1, r2,an, 20, 20);
glScalef(1,1,0.01f);
glutSolidSphere(r1,20,20);
glTranslatef(0,0,100*an);
glutSolidSphere(r2,20,20);
glTranslatef(0,0,-100*an);
glScalef(1,1,100);
};
int main(int argc, char **argv) {
al=3;
an=3;
pro=3;
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowPosition(20,20);
glutInitWindowSize( 600, 600);
glutCreateWindow("Puerco Araña");
init();
glutDisplayFunc(humanoide);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutIdleFunc(humanoide);
glutMainLoop();
return 0;
}
void humanoide(void){
glClearColor(0,.4,.5,0);
GLUquadricObj *qobj;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
glTranslatef(transX, transY, transZ);
glRotatef(angleX, 1.0f, 0.0f, 0.0f);
glRotatef(angleY, 0.0f, 1.0f, 0.0f);
glRotatef(angleZ, 0.0f, 0.0f, 1.0f);
glScalef(xScale, yScale, zScale);
////
//tronco
glPushMatrix();
glRotatef(90,0,1,0);
glColor3f(1.0f, 0.7f, 0.8f);
cilindro(1.5*an, 1.2*al, 5*pro);
glPushMatrix();//Pompis
//glColor3f(0.0f, 0.7f, 0.0f);
glTranslatef(-.05*an,0.1*al,4.0f*pro);
glutSolidSphere(1.4*an, 20, 20);
glPushMatrix();//cola
glTranslatef(0.0f*an,.8*al,1.0*pro);
glRotatef(-50,1,0,0);
cilindro(.2*an, .1*al, 1*pro);
glPopMatrix();//fin cola
glPopMatrix();//Pompis
//cabeza
glColor3f(1.0f, 0.7f, 0.8f);
glPushMatrix();
glTranslatef(0.0f,0.7*al,-1.0f);
glutSolidSphere(1.7*an, 20, 20);
//orejas
glPushMatrix();
glColor3f(1.0f, 0.6f, 0.6f);
glTranslatef(1.2*an,0.8*al,0*pro);
glPushMatrix();
glRotatef(90,0,1,0);
glRotatef(-45,1,0,0);
glutSolidCone(.5*an, .75*al, 50,5);
glPopMatrix();//cierre de oreja1
//oreja2
glTranslatef(-1.2*an,0.8*al,0*pro);
glPushMatrix();
glRotatef(-90,0,1,0);
glRotatef(-45,1,0,0);
glutSolidCone(.5*an, 1*al, 50,5);
glPopMatrix();//cierred e oreja2
//fleco
glPushMatrix();
glColor3f(1.0f, 0.8f, 0.0f);
glTranslatef(1.25*an,.9*al,0*pro);
//drawCube(.9*an, .4*al, 1*pro);
glRotatef(90,1,0,0);
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_FILL);
gluCylinder(qobj, .7*an, .6*al, .4*pro,7,200);
glTranslatef(-.2*an,0*al,.3*pro);
glutSolidSphere(.6*an, 10, 3);
glTranslatef(.4*an,.2*al,.0*pro);
glutSolidSphere(.6*an, 10, 3);
glPopMatrix();
glPopMatrix();//cierred e orejas
glColor3f(1.0f, 0.7f, 0.8f);
//Trompa
glPushMatrix();
glTranslatef(0,-0.5f,-1.0*pro);
glColor3f(1.0f, 0.6f, 0.6f);
glPushMatrix();
glRotatef(180,0,1,0);
glRotatef(10,1,0,0);
cilindro(.4*an, .9*al, 1.25*pro);
glPopMatrix();//cierra trompas
glPopMatrix();//cerramso trompa
//ojos si salen
glPushMatrix();
glColor3f(1.0f, 1.0f, 1.0f);
glTranslatef(0.8*an,1*al,-1.5*pro);
glutSolidSphere(.5*an, 20*al, 20*pro);
glPushMatrix();
glColor3f(0.0f, 0.0f, 0.0f);
glTranslatef(0*an,0*al,-0.5*pro);
glutSolidSphere(.07*an, 20*al, 20*pro);
glColor3f(0,0,0);
//Lentes
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_FILL);
glTranslatef(0*an,0*al,-.01*pro);
glutSolidTorus (.3, 1.7, 12, 24);
glTranslatef(-1.8*an,0*al,0*pro);
glutSolidTorus (.3, 1.7, 12, 24);
glRotatef(-60,1,0,0);
glTranslatef(.9*an,0*al,.1*pro);
glutSolidTorus (.3, 1.2, 12, 24);
//armazon de lentes
glTranslatef(1.5*an,0*al,-.01*pro);
glRotatef(20,1,0,0);
glRotatef(-10,0,1,0);
cilindro(.1*an,.1*al,2*pro);
glRotatef(20,0,1,0);
glTranslatef(-3*an,0*al,-.6*pro);
cilindro(.1*an,.1*al,2*pro);
glPopMatrix();
glPopMatrix();//cierre ojo1
//OJO2
glPushMatrix();
glColor3f(1.0f, 1.0f, 1.0f);
glTranslatef(-0.8*an,1*al,-1.5*pro);
glutSolidSphere(.5*an, 20*al, 20*pro);
glPushMatrix();
glColor3f(0.0f, 0.0f, 0.0f);
glTranslatef(0*an,0*al,-0.5*pro);
glutSolidSphere(.07*an, 20*al, 20*pro);
glPopMatrix();
glPopMatrix();//cierre ojo2
glPopMatrix();//cierre de cabeza
//manos
glColor3f(1.0f, 0.7f, 0.8f);
glPushMatrix();//mano1
glTranslatef(0.4f*an,-0.2f*al,1*pro);
glPushMatrix();//mano1
glRotatef(60,1,0,0);
cilindro(.5*an, .3*al, 1*pro);
//Pata Izquierda
glPushMatrix();//
glRotatef(30,1,0,0);
glTranslatef(0.0f*an,0.5f*al,.8*pro);
cilindro(.3*an, .1*al, 2*pro);
glPopMatrix();//
glPopMatrix();//mano1
glTranslatef(0.4f*an,-0.1f*al,-2*pro);
//Pata Derecha
glPushMatrix();//mano2
glRotatef(90,1,0,0);
glRotatef(30,1,0,0);
cilindro(.5*an, .3*al, 1*pro);
glPushMatrix();//
glRotatef(-30,1,0,0);
glTranslatef(-0.2f*an,-0.4f*al,0.7*pro);
cilindro(.3*an, .1*al, 2*pro);
glPopMatrix();//
glPopMatrix();//mano2
glPopMatrix();
//Patata Izquierda
glTranslatef(3.8*al,0,0);
glPushMatrix();//mano1
glTranslatef(0.4f*an,-0.2f*al,.7*pro);
glPushMatrix();//mano1
glRotatef(60,1,0,0);
cilindro(.7*an, .5*al, 1.4*pro);
glPushMatrix();//
glRotatef(30,1,0,0);
glTranslatef(0.0f*an,0.5f*al,.8*pro);
cilindro(.6*an, .2*al, 2*pro);
glPopMatrix();//
glPopMatrix();//mano1
//Pata Derecha
glTranslatef(0.4f*an,0*al,-1.4*pro);
glPushMatrix();
glRotatef(90,1,0,0);
glRotatef(30,1,0,0);
cilindro(.7*an, .5*al, 1.4*pro);
glPushMatrix();//
glRotatef(-30,1,0,0);
glTranslatef(0.0f*an,-0.5f*al,0.8*pro);
cilindro(.6*an, .2*al, 2*pro);
glPopMatrix();//
glPopMatrix();//mano2
glPopMatrix();//cierra manos
glPopMatrix();//cierre de tronco
//rabo
glPushMatrix();
glTranslatef(-0.1f,0.1f,0.0f);
glColor3f(1.0f, 0.6f, 0.6f);
glPushMatrix();
glRotatef(90,0,1,0);
cilindro( 0.02, 0.02, 0.1);
glPopMatrix();
glPopMatrix();
glFlush();
glutSwapBuffers();
}
void reshape(int width, int height){
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-20,20,-20,20,-40,40);
//gluPerspective(110,(GLfloat)width/(GLfloat)height, 0.1, 50);
glMatrixMode(GL_MODELVIEW);
venAncho = width;
venAlto = height;
}
void keyboard(unsigned char key, int x, int y){
switch(key)
{
case 27:
exit(0);
case 'w':
angleX += 1.0f;
break;
case 'W':
angleX -= 1.0f;
break;
case 's':
angleZ += 1.0f;
break;
case 'S':
angleZ -= 1.0f;
break;
case 'a':
angleY += 1.0f;
break;
case 'A':
angleY -= 1.0f;
break;
case 'z':
transZ += 0.1f;
break;
case 'Z':
transZ -= 0.1f;
break;
case 'x':
transX += 0.1f;
break;
case 'X':
transX -= 0.1f;
break;
case 'y':
transY += 0.1f;
break;
case 'Y':
transY -= 0.1f;
break;
case 'b':
xScale += 0.1f;
break;
case 'B':
xScale -= 0.1f;
break;
case 'n':
yScale += 0.1f;
break;
case 'N':
yScale -= 0.1f;
break;
case 'm':
zScale += 0.1f;
break;
case 'M':
zScale -= 0.1f;
break;
case 'c':
camina=0;
break;
case 'C':
camina=1;
break;
case 'V':
if(codo>=0)
codo-=1.0;
break;
case 'v':
if(codo<=135)
codo+=1;
break;
case 'G':
if(hom>=0)
hom-=1.0;
break;
case 'g':
if(hom<90)
hom+=1;
break;
case 'H':
if(cintu>=-20)
cintu-=1.0;
break;
case 'h':
if(cintu<=45)
cintu+=1;
break;
case 'R':
if(rod>=0)
rod-=1.0;
break;
case 'r':
if(rod<=45)
rod+=1;
break;
case 'F':
if(tor>=0)
tor-=1.0;
break;
case 'f':
if(tor<=45)
tor+=1;
break;
default:
break;
}
}
void init(){
glClearDepth(1.0);
glEnable(GL_DEPTH_TEST);
}
Codigo fuente
#include#include "glut.h"
#include "Cubo.h"
using namespace std;
float angleX = 0.0f;
float angleY = 0.0f;
float angleZ = 0.0f;
float transZ = -10.0f;
float transY = 0.0f;
float transX = 0.0f;
float xScale=1;
float yScale=1;
float zScale=1;
int camina=0;
float caminar=0.0f,aux=0;
float codo=0;
float hom=0;
float cintu=0;
float rod=0;
float tor=0;
float al,an,pro;
GLint venAncho=600;
GLint venAlto=600;
float hum_camina(float cam);
void humanoide();
void reshape(int width, int height);
void keyboard(unsigned char key, int x, int y);
void init();
void cilindro(float r1,float r2,float an){
GLUquadricObj *qobj;
qobj = gluNewQuadric ();
gluQuadricDrawStyle(qobj,GLU_FILL);
gluCylinder(qobj, r1, r2,an, 20, 20);
glScalef(1,1,0.01f);
glutSolidSphere(r1,20,20);
glTranslatef(0,0,100*an);
glutSolidSphere(r2,20,20);
glTranslatef(0,0,-100*an);
glScalef(1,1,100);
};
int main(int argc, char **argv) {
al=3;
an=3;
pro=3;
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowPosition(20,20);
glutInitWindowSize( 600, 600);
glutCreateWindow("Puerco Araña");
init();
glutDisplayFunc(humanoide);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutIdleFunc(humanoide);
glutMainLoop();
return 0;
}
void humanoide(void){
glClearColor(0,.4,.5,0);
GLUquadricObj *qobj;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
glTranslatef(transX, transY, transZ);
glRotatef(angleX, 1.0f, 0.0f, 0.0f);
glRotatef(angleY, 0.0f, 1.0f, 0.0f);
glRotatef(angleZ, 0.0f, 0.0f, 1.0f);
glScalef(xScale, yScale, zScale);
////
//tronco
glPushMatrix();
glRotatef(90,0,1,0);
glColor3f(1.0f, 0.7f, 0.8f);
cilindro(1.5*an, 1.2*al, 5*pro);
glPushMatrix();//Pompis
//glColor3f(0.0f, 0.7f, 0.0f);
glTranslatef(-.05*an,0.1*al,4.0f*pro);
glutSolidSphere(1.4*an, 20, 20);
glPushMatrix();//cola
glTranslatef(0.0f*an,.8*al,1.0*pro);
glRotatef(-50,1,0,0);
cilindro(.2*an, .1*al, 1*pro);
glPopMatrix();//fin cola
glPopMatrix();//Pompis
//cabeza
glColor3f(1.0f, 0.7f, 0.8f);
glPushMatrix();
glTranslatef(0.0f,0.7*al,-1.0f);
glutSolidSphere(1.7*an, 20, 20);
//orejas
glPushMatrix();
glColor3f(1.0f, 0.6f, 0.6f);
glTranslatef(1.2*an,0.8*al,0*pro);
glPushMatrix();
glRotatef(90,0,1,0);
glRotatef(-45,1,0,0);
glutSolidCone(.5*an, .75*al, 50,5);
glPopMatrix();//cierre de oreja1
//oreja2
glTranslatef(-1.2*an,0.8*al,0*pro);
glPushMatrix();
glRotatef(-90,0,1,0);
glRotatef(-45,1,0,0);
glutSolidCone(.5*an, 1*al, 50,5);
glPopMatrix();//cierred e oreja2
//fleco
glPushMatrix();
glColor3f(1.0f, 0.8f, 0.0f);
glTranslatef(1.25*an,.9*al,0*pro);
//drawCube(.9*an, .4*al, 1*pro);
glRotatef(90,1,0,0);
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_FILL);
gluCylinder(qobj, .7*an, .6*al, .4*pro,7,200);
glTranslatef(-.2*an,0*al,.3*pro);
glutSolidSphere(.6*an, 10, 3);
glTranslatef(.4*an,.2*al,.0*pro);
glutSolidSphere(.6*an, 10, 3);
glPopMatrix();
glPopMatrix();//cierred e orejas
glColor3f(1.0f, 0.7f, 0.8f);
//Trompa
glPushMatrix();
glTranslatef(0,-0.5f,-1.0*pro);
glColor3f(1.0f, 0.6f, 0.6f);
glPushMatrix();
glRotatef(180,0,1,0);
glRotatef(10,1,0,0);
cilindro(.4*an, .9*al, 1.25*pro);
glPopMatrix();//cierra trompas
glPopMatrix();//cerramso trompa
//ojos si salen
glPushMatrix();
glColor3f(1.0f, 1.0f, 1.0f);
glTranslatef(0.8*an,1*al,-1.5*pro);
glutSolidSphere(.5*an, 20*al, 20*pro);
glPushMatrix();
glColor3f(0.0f, 0.0f, 0.0f);
glTranslatef(0*an,0*al,-0.5*pro);
glutSolidSphere(.07*an, 20*al, 20*pro);
glColor3f(0,0,0);
//Lentes
qobj = gluNewQuadric();
gluQuadricDrawStyle(qobj,GLU_FILL);
glTranslatef(0*an,0*al,-.01*pro);
glutSolidTorus (.3, 1.7, 12, 24);
glTranslatef(-1.8*an,0*al,0*pro);
glutSolidTorus (.3, 1.7, 12, 24);
glRotatef(-60,1,0,0);
glTranslatef(.9*an,0*al,.1*pro);
glutSolidTorus (.3, 1.2, 12, 24);
//armazon de lentes
glTranslatef(1.5*an,0*al,-.01*pro);
glRotatef(20,1,0,0);
glRotatef(-10,0,1,0);
cilindro(.1*an,.1*al,2*pro);
glRotatef(20,0,1,0);
glTranslatef(-3*an,0*al,-.6*pro);
cilindro(.1*an,.1*al,2*pro);
glPopMatrix();
glPopMatrix();//cierre ojo1
//OJO2
glPushMatrix();
glColor3f(1.0f, 1.0f, 1.0f);
glTranslatef(-0.8*an,1*al,-1.5*pro);
glutSolidSphere(.5*an, 20*al, 20*pro);
glPushMatrix();
glColor3f(0.0f, 0.0f, 0.0f);
glTranslatef(0*an,0*al,-0.5*pro);
glutSolidSphere(.07*an, 20*al, 20*pro);
glPopMatrix();
glPopMatrix();//cierre ojo2
glPopMatrix();//cierre de cabeza
//manos
glColor3f(1.0f, 0.7f, 0.8f);
glPushMatrix();//mano1
glTranslatef(0.4f*an,-0.2f*al,1*pro);
glPushMatrix();//mano1
glRotatef(60,1,0,0);
cilindro(.5*an, .3*al, 1*pro);
//Pata Izquierda
glPushMatrix();//
glRotatef(30,1,0,0);
glTranslatef(0.0f*an,0.5f*al,.8*pro);
cilindro(.3*an, .1*al, 2*pro);
glPopMatrix();//
glPopMatrix();//mano1
glTranslatef(0.4f*an,-0.1f*al,-2*pro);
//Pata Derecha
glPushMatrix();//mano2
glRotatef(90,1,0,0);
glRotatef(30,1,0,0);
cilindro(.5*an, .3*al, 1*pro);
glPushMatrix();//
glRotatef(-30,1,0,0);
glTranslatef(-0.2f*an,-0.4f*al,0.7*pro);
cilindro(.3*an, .1*al, 2*pro);
glPopMatrix();//
glPopMatrix();//mano2
glPopMatrix();
//Patata Izquierda
glTranslatef(3.8*al,0,0);
glPushMatrix();//mano1
glTranslatef(0.4f*an,-0.2f*al,.7*pro);
glPushMatrix();//mano1
glRotatef(60,1,0,0);
cilindro(.7*an, .5*al, 1.4*pro);
glPushMatrix();//
glRotatef(30,1,0,0);
glTranslatef(0.0f*an,0.5f*al,.8*pro);
cilindro(.6*an, .2*al, 2*pro);
glPopMatrix();//
glPopMatrix();//mano1
//Pata Derecha
glTranslatef(0.4f*an,0*al,-1.4*pro);
glPushMatrix();
glRotatef(90,1,0,0);
glRotatef(30,1,0,0);
cilindro(.7*an, .5*al, 1.4*pro);
glPushMatrix();//
glRotatef(-30,1,0,0);
glTranslatef(0.0f*an,-0.5f*al,0.8*pro);
cilindro(.6*an, .2*al, 2*pro);
glPopMatrix();//
glPopMatrix();//mano2
glPopMatrix();//cierra manos
glPopMatrix();//cierre de tronco
//rabo
glPushMatrix();
glTranslatef(-0.1f,0.1f,0.0f);
glColor3f(1.0f, 0.6f, 0.6f);
glPushMatrix();
glRotatef(90,0,1,0);
cilindro( 0.02, 0.02, 0.1);
glPopMatrix();
glPopMatrix();
glFlush();
glutSwapBuffers();
}
void reshape(int width, int height){
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-20,20,-20,20,-40,40);
//gluPerspective(110,(GLfloat)width/(GLfloat)height, 0.1, 50);
glMatrixMode(GL_MODELVIEW);
venAncho = width;
venAlto = height;
}
void keyboard(unsigned char key, int x, int y){
switch(key)
{
case 27:
exit(0);
case 'w':
angleX += 1.0f;
break;
case 'W':
angleX -= 1.0f;
break;
case 's':
angleZ += 1.0f;
break;
case 'S':
angleZ -= 1.0f;
break;
case 'a':
angleY += 1.0f;
break;
case 'A':
angleY -= 1.0f;
break;
case 'z':
transZ += 0.1f;
break;
case 'Z':
transZ -= 0.1f;
break;
case 'x':
transX += 0.1f;
break;
case 'X':
transX -= 0.1f;
break;
case 'y':
transY += 0.1f;
break;
case 'Y':
transY -= 0.1f;
break;
case 'b':
xScale += 0.1f;
break;
case 'B':
xScale -= 0.1f;
break;
case 'n':
yScale += 0.1f;
break;
case 'N':
yScale -= 0.1f;
break;
case 'm':
zScale += 0.1f;
break;
case 'M':
zScale -= 0.1f;
break;
case 'c':
camina=0;
break;
case 'C':
camina=1;
break;
case 'V':
if(codo>=0)
codo-=1.0;
break;
case 'v':
if(codo<=135)
codo+=1;
break;
case 'G':
if(hom>=0)
hom-=1.0;
break;
case 'g':
if(hom<90)
hom+=1;
break;
case 'H':
if(cintu>=-20)
cintu-=1.0;
break;
case 'h':
if(cintu<=45)
cintu+=1;
break;
case 'R':
if(rod>=0)
rod-=1.0;
break;
case 'r':
if(rod<=45)
rod+=1;
break;
case 'F':
if(tor>=0)
tor-=1.0;
break;
case 'f':
if(tor<=45)
tor+=1;
break;
default:
break;
}
}
void init(){
glClearDepth(1.0);
glEnable(GL_DEPTH_TEST);
}
Tarea 3
Modelar jerárquicamente, construir el árbol del modelo y escribir el código que lo construye
El codigo completo lo puedes bajar aqui:
#include
#include "glut.h"
#include "Cubo.h"
using namespace std;
float angleX = 0.0f;
float angleY = 0.0f;
float angleZ = 0.0f;
float transZ = -10.0f;
float al,an,pro;
GLint venAncho=600;
GLint venAlto=600;
void HORMIGA();
void reshape(int width, int height);
void keyboard(unsigned char key, int x, int y);
int main(int argc, char **argv) {
al=1;
an=1;
pro=1;
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowPosition(20,20);
glutInitWindowSize( 600, 600);
glClearColor(0,0,0,0);
glEnable(GL_DEPTH_TEST);
glutCreateWindow("HORMIGA 3D");
glutDisplayFunc(HORMIGA);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutIdleFunc(HORMIGA);
glutMainLoop();
return 0;
}
void keyboard(unsigned char key, int x, int y){
switch(key)
{
case 27:
exit(0);
case 'w':
angleX += 5.0f;
break;
case 'W':
angleX -= 5.0f;
break;
case 's':
angleZ += 5.0f;
break;
case 'S':
angleZ -= 5.0f;
break;
case 'a':
angleY += 5.0f;
break;
case 'A':
angleY -= 5.0f;
break;
case 'z':
transZ += 0.1f;
break;
case 'Z':
transZ -= 0.1f;
break;
default:
break;
}
}
void HORMIGA(void){
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
glTranslatef(0.0f, 0.0f, transZ);
glRotatef(angleX, 1.0f, 0.0f, 0.0f);
glRotatef(angleY, 0.0f, 1.0f, 0.0f);
glRotatef(angleZ, 0.0f, 0.0f, 1.0f);
//cola
glPushMatrix();
glColor4f(.9f,0.40f,0.12f,.5f);
glScalef(4,4,4);
glTranslatef(0.0f,0.0f,0.0f);
drawCube(an,al,pro);
glPopMatrix();
//Tronco
glTranslatef(0.0f,4,0.0f);
glPushMatrix();
glColor4f(1.0f,0.40f,0.12f,.5f);
glScalef(3,2,2);
drawCube(an,al,pro);
glPopMatrix();
//cabeza
glPushMatrix();
glColor4f(.9f,0.60f,0.12f,.5f);
glTranslatef(0.0f,1.5*al,0.0f);
drawCube(an,al,pro);
glPopMatrix();
//cintura
glPushMatrix();
glColor4f(.7f,0.50f,0.12f,.5f);
glScalef(1,1.5,1);
glTranslatef(0.0f,-(7*al)/6,0.0f);
drawCube(an,al,pro);
glPopMatrix();
//patas
glPushMatrix();
glColor4f(.9f,0.40f,0.12f,.5f);
glRotatef(40.0f,0.0f,1.0f, 0.0f);
glRotatef(-20.0f,0.0f,0.0f, 1.0f);
glScalef(2,0.5,0.5);
glTranslatef(-1.2*an,1.3*al,-2.5*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(0.5f,2,2);
glRotatef(-70.0f,0.0f,1.0f, 0.0f);
glScalef(2.5,0.5,0.5);
glTranslatef(-0.73*an,0*al,2.4*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(1/2.5,2,2);
glRotatef(20.0f,0.0f,1.0f, 0.0f);
glScalef(1,0.5,0.5);
glTranslatef(-1.8*an,0.0f,-0.8*pro);
drawCube(an,al,pro);
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glColor4f(.9f,0.40f,0.12f,.5f);
glRotatef(30.0f,0.0f,1.0f, 0.0f);
glScalef(2,0.5,0.5);
glTranslatef(-1.2*an,0.0,-2.5*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(0.5f,2,2);
glRotatef(-70.0f,0.0f,1.0f, 0.0f);
glScalef(2.5,0.5,0.5);
glTranslatef(-0.73*an,0*al,2.4*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(1/2.5,2,2);
glRotatef(20.0f,0.0f,1.0f, 0.0f);
glScalef(1,0.5,0.5);
glTranslatef(-1.8*an,0.0f,-0.8*pro);
drawCube(an,al,pro);
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glColor4f(.9f,0.40f,0.12f,.5f);
glRotatef(40.0f,0.0f,1.0f, 0.0f);
glRotatef(20.0f,0.0f,0.0f, 1.0f);
glScalef(2,0.5,0.5);
glTranslatef(-1.2*an,-1.3*al,-2.5*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(0.5f,2,2);
glRotatef(-70.0f,0.0f,1.0f, 0.0f);
glScalef(2.5,0.5,0.5);
glTranslatef(-0.73*an,0*al,2.4*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(1/2.5,2,2);
glRotatef(20.0f,0.0f,1.0f, 0.0f);
glScalef(1,0.5,0.5);
glTranslatef(-1.8*an,0.0f,-0.8*pro);
drawCube(an,al,pro);
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glColor4f(.9f,0.40f,0.12f,.5f);
glRotatef(-40.0f,0.0f,1.0f, 0.0f);
glRotatef(20.0f,0.0f,0.0f, 1.0f);
glScalef(2,0.5,0.5);
glTranslatef(1.2*an,1.3*al,-2.5*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(0.5f,2,2);
glRotatef(70.0f,0.0f,1.0f, 0.0f);
glScalef(2.5,0.5,0.5);
glTranslatef(0.73*an,0*al,2.4*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(1/2.5,2,2);
glRotatef(-20.0f,0.0f,1.0f, 0.0f);
glScalef(1,0.5,0.5);
glTranslatef(1.8*an,0.0f,-0.8*pro);
drawCube(an,al,pro);
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glColor4f(.9f,0.40f,0.12f,.5f);
glRotatef(-30.0f,0.0f,1.0f, 0.0f);
glScalef(2,0.5,0.5);
glTranslatef(1.2*an,0.0,-2.5*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(0.5f,2,2);
glRotatef(70.0f,0.0f,1.0f, 0.0f);
glScalef(2.5,0.5,0.5);
glTranslatef(0.73*an,0*al,2.4*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(1/2.5,2,2);
glRotatef(-20.0f,0.0f,1.0f, 0.0f);
glScalef(1,0.5,0.5);
glTranslatef(1.8*an,0.0f,-0.8*pro);
drawCube(an,al,pro);
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glColor4f(.9f,0.40f,0.12f,.5f);
glRotatef(-40.0f,0.0f,1.0f, 0.0f);
glRotatef(-20.0f,0.0f,0.0f, 1.0f);
glScalef(2,0.5,0.5);
glTranslatef(1.2*an,-1.3*al,-2.5*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(0.5f,2,2);
glRotatef(70.0f,0.0f,1.0f, 0.0f);
glScalef(2.5,0.5,0.5);
glTranslatef(0.73*an,0*al,2.4*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(1/2.5,2,2);
glRotatef(-20.0f,0.0f,1.0f, 0.0f);
glScalef(1,0.5,0.5);
glTranslatef(1.8*an,0.0f,-0.8*pro);
drawCube(an,al,pro);
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glutSwapBuffers();
}
void reshape(int width, int height){
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-10,10,-10,10, 0.1, 20);
glMatrixMode(GL_MODELVIEW);
venAncho = width;
venAlto = height;
}
El codigo completo lo puedes bajar aqui:#include
#include "glut.h"
#include "Cubo.h"
using namespace std;
float angleX = 0.0f;
float angleY = 0.0f;
float angleZ = 0.0f;
float transZ = -10.0f;
float al,an,pro;
GLint venAncho=600;
GLint venAlto=600;
void HORMIGA();
void reshape(int width, int height);
void keyboard(unsigned char key, int x, int y);
int main(int argc, char **argv) {
al=1;
an=1;
pro=1;
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowPosition(20,20);
glutInitWindowSize( 600, 600);
glClearColor(0,0,0,0);
glEnable(GL_DEPTH_TEST);
glutCreateWindow("HORMIGA 3D");
glutDisplayFunc(HORMIGA);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutIdleFunc(HORMIGA);
glutMainLoop();
return 0;
}
void keyboard(unsigned char key, int x, int y){
switch(key)
{
case 27:
exit(0);
case 'w':
angleX += 5.0f;
break;
case 'W':
angleX -= 5.0f;
break;
case 's':
angleZ += 5.0f;
break;
case 'S':
angleZ -= 5.0f;
break;
case 'a':
angleY += 5.0f;
break;
case 'A':
angleY -= 5.0f;
break;
case 'z':
transZ += 0.1f;
break;
case 'Z':
transZ -= 0.1f;
break;
default:
break;
}
}
void HORMIGA(void){
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_PROJECTION);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
glTranslatef(0.0f, 0.0f, transZ);
glRotatef(angleX, 1.0f, 0.0f, 0.0f);
glRotatef(angleY, 0.0f, 1.0f, 0.0f);
glRotatef(angleZ, 0.0f, 0.0f, 1.0f);
//cola
glPushMatrix();
glColor4f(.9f,0.40f,0.12f,.5f);
glScalef(4,4,4);
glTranslatef(0.0f,0.0f,0.0f);
drawCube(an,al,pro);
glPopMatrix();
//Tronco
glTranslatef(0.0f,4,0.0f);
glPushMatrix();
glColor4f(1.0f,0.40f,0.12f,.5f);
glScalef(3,2,2);
drawCube(an,al,pro);
glPopMatrix();
//cabeza
glPushMatrix();
glColor4f(.9f,0.60f,0.12f,.5f);
glTranslatef(0.0f,1.5*al,0.0f);
drawCube(an,al,pro);
glPopMatrix();
//cintura
glPushMatrix();
glColor4f(.7f,0.50f,0.12f,.5f);
glScalef(1,1.5,1);
glTranslatef(0.0f,-(7*al)/6,0.0f);
drawCube(an,al,pro);
glPopMatrix();
//patas
glPushMatrix();
glColor4f(.9f,0.40f,0.12f,.5f);
glRotatef(40.0f,0.0f,1.0f, 0.0f);
glRotatef(-20.0f,0.0f,0.0f, 1.0f);
glScalef(2,0.5,0.5);
glTranslatef(-1.2*an,1.3*al,-2.5*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(0.5f,2,2);
glRotatef(-70.0f,0.0f,1.0f, 0.0f);
glScalef(2.5,0.5,0.5);
glTranslatef(-0.73*an,0*al,2.4*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(1/2.5,2,2);
glRotatef(20.0f,0.0f,1.0f, 0.0f);
glScalef(1,0.5,0.5);
glTranslatef(-1.8*an,0.0f,-0.8*pro);
drawCube(an,al,pro);
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glColor4f(.9f,0.40f,0.12f,.5f);
glRotatef(30.0f,0.0f,1.0f, 0.0f);
glScalef(2,0.5,0.5);
glTranslatef(-1.2*an,0.0,-2.5*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(0.5f,2,2);
glRotatef(-70.0f,0.0f,1.0f, 0.0f);
glScalef(2.5,0.5,0.5);
glTranslatef(-0.73*an,0*al,2.4*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(1/2.5,2,2);
glRotatef(20.0f,0.0f,1.0f, 0.0f);
glScalef(1,0.5,0.5);
glTranslatef(-1.8*an,0.0f,-0.8*pro);
drawCube(an,al,pro);
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glColor4f(.9f,0.40f,0.12f,.5f);
glRotatef(40.0f,0.0f,1.0f, 0.0f);
glRotatef(20.0f,0.0f,0.0f, 1.0f);
glScalef(2,0.5,0.5);
glTranslatef(-1.2*an,-1.3*al,-2.5*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(0.5f,2,2);
glRotatef(-70.0f,0.0f,1.0f, 0.0f);
glScalef(2.5,0.5,0.5);
glTranslatef(-0.73*an,0*al,2.4*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(1/2.5,2,2);
glRotatef(20.0f,0.0f,1.0f, 0.0f);
glScalef(1,0.5,0.5);
glTranslatef(-1.8*an,0.0f,-0.8*pro);
drawCube(an,al,pro);
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glColor4f(.9f,0.40f,0.12f,.5f);
glRotatef(-40.0f,0.0f,1.0f, 0.0f);
glRotatef(20.0f,0.0f,0.0f, 1.0f);
glScalef(2,0.5,0.5);
glTranslatef(1.2*an,1.3*al,-2.5*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(0.5f,2,2);
glRotatef(70.0f,0.0f,1.0f, 0.0f);
glScalef(2.5,0.5,0.5);
glTranslatef(0.73*an,0*al,2.4*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(1/2.5,2,2);
glRotatef(-20.0f,0.0f,1.0f, 0.0f);
glScalef(1,0.5,0.5);
glTranslatef(1.8*an,0.0f,-0.8*pro);
drawCube(an,al,pro);
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glColor4f(.9f,0.40f,0.12f,.5f);
glRotatef(-30.0f,0.0f,1.0f, 0.0f);
glScalef(2,0.5,0.5);
glTranslatef(1.2*an,0.0,-2.5*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(0.5f,2,2);
glRotatef(70.0f,0.0f,1.0f, 0.0f);
glScalef(2.5,0.5,0.5);
glTranslatef(0.73*an,0*al,2.4*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(1/2.5,2,2);
glRotatef(-20.0f,0.0f,1.0f, 0.0f);
glScalef(1,0.5,0.5);
glTranslatef(1.8*an,0.0f,-0.8*pro);
drawCube(an,al,pro);
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPushMatrix();
glColor4f(.9f,0.40f,0.12f,.5f);
glRotatef(-40.0f,0.0f,1.0f, 0.0f);
glRotatef(-20.0f,0.0f,0.0f, 1.0f);
glScalef(2,0.5,0.5);
glTranslatef(1.2*an,-1.3*al,-2.5*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(0.5f,2,2);
glRotatef(70.0f,0.0f,1.0f, 0.0f);
glScalef(2.5,0.5,0.5);
glTranslatef(0.73*an,0*al,2.4*pro);
drawCube(an,al,pro);
glPushMatrix();
glScalef(1/2.5,2,2);
glRotatef(-20.0f,0.0f,1.0f, 0.0f);
glScalef(1,0.5,0.5);
glTranslatef(1.8*an,0.0f,-0.8*pro);
drawCube(an,al,pro);
glPopMatrix();
glPopMatrix();
glPopMatrix();
glPopMatrix();
glutSwapBuffers();
}
void reshape(int width, int height){
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-10,10,-10,10, 0.1, 20);
glMatrixMode(GL_MODELVIEW);
venAncho = width;
venAlto = height;
}
domingo, 2 de septiembre de 2007
domingo, 26 de agosto de 2007
Tarea 1: Formatos
.jpg)
CGA
Siglas de Color Graphics Adapter, adaptador para gráficos a color. Fue el primer modo de vídeo estándar que se creó para el ordenador IBM PC. Se introdujo en 1981 en ordenadores destinados a juegos, ya que podía presentar en la pantalla hasta cuatro colores a la vez.
Precisaba de un monitor de color digital, de tipo RGB (Red-Green-Blue, rojo-verde-azul). Las primeras tarjetas CGA tenían una conexión especial con la que se podían conectar a un televisor.
Era un sistema de baja resolución, que no permitía sofisticadas tareas de edición de caracteres o el trabajo con aplicaciones de gráficos avanzados. Se presentaba en dos modos gráficos, uno de resolución 320 píxeles horizontales por 200 verticales, con cuatro colores, y otro de 640 píxeles horizontales por 200 verticales, con dos colores. Este modo de vídeo fue superado más tarde por los adaptadores EGA y VGA.
EGA
En informática, acrónimo inglés de Enhanced Graphics Adaptor (adaptador de gráficos mejorado), un adaptador de monitor de vídeo lanzado por IBM en 1984. El EGA es capaz de emular el CGA, acrónimo inglés de Color Graphics Adapter (Adaptador para Gráficos Color) y el MDA, así como de proporcionar varios modos de vídeo adicionales, entre ellos un modo de 43 caracteres de línea y un modo gráfico con 640 píxeles horizontales por 350 píxeles verticales y 16 colores seleccionados en una paleta de 64.
VGA
En informática, acrónimo de Video Graphics Array, un adaptador de vídeo presentado por IBM en 1987. El adaptador VGA reproduce todos los modos de vídeo de la tarjeta EGA (acrónimo de Enhanced Graphics Adapter) e incorpora varios modos adicionales. Los nuevos modos más conocidos son el de 640 píxeles horizontales por 480 verticales, con 16 colores simultáneos a elegir de una paleta de 262.144 colores, y el modo de 320 píxeles horizontales por 200 verticales, con 256 colores a elegir de una paleta de 262.144 colores.
SVGA, siglas de Super Video Graphics Array, súper adaptador de gráficos de vídeo. Es una versión mejorada del adaptador de vídeo VGA (Video Graphics Array), introducido por IBM en 1987.
Soporta una resolución de 800×600 píxeles y tiene una paleta que puede alcanzar hasta 16 millones de colores, aunque el número de ellos que puede mostrar un monitor de forma simultánea depende de la memoria de vídeo que tenga instalada el sistema.
Más recientemente se han establecido especificaciones de adaptadores de gráficos más avanzadas, como XGA (extended Graphics Array, matriz de gráficos extendida), con una resolución de 1.024×768 píxeles, SXGA (Super Extended Graphics Array), de 1.280×1.024 píxeles, y UXGA (Ultra Extended Graphics Array), que llega hasta 1.600×1.200 píxeles de resolución. Estas tarjetas gráficas se utilizan para trabajar con gráficos 3D avanzados, como los que se emplean en los juegos.
XGA
Acrónimo de extended Graphics Array (matriz de gráficos extendida), estándar de modo de vídeo. Fue introducido por primera vez en 1990, por IBM en su línea de ordenadores personales PS/2, y permitía una resolución de pantalla de hasta 1.024×768 puntos de pantalla o píxeles, lo que superaba los estándares originales de VGA (Video Graphics Array) y SVGA (Super Video Graphics Array), que alcanzaban 640×480 y 800×600 puntos de pantalla, respectivamente. Además, posibilitaba un mayor número de colores que el anterior sistema IBM 8514/A y daba soporte para vídeo no entrelazado. Posteriormente se presentaron alternativas más avanzadas, como SXGA y UXGA, con resoluciones de 1.280×1.024 y 1600×1.200 píxeles, aunque estas denominaciones no tuvieron una amplia repercusión, dada la aceptación general del término SVGA por parte de los fabricantes de hardware, que suelen referirse a cada resolución como un modo de vídeo SVGA diferente.
VESA
Video Electronics Standards Association ( Asociación para estándares electrónicos y de video ) es una asociación internacional de fabricantes de electrónica. Fue fundada por NEC en los años 80 del siglo XX , con el objetivo inicial de desarrollar pantallas de vídeo con una resolución común de 800x600 píxel es. Desde entonces, la VESA ha otros estándares relacionados con funcionalidades de vídeo en periféricos de los IBM PC y compatibles, como conectores, BIOS o características de la frecuencia, transmisión y sincronización de la imagen.
PGA
El regulador profesional de los gráficos era una tarjeta de los gráficos de IBM XT fabricada por IBM. Era muy avanzado, proporcionando ambos 2.o y acelerador de gráficos 3D para los usos del cad. Consistió en tres tarjetas interconectadas de ISA, y de hecho contuvo su propio procesador y memoria. Introducido en 1984, y hecho anticuado antes de 1987, la resolución levemente más alta ofrecida profesional del regulador de los gráficos (a menudo llamado “adaptador profesional de los gráficos” y a veces “arsenal profesional de los gráficos”) y la profundidad de color que el EGA, hasta 640 x 480 y 256 colores en 60 marcos/en segundo lugar. Fue pensado para el mercado del diseño automatizado y los 320 KB incluidos del ESPOLÓN de la exhibición y de un microprocesador a bordo, que te dieron la capacidad de hacer la rotación 3D y el truncamiento de imágenes. Mientras que nunca es extenso en ordenadores personales del consumidor-clase.
El adaptador de exhibición fue compuesto de tres tarjetas físicas (una con el microprocesador a bordo, el conectador del ROM de los soportes lógico inalterable y video de salida, y el otro sobre todo ESPOLÓN de abastecimiento dos) y ocupó dos ranuras de extensión adyacentes en el XT o EN la placa base; la tercera tarjeta fue situada entre las dos ranuras.
Además de su natural el modo 640 x 480, el PGC apoyó opcionalmente los modos documentados del texto y de gráficos del adaptador de los gráficos de color.
Siglas de Color Graphics Adapter, adaptador para gráficos a color. Fue el primer modo de vídeo estándar que se creó para el ordenador IBM PC. Se introdujo en 1981 en ordenadores destinados a juegos, ya que podía presentar en la pantalla hasta cuatro colores a la vez.
Precisaba de un monitor de color digital, de tipo RGB (Red-Green-Blue, rojo-verde-azul). Las primeras tarjetas CGA tenían una conexión especial con la que se podían conectar a un televisor.
Era un sistema de baja resolución, que no permitía sofisticadas tareas de edición de caracteres o el trabajo con aplicaciones de gráficos avanzados. Se presentaba en dos modos gráficos, uno de resolución 320 píxeles horizontales por 200 verticales, con cuatro colores, y otro de 640 píxeles horizontales por 200 verticales, con dos colores. Este modo de vídeo fue superado más tarde por los adaptadores EGA y VGA.
EGA
En informática, acrónimo inglés de Enhanced Graphics Adaptor (adaptador de gráficos mejorado), un adaptador de monitor de vídeo lanzado por IBM en 1984. El EGA es capaz de emular el CGA, acrónimo inglés de Color Graphics Adapter (Adaptador para Gráficos Color) y el MDA, así como de proporcionar varios modos de vídeo adicionales, entre ellos un modo de 43 caracteres de línea y un modo gráfico con 640 píxeles horizontales por 350 píxeles verticales y 16 colores seleccionados en una paleta de 64.
VGA
En informática, acrónimo de Video Graphics Array, un adaptador de vídeo presentado por IBM en 1987. El adaptador VGA reproduce todos los modos de vídeo de la tarjeta EGA (acrónimo de Enhanced Graphics Adapter) e incorpora varios modos adicionales. Los nuevos modos más conocidos son el de 640 píxeles horizontales por 480 verticales, con 16 colores simultáneos a elegir de una paleta de 262.144 colores, y el modo de 320 píxeles horizontales por 200 verticales, con 256 colores a elegir de una paleta de 262.144 colores.
SVGA, siglas de Super Video Graphics Array, súper adaptador de gráficos de vídeo. Es una versión mejorada del adaptador de vídeo VGA (Video Graphics Array), introducido por IBM en 1987.
Soporta una resolución de 800×600 píxeles y tiene una paleta que puede alcanzar hasta 16 millones de colores, aunque el número de ellos que puede mostrar un monitor de forma simultánea depende de la memoria de vídeo que tenga instalada el sistema.
Más recientemente se han establecido especificaciones de adaptadores de gráficos más avanzadas, como XGA (extended Graphics Array, matriz de gráficos extendida), con una resolución de 1.024×768 píxeles, SXGA (Super Extended Graphics Array), de 1.280×1.024 píxeles, y UXGA (Ultra Extended Graphics Array), que llega hasta 1.600×1.200 píxeles de resolución. Estas tarjetas gráficas se utilizan para trabajar con gráficos 3D avanzados, como los que se emplean en los juegos.
XGA
Acrónimo de extended Graphics Array (matriz de gráficos extendida), estándar de modo de vídeo. Fue introducido por primera vez en 1990, por IBM en su línea de ordenadores personales PS/2, y permitía una resolución de pantalla de hasta 1.024×768 puntos de pantalla o píxeles, lo que superaba los estándares originales de VGA (Video Graphics Array) y SVGA (Super Video Graphics Array), que alcanzaban 640×480 y 800×600 puntos de pantalla, respectivamente. Además, posibilitaba un mayor número de colores que el anterior sistema IBM 8514/A y daba soporte para vídeo no entrelazado. Posteriormente se presentaron alternativas más avanzadas, como SXGA y UXGA, con resoluciones de 1.280×1.024 y 1600×1.200 píxeles, aunque estas denominaciones no tuvieron una amplia repercusión, dada la aceptación general del término SVGA por parte de los fabricantes de hardware, que suelen referirse a cada resolución como un modo de vídeo SVGA diferente.
VESA
Video Electronics Standards Association ( Asociación para estándares electrónicos y de video ) es una asociación internacional de fabricantes de electrónica. Fue fundada por NEC en los años 80 del siglo XX , con el objetivo inicial de desarrollar pantallas de vídeo con una resolución común de 800x600 píxel es. Desde entonces, la VESA ha otros estándares relacionados con funcionalidades de vídeo en periféricos de los IBM PC y compatibles, como conectores, BIOS o características de la frecuencia, transmisión y sincronización de la imagen.
PGA
El regulador profesional de los gráficos era una tarjeta de los gráficos de IBM XT fabricada por IBM. Era muy avanzado, proporcionando ambos 2.o y acelerador de gráficos 3D para los usos del cad. Consistió en tres tarjetas interconectadas de ISA, y de hecho contuvo su propio procesador y memoria. Introducido en 1984, y hecho anticuado antes de 1987, la resolución levemente más alta ofrecida profesional del regulador de los gráficos (a menudo llamado “adaptador profesional de los gráficos” y a veces “arsenal profesional de los gráficos”) y la profundidad de color que el EGA, hasta 640 x 480 y 256 colores en 60 marcos/en segundo lugar. Fue pensado para el mercado del diseño automatizado y los 320 KB incluidos del ESPOLÓN de la exhibición y de un microprocesador a bordo, que te dieron la capacidad de hacer la rotación 3D y el truncamiento de imágenes. Mientras que nunca es extenso en ordenadores personales del consumidor-clase.
El adaptador de exhibición fue compuesto de tres tarjetas físicas (una con el microprocesador a bordo, el conectador del ROM de los soportes lógico inalterable y video de salida, y el otro sobre todo ESPOLÓN de abastecimiento dos) y ocupó dos ranuras de extensión adyacentes en el XT o EN la placa base; la tercera tarjeta fue situada entre las dos ranuras.
Además de su natural el modo 640 x 480, el PGC apoyó opcionalmente los modos documentados del texto y de gráficos del adaptador de los gráficos de color.
Bibliografía
Hola a todos
Hola mi niombre es Humberto Keymur Landeros
Este es el blog para la materia de computacíon gráfica
Suscribirse a:
Comentarios (Atom)