martes, 28 de agosto de 2007

Previo practica 1 (laboratorio)

1.- Investigue los siguientes comandos de openGL:

glVertex(): Sirve para definir vértices y puede tomar de dos a cuatro parámetros de cualquier tipo numérico.

gLBegin(): a OpenGL que los siguientes llamados a la funcion deberan ser interpretados como vértices para ensamblar la primitiva especificada en (enum mode) estos bloques se terminan con glEnd()

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

glPopMatrix(): La función glPopMatrix() elimina la matriz superior, quedando en la parte superior dela pila la matriz que estaba en el momento de llamar a la función glPushMatrix().

glTranslate(): glTranslate es una instrucción para trasladar el sistema de coordenadas (los ejes). que crea la matriz de transformación y la multiplica por la matriz que esté activa en ese instante

glRotate(): función de alto nivel que construye la matriz de transformación y la multiplica por la matriz activa, glRotate. Lleva como parámetros el ángulo a rotar (en grados, sentido horario), y después x, y y z del vector sobre el cual queremos rotar el objeto.

glScale(): La función glScale lleva como parámetros la escala en x, y y z, respectivamente. LA función relaiza una transformación de escala incrementa el tamaño de nuestro objeto expandiendo todos los vértices a lo largo de los tres ejes por los factores especificados

glClear():Se inicializan el buffer con los valores predeterminados

glClearColor():
Limpia la pantalla con el color especificado en el parámetro


2.- Escribe un programa que dibuje un tetraedro:

float Ang=0;
void Idle(void);
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}

void display(void)
{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
// glColor3f (1.0, 0.0, 0.0); /* 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, 2.0, 1.0); /* modeling transformation */
glRotatef(Ang,0.0f,1.0f,0.0f);

//función que dibuja el tetraedro:-----

glutWireTetrahedron( );


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, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
// glutDisplayFunc(Render);
glutIdleFunc(Idle);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

void Idle(void)
{
Ang++;
display();
}



3.- Cree un archivo de cabecera, llámela objetos.h y ahi deposite el código del tetraedro

/*objetos.h Ximena Gutiérrez V.
CAbecera que contendrá diversas figuras geométricas*/


void tetraedro (void) /*funcion que dibuja un tetraedro urtlizando una función de GLUT*/
{
glutWireTetrahedron( );

}



4.-En objetos.h incluya ahora una función que dibuje un pequeño prisma de base triangular y llame a esta funcion prismaTriangular() desde el código principal

/*objetos.h Ximena Gutiérrez V.
CAbecera que contendrá diversas figuras geométricas*/


void tetraedro (void) /*funcion que dibuja un tetraedro urilizando una función d eopenGL*/
{
glutWireTetrahedron( );

}

void prismaTriangular (void) /*función que dibuja un prisma triangular*/
{
glBegin(GL_POLYGON); // para dibujar tapa triangular
glColor
3f(1.0f,0.0f,0.0f);
glVertex3f( -1.0f, -1.0f, 0.0f);
glColor3f(0.0f,1.0f,0.0f);
glVertex3f(1.0f,-1.0
f, 0.0f);
glColor3f(1.0f,0.0f,1.0f);
glVertex3f( 0.0f,-1.0f, -2.0f);
glEnd();



glColor3f(1,0,0);

glBegin(GL_POLYGON); // para dibujar una pared

glVertex3f( 1.0f, 1.0f, 0.0f);


glVertex3f(-1.0f, 1.0f, 0.0f);

glVertex3f(-1.0f,-1.0f, 0.0f);

glVertex3f( 1.0f,-1.0f, 0.0f);


glEnd();


glColor3f(1,1,0);
glBegin(GL_POLYGON); //para dibujar una pared

glVertex3f( 1.0f, -1.0f, 0.0f);
glVertex3f( 0.0f, -1.0f, -2.0f);

glVertex3f(0.0f,1.0f, -2.0f);

glVertex3f( 1.0f,1.0f, 0.0f);
glEnd();

glColor3f(0,0,1);

glBegin(GL_POLYGON); //para dibujar una pared

glVertex3f( 0.0f, -1.0f, -2.0f);
glVertex3f( 0.0f, 1.0f, -2.0f);

glVertex3f(-1.0f,1.0f, 0.0f);

glVertex3f( -1.0f,-1.0f, 0.0f);
glEnd();

glColor3f(0,1,1);

glBegin(GL_POLYGON); //para dibujar la otra tapa triangular

glVertex3f( -1.0f, 1.0f, 0.0f);

glVertex3f(1.0f,1.0f, 0.0f);

glVertex3f( 0.0f,1.0f, -2.0f);
glEnd();


}


Llamada desde el código principal:


#include
#include "objetos.h"


float Ang=0;
void Idle(void);
void init(void)
{
glClearColor (0.0, 0.0, 0.0, 0.0);
glShadeModel (GL_FLAT);
}

void display(void)
{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
// glColor3f (1.0, 0.0, 0.0); /* 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, 2.0, 1.0); /* modeling transformation */
glRotatef(Ang,0.0f,1.0f,0.0f);


// llamada a la funcion que dibuja el prisma //

prismaTriangular();


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, 500);
glutInitWindowPosition (100, 100);
glutCreateWindow (argv[0]);
init ();
glutDisplayFunc(display);
// glutDisplayFunc(Render);
glutIdleFunc(Idle);
glutReshapeFunc(reshape);
glutKeyboardFunc(keyboard);
glutMainLoop();
return 0;
}

void Idle(void)
{
Ang++;
display();
}

Reporte de práctica 1 (LABORATORIO)

Reporte de práctica 1

Ambiente de trabajo y configuración de proyectos

1.- Describa paso a paso de la manera más detallada la forma en qué se crea un proyecto en visual studio 2005

- Para crear un nuevo proyecto, se debe ir al menú: file->new->project

- Se debe elegir el tipo de aplicación, en nuestro caso: visual c++->win32->win32 console application.

- Posteriormente se debe seleccionar : empty project, y después finalizar

- Para empezar a programar, es necesario dirigirse a la ventana “solution explorer” y seleccionar: source->new item->c++ file->nombreprograma.c

- Para compilar un programa:

Build->start debugging

2.-¿Qué pasos hay que seguir par configurar un proeycto que peuda utilizar la librería GLUT?

-Dirigirse al menú:

project->properties->c++->aditional include directories

En esa ventana se debe especificar el directorio /include que contenga el archivo glut.h. En linker->additional library directories se debe especificar el directorio /lib que contenga archivos .lib de glut.

3.- ¿Cuál es la diferencia entre un proyecto c++ win 32 console application y un proyecto c++ win32 project?

- Un proyecto win 32 console aplication al ejecutarlo se abre la shell, al contrario de un proyecto win32 project.

4.-¿Cuál es la diferencia entre ejecutar la aplicación recién creada en modo de depuración (debug) y sin depurador?

-Con depurador, puedes ver el contenido de las variables en tiempo de ejecucion

5.-¿Qué es una variable de entorno? ¿Cómo se configura en windows vista?

Una variable de entorno es un objeto designado para contener información usada por una o más aplicaciones

Para configurar seleccionar:

Inicio->computer->propiedades del sistema->opciones avanzadas->variables de entorno

lunes, 27 de agosto de 2007

Tarea 1 (TEORIA) formatos de video

CGA:

La Color Graphics Adapter (Adaptador de Gráficos en Color) o CGA, comercializada en 1981, fue la primera tarjeta gráfica en color de IBM (originalmente llamada "Color/Graphics Monitor Adapter"), y el primer estándar gráfico en color para el IBM PC.

La tarjeta estándar CGA de IBM incorporaba 16 kilobytes de VRAM, y permitía mostrar varios modos gráficos y de texto. La resolución máxima de cualquier modo era 640×200, y la mayor profundidad de color soportada era de 4 bits (16 colores). El modo más conocido, usado en la mayoría de los juegos CGA, mostraba 4 colores a una resolución de 320×200.

Aunque los 4 colores estaban considerados generalmente como el límite para la tarjeta CGA, era posible aumentar esa cantidad mediante varios métodos (algunos oficiales, otros no).

La tarjeta CGA funcionaba con monitores en color CRT RGBI. Estaba basada en el controlador de vídeo Motorola MC6845 y tenía una paleta de 16 colores. El rojo, el verde y el azul correspondían a cada uno de los tres rayos catódicos y el negro significaba que todos los rayos estaban casi apagados. El cian era una mezcla de los rayos verde y azul, el magenta de azul y rojo, y el marrón de verde y rojo. El blanco (o gris claro) era una mezcla de los tres rayos.

Los 8 colores restantes se conseguían mediante la activación de un bit de intensificación, consiguiendo una versión más brillante de cada color, aunque el gris oscuro no se podía distinguir del negro en muchos monitores. El diseño RGB + bit de intensificación de la CGA se denominaba RGBI.

Modos de texto estándar

La CGA permitía usar dos modos de texto:

40×25 caracteres con hasta 16 colores

80×25 caracteres con hasta 16 colores

Modos gráficos estándar

320×200 píxeles

640×200 pixeles


Tarjeta de Vídeo EGA

Enchanced Graphics Adapter (EGA), se trata de una tarjeta gráfica superiora la CGA. En el modo texto ofrece una resolución de 14x18 puntos y en el modo gráfico dos resoluciones diferentes de 640x200 y 640x350 a 4 bits, lo que da como resultado una paleta de 16 colores, siempre y cuando la tarjeta esté equipada con 256KB de memoria de video RAM.

EGA es el acrónimo inglés de Enhanced Graphics Adapter, el la especificación estándar de IBM PC para visualización de gráficos, situada entre CGA y VGA en términos de rendimiento gráfico (es decir, amplitud de colores y resolución). Introducida en 1984 por IBM para sus nuevos PC-AT, EGA tenía una profundidad de color de 16 colores y una resolution de hasta 640×350 píxels. La tarjeta EGA tenía 16 kilobytes de ROM para ampliar la de la BIOS con funciones adicionales e incluía el generador de direcciones de video Motorola MC6845.

La tarjeta IBM EGA básica incluía 64 kilobytes de memoria de vídeo, suficiente para controlar un monitor monocromo de alta resolución (y permitiendo todos los colores a 640×200 and 320×200 modes), si bien la mayoría de las tarjetas EGA y sus clones incluían 256 KB de memoria. Algunos clones de EGA de terceros fabricantes (principalmente las tarjetas de ATI Technologies y Paradise boards) incluían un rango de gráficos ampliado (por ejemplo, 640×400, 640×480 and 720×540), así como detección automática del monitor, y algunas un modo especial de 400 líneas para usar con monitores CGA.

El estándar EGA quedó obsoleto con la introducción del VGA por IBM en Abril de 1987 con los ordenadores PS/2.



VGA

(Video Graphics Array) es una norma de visualización de gráficos para ordenadores creada en 1987 por IBM. VGA pertenece a la familia de normas que comenzó con la MDA.

Como pasó con otros productos de IBM, múltiples fabricantes crearon tarjetas clónicas compatibles con la norma VGA. Aunque la norma VGA está anticuada, siendo superada por la XGA, es último estándar de visualización de gráficos de IBM que la mayoría de los fabricantes decidieron seguir. A partir de entonces cada fabricante creó mejoras del estándar VGA incompatibles entre sí denominadas SVGA).

Las tarjetas compatibles con la norma VGA requieren de un mínimo de 256 KB de memoria de vídeo. Pueden mostrar hasta 256 colores elegidos de una paleta de 262.144 colores y alcanzar una resolución de 720 x 480 con un refresco de pantalla de 70 Hz.

La norma VGA admite hasta cuatro planos de vídeo, desplazamientos de la imagen, división de la pantalla en zonas independientes y creación de caracteres definidos mediante software.

La norma VGA admite los modos gráficos de las versiones anteriores: MCGA, EGA, CGA y MDA y añade un nuevo modo de 640 x 480 con 16 colores. Además admite otros modos no documentados por IBM. Estos modos no documentados reciben el nombre genérico de modos X.

Los modos de texto son idénticos a los de la norma EGA, pero además añade uno nuevo de 80 x 50 caracteres. La mayoría de los programas emplean el modo de 80 x 25 caracteres. El color de cada carácter se puede elegir de una paleta de dieciséis colores, excepto en el caso de que esté parpadeando, que se reduce a una paleta de ocho colores.


XGA

XGA (siglas en inglés de Extended Graphics Array) es un estándar de visualización de gráficos para ordenadores creada por IBM en 1990.

El estándar XGA permite una resolución máxima de 1024x768 pixeles, con una paleta gráfica de 256 colores, o 640x480 con una profundidad de color de 16 bits por pixel (65.536 colores)

El estándar XGA-2 permite mayor profundidad de color para el modo 1024x768 y mayor frecuencia de refresco de pantalla, además de una resolución de 1360x1024 a 16 colores. Todos estos modos de pantalla conservan la relación de aspecto 4:3 redondeado a 8 pixeles.

El formato de presentación de gráficos XGA no es un reemplazo para el estándar Super VGA, sino sólo un conjunto particular de modos de pantalla dentro del rango permitido por éste. No debe confundirse XGA con el estándar VESA EVGA, comercializado en las mismas fechas.


VESA

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íxeles. 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.

Principales estándares de la VESA:

  • Bus VESA (VLB), antes usado como un puerto de alta velocidad para vídeo (antes de la aparición del AGP)
  • VESA BIOS Extensions (VBE), usado para crear un estándar que soportase modos de vídeo avanzados (a alta resolución y miles de millones de colores).
  • VESA Display Data Channel (DDC), que permite a los monitores autoidentificarse a las tarjetas gráficas a las que están conectados. Sin embargo, el formato actual de identificación es llamado EDID (Extended Display Identification Data).
  • VESA Display Power Management Signaling, que permite a los monitores comunicar que tipo de modos de ahorro de energía poseen.
  • Digital Packet Video Link
  • Una serie de patentes sobre pantallas planas, conectores de video y sincronización del vídeo digital.

WXGA

WXGA es una norma de visualización de gráficos de ordenador. Abreviatura de "Wide eXtended Graphics Array" o "Wide XGA", que es una ampliación de resolución horizontal (el término "wide" se refiere al formato panorámico) del formato XGA.

La resolución de éste formato es de 1366x768 que constituyen una imagen de 1.049.088 píxeles con una relación de aspecto de 16:9 (16 unidades horizontales por 9 verticales). Aunque la relación de aspecto considerada panorámica más usada en el entorno informático es de 16:10.

Éstas especificaciones no pueden considerarse exactas puesto que existen variantes entre fabricantes (1280x768, 1280x800, 1360x768, 1440x900)

Esta norma suele ser usada en ordenadores portátiles y en televisores de gran formato aunque no todos ellos, a pesar de tener la resolución suficiente, soportan señales de Alta definición (HDTV).

GPA

GPA (graphics performance accelerator): Los aceleradores de desempeño de gráficos son módulos de memoria altamente especializados usados únicamente en sistemas que utilizan el chipset 815E de Intel y gráficos integrados.

Las tarjetas GPA proveen un caché dedicado al motor de gráficos integrado. La tarjeta Gpa es una tarjeta de 32-bit 133 MHz 4 MB SDRAM. Debido a que la tarjeta GPA solamente es utilizada con los gráficos integrados y ocupa el spot AGP, no puede ser usada al mismo tiempo como una tarjeta de video AGP agregada. Los gráficos 3D pueden obtener un desempeño extra del 20 %, utilizando la tarjeta GPA con los gráficos integrados.