Previo práctica 2: OpenGL y modelado geométrico

1.- Investigue el uso, parámetros y variantes de los comandos de OpenGL

-glVertex: En OpenGL los objetos los definimos como un conjunto ordenado de vértices. Para especificar un vértice disponemos del comando glVertex*();

void glVertex{234}{sifd} (TYPE coords);

Especifica un vértice para el uso en la descripción de un objeto geométrico. El número de coordenadas puede ser de 2 (x,y), 3 (x,y,z) y 4 (x,y,z,w). Si se usa una versión en la que no se especifica z o w, será entendido que a z se le asigna el valor 0 y a w el valor 1.

NOTA: La llamada a glVertex*(), debe ser siempre ejecutada entre glBegin() y glEnd().

NOTA: Cuando se utilizan 4 coordenadas (x,y,z,w) nos referimos al sistema euclídeo, en el que la situación del punto será (x/w,y/w,z/w).

Ejemplos:
glVertex3f(1.0f,3.0f,4.0f);
glVertex2s(1,3);
GLdouble vect[3]={1.0,3.0,4.0};
glVertex3dv(vect);

-glBegin: Ya que conocemos como podemos especificar un vértice necesitamos como crear un punto, una línea o un polígono. Para que se dibuje correctamente, cada definición del vértice debe ir entre las llamadas glBegin() y glEnd().

void glBegin(GLenum mode);

Marca el inicio de una lista de vértices que describen una primitiva geométrica. El tipo de primitiva está indicado por modo, el cual puede tener uno de los siguientes valores.

Valores Significado

GL_POINTS Puntos individuales

GL_LINES Par de vértices interpretados como líneas de segmentos individuales

GL_POLYGON Límite de un polígono simple convexo

GL_TRIANGLES Trios de vértices interpretados como triángulos

GL_QUADS Cuádruples de vértices interpretados como polígonos de cuatro lados

GL_LINE_STRIP Series de líneas de segmentos conectados

GL_LINE_LOOP Igual que el anterior, pero con un segmento añadido entre el primer y el último vértice

GL_TRIANGLE_STRIP Enlazar tiras de triángulos

GL_TRIANGLE_FAN Enlazar abanicos de triángulos

GL_QUAD_STRIP Enlazar tiras de cuadriláteros

-glEnd: Marca el final de una lista de vértices. void glEnd(void);

-glPushMatrix: ealiza una copia de la matriz superior y la pone encima de la pila de matrices. Este comando es comúnmente utilizado para realizar copias de las matrices para no perder su información.

-glPopMatrix: elimina la matriz superior, regresando a la cima de la pila a la matriz que ocupaba ese puesto antes de la instrucción glPushMatrix.

-glTranslate: mueve el sistema de coordenadas original al punto especificado por (x,y,z). El vector de traslación se utiliza para calcular una matriz de traslación de 4x4. La matriz actual es multiplicada por esta matriz de traslación, con el producto reemplazando a la matriz actual. Es decir si M es la matriz actual y si T es la matriz de traslación, entonces M es reemplazada por M o T.

Si la matriz está en el modo GL_MODELVIEW o en el modo GL_PROJECTION, todos los objetos dibujados después de la llamada a glRotate también son afectados por la traslación. Hay que usar glPushMatrix yglPopMatrix para guardar y restaurar el sistema de coordenadas sin trasladar.

Tipos:
void glTranslated( GLdouble x, GLdouble y, GLdouble z )
void glTranslatef( GLfloat x, GLfloat y, GLfloat z )

Parámetros:
x,y,z especifican las coordenadas de un vector de traslación.

-glRotate: En OpenGL l rotación de un objeto se realiza llamado a la función glRotate, que realiza una rotación especificando la medida del ángulo en grados como primer parámtero y los parámetros “x”, “y” y “z”, los cuales representan el vector respecto al cual se efectuará dicha rotación, tomando dicho ángulo en sentido contrario a las manecillas del reloj.

void glRot ted(GLdouble angle ,GLdouble x ,GLdouble y ,GLdouble z );

void glRot tef(GLfloat angle ,GLfloat x ,GLfloat y ,GLfloat z );

-glScale: produce un escalamiento general a lo largo de los ejes x,y,z. Los tres argumentos indican los factores de escala deseados. La matriz actual es multiplicada por esta matriz y el producto reemplaza a la matriz actual. Es decir si M es la matriz actual y S es la matriz de escalamiento, entonces M es reemplazada por M o S. Si la matriz está en el modo GL_MODELVIEW o en el modo GL_PROJECTION, todos los objetos dibujados después de la llamada a glRotate también son afectados por el escalamiento. Hay que usar glPushMatrix yglPopMatrix para guardar y restaurar el sistema de coordenadas sin escalar.

glScaled,glScalef (multiplica la matriz actual por una matriz de escalamiento).

Tipos:
void glScaled( GLdouble x, GLdouble y, GLdouble z )
void glScalef( GLfloat x, GLfloat y, GLfloat z )

Parámetros:
x,y,z : especifican los factores de escala a lo largo de los ejes x,y,z respectivamente.

-glClear: void glClear(Glbitfdield mask)

Limpia los buffers especificados asignándoles los valores actuales. El argumento mask puede tener los siguientes valores:

Buffer Nombre

Buffer de color GL_COLOR_BUFFER_BIT

Buffer de fondo GL_DEPTH_BUFFER_BIT

Buffer de acumulación GL_ACCUM_BUFFER_BIT

Buffer de patrón GL_STENCIL_BUFFER_BIT

-glClearColor: void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);

Establece el color actual que va a aparecer en el fondo de la ventana en modo RGBA. Los valores red, green, blue y alpha están restringidos entre los valores [0,1]. El valor por defecto es (0,0,0,0) negro.

http://usuarios.lycos.es/andromeda_studios/paginas/tutoriales/aptutgl02.htm

2.- Código del tetraedro

#include
void dibuja() {
glClear(GL_COLOR_BUFFER_BIT);
// Se definen los vertices y se les asigna un color, como el tetraedro es una figura de 4 lados
glColor3f(1-t,1-t,0.5)
for i in range(100):
glBegin(GL_TRIANGLES);

glVertex3f(0.0,radio,0.0); #Cara frontal
glVertex3f(1.5,radio+5-t*10,0.0);
glVertex3f(4,radio-0.5,0.0);

#glColor3f(1,0.5,0.5)
glVertex3f(4,radio-0.5,0.0); #Cara lateral derecho
glVertex3f(1.5,radio+5-t*10,0.0);
glVertex3f(4,radio-0.5,1.5);

#glColor3f(0.5,1,0.5)
glVertex3f(0.0,radio,1.5); #Cara trasera
glVertex3f(1.5,radio+5-t*10,0.0);
glVertex3f(4,radio-0.5,1.5);

#glColor3f(0.5,0.5,0.5)
glVertex3f(0.0,radio,1.5); #Cara lateral izquierdo
glVertex3f(1.5,radio+5-t*10,0.0);
glVertex3f(0.0,radio,0.0);

glEnd()
glRotate(12,0.0,0.0,1.0)
}

3.- Prisma de base triangular

Objetos.h

void prismaTriangular(void){
glBegin(GL_TRIANGLES);
//Tapas del prisma
glColor3f(0.5, 0, 0.5); glVertex3f(0, 0, 0);
glColor3f(0.5, 0, 0.5); glVertex3f(0.5, 0, 0.5);
glColor3f(0.5, 0, 0.5); glVertex3f(1, 0, 0);
glColor3f(0.5, 0, 0.5); glVertex3f(0, 1, 0);
glColor3f(0.5, 0, 0.5); glVertex3f(0.5, 1, 0.5);
glColor3f(0.5, 0, 0.5); glVertex3f(1, 1, 0);
glEnd();
glBegin(GL_QUADS);
//Caras del prisma triangular
glColor3f(0.5, 0.5, 0.5); glVertex3f(0, 0, 0);
glColor3f(1, 0.5, 1); glVertex3f(1, 0, 0);
glColor3f(1, 0.5, 1); glVertex3f(1, 1, 0);
glColor3f(1, 0.5, 1); glVertex3f(0, 1, 0);
glColor3f(1, 0.5, 1); glVertex3f(1, 0, 0);
glColor3f(1, 0.5, 1); glVertex3f(0.5, 0, 0.5);
glColor3f(1, 0.5, 1); glVertex3f(0.5, 1, 0.5);
glColor3f(1, 0.5, 1); glVertex3f(1, 1, 0);
glColor3f(1, 0.5, 1); glVertex3f(0.5, 0, 0.5);
glColor3f(1, 0.5, 1); glVertex3f(0.5, 1, 0.5);
glColor3f(1, 0.5, 1); glVertex3f(0, 1, 0);
glColor3f(0.5, 0.5, 0.5); glVertex3f(0, 0, 0);

glEnd();