Previo práctica 2

1. Investigar el uso, parámetros y variantes de las siguientes funciones:

a) glVertex()

Esta función se usa para especificar un punto de dibujo en una paleta 3d ó 2d, en pocas palabras, se puede decir que representa el vértice de cualquier línea, punto o de una figura como lo son los polígonos. Es ta función puede tomar de 2 a 4 parámetros (siempre numéricos) según lo que se desee ya que estos parámetros representan coordenadas en un plano. Se puede utilizar para dibujos en 2d y en 3d y se le pueden dar valores enteros, flotantes, shorts y dobles, además de tener la opción de darle parámetros como arreglos. Las derivaciones de esta función y la forma en la que se invocan son las siguientes:

void glVertex2d( GLdouble x, GLdouble y )
void glVertex2f( GLfloat x, GLfloat y )
void glVertex2i( GLint x, GLint y )
void glVertex2s( GLshort x, GLshort y )
void glVertex3d( GLdouble x, GLdouble y, GLdouble z )
void glVertex3f( GLfloat x, GLfloat y, GLfloat z )
void glVertex3i( GLint x, GLint y, GLint z )
void glVertex3s( GLshort x, GLshort y, GLshort z )
void glVertex4d( GLdouble x, GLdouble y, GLdouble z, GLdouble w )
void glVertex4f( GLfloat x, GLfloat y, GLfloat z, GLfloat w )
void glVertex4i( GLint x, GLint y, GLint z, GLint w )
void glVertex4s( GLshort x, GLshort y, GLshort z, GLshort w )

***Para mandar arreglos se hace las funciones son:

void glVertex2dv(const GLdouble *v);
void glVertex2fv(const GLfloat *v);
void glVertex2iv(const GLint *v);
void glVertex2sv(const GLshort *v);
void glVertex3dv(const GLdouble *v);
void glVertex3fv(const GLfloat *v);
void glVertex3iv(const GLint *v);
void glVertex3sv(const GLshort *v);
void glVertex4dv(const GLdouble *v);
void glVertex4fv(const GLfloat *v);
void glVertex4iv(const GLint *v);
void glVertex4sv(const GLshort *v);


b) glBegin

Esta función sirve para delimitar los vértices de un primitivo o de un grupo de primitivos parecidos.Esta función acepta un argumento simple que especifica en cuál de las 10 formas los vértices son interpretados (puntos, líneas, triángulos, cuadrados, polígonos). El argumento mandado a esta función representa el número total de vértices especificados y siendo este número un entero pudiendo empezando desde uno. La forma en que se invoca a la función es la siguiente:

void glBegin(GLenum mode);

Las variables simbólicas que se pueden mandar (GLenum mode) son:

GL_POINTS: Trata a cada vértice como un punto.
GL_LINES: Cada par de vértices en un segmento de línea independiente.
GL_LINE_STRIP: Dibuja un grupo de segmentos de línea conectados, desde el primer vértice hasta el último.
GL_LINE_LOOP:Dibuja un grupo de segmentos de línea conectados, desde el primer vértice hasta el último y luego regresa al primero.
GL_TRIANGLES:Trata a cada tripleta de vértices como un triángulo independiente.
GL_TRIANGLE_STRIP: Dibuja un grupo de triángulos conectados. Un triángulo es definido para cada vértice presentado después de los primeros dos vértices.
GL_TRIANGLE_FAN:Dibuja un grupo de triángulos conectados pero ahora estos triángulos tienen un vértice central en común.
GL_QUADS:Trata a cada grupo de 4 vértices como un cuadrilatero independiente.
GL_QUADS_STRIP:Dibuja un grupo de cuadrilateros conectados. Un cuadrilatero es definido para cada par de vértices presentados después del primer par.
GL_POLYGON:Dibuja un polígono convexo. Los vértices 1 a n definen al polígono.

c) glEnd()

Esta función no requiere parámetros ya que sólo indica que ahí se acaban las sentencias para definir glBegin(). Esta función es necesaria al escribir glBegin() ya que marca el fin de esta función.

d) glPushMatrix()

Si hay una pila de matrices, esta función hace una copia de la matriz superior y la pone encima de la pila, haciendola que las dos primeras matrices sean iguales. La forma en la que se declara la función es:

void glPushMatrix();

Existe una pila de matrices para cada modo de matriz. En el modo GL_MODELVIEW la profundidad de la pila es de al menos 32 y en los modos GL_PROJECTION y GL_TEXTURE la profundidad es de al menos 2.

e) glPopMatrix();

Con esta función se elimina en una pila la matriz superior, quedando así en la primera posición de la pila la matriz que era la primera antes de usar la función glPushMatrix(). La función se declara de la siguiente forma:

void glPopMatrix();

f) glTranslate();

Esta es una instrucción que sirve para trasladar nuestro sistema de coordenadas (los ejes) desde el punto de origen hasta el punto de las coordenadas especificadas mediante los parámetros (x,y,z). Estos parámetros pueden ser de tipo doble o flotante y se declara de la siguiente manera:

void glTranslated (GLdouble x, GLdoubley, GLdoublez);
void glTranslatef (GLfloat x, GLfloat y, GLfloat z);

g) glRotate();

Como su nombre lo dice, esta función sirve para poder rotar en grados un vector (x,y,z). Esta función toma los parámetros primero del ángulo en grados y después los parámetros x,y,z que representan al vector respecto al cual se dara la rotación. El ángulo se toma en sentido contrario a las manecillas del reloj y su declaración es la siguiente:

void glRotated (GLdouble angle, GLdouble x, GLdouble y, GLdouble z);
void glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloatz);

h) glScale();

Esta función produce un escalamiento general a lo largo de los ejes x, y, z. Esta función requiere de 3 parámetros que indican el factor de escala deseado para cada uno de los ejes. Estos parámetros pueden ser de tipo doble o flotantes y su declaración es la siguiente:

void glScaled (GLdouble x, GLdouble y, GLdouble z);
void glScalef (GLfloat x, GLfloat y, GLfloat z);

i) glClear();

Se usa para limpiarr el contenido del buffer. Sus parámetros son banderas que indican qué buffer se va a limpiar. Al aplicar la función regresa al buffer los valores por defecto. La declaración de esta función es la siguiente:

void glClear (GLbitfield mask);

con los siguientes parámetros

GL_COLOR_BUFFER_BIT (Buffer de color RGBA)
GL_DEPTH BUFFER_BIT (Buffer de profundidad)
GL_STENCER_BUFFER_BIT (Buffer de esténcil)
GL_ACCUM_BUFFER_BIT (Buffer acumulado)

j) glClearColor();

Esta función especifica los valores de rojo, verde, azul y alpha usados por la función glClear() para limpiar los buffer de color, es decir, limpia la pantalla con el color especificado. El rango de valores que se pueden especificar es de [0,1] y su valor por defecto es (0,0,0,0). La forma en la que se invoca es la siguiente:

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

2. Hacer el código para un Tetraedro

#include

void HaceTetra() {

glClear(GL_COLOR_BUFFER_BIT);

glBegin(GL_TRIANGLE_STRIP);

glColor3f(1, 0, 0);
glVertex3f(0, 2, 0);
glVertex3f(-1, 0, 1);
glVertex3f(1, 0, 1);
glColor3f(0, 1, 0);
glVertex3f(0, 0, -1.4);
glVertex3f(0, 2, 0);
glVertex3f(-1, 0, 1);

glEnd();
glFlush();
}

void SetPantalla() {

glClearColor(1, 1, 1, 1.0);
glColor3f(0.0, 0.0, 0.0);
glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(-2, 2, -2, 2, 1, 50);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(0, 0, -3);
glRotatef(50, 1, 0, 0);
glRotatef(45, 0, 1, 0);
}

int main(int argc, char** argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutInitWindowPosition(80, 80);
glutInitWindowSize(400, 300);
glutCreateWindow("Tetra");
glutDisplayFunc(HaceTetra);
SetPantalla();
glutMainLoop();
}

3.Hacer un archivo de cabecera y llamarlo Objetos.h y ahí poner el código que dibuja un tetraedro.

Objetos.h

void HaceTetra() {

glClear(GL_COLOR_BUFFER_BIT);
glBegin(GL_TRIANGLE_STRIP);

glColor3f(1, 0, 0);
glVertex3f(0, 2, 0);
glVertex3f(-1, 0, 1);
glVertex3f(1, 0, 1);
glColor3f(0, 1, 0);
glVertex3f(0, 0, -1.4);
glVertex3f(0, 2, 0);
glVertex3f(-1, 0, 1);

glEnd();
glFlush();
}

4. En ese mismo archivo de cabecera hacer una función que dibuje un prisma triangular

objetos.h

void reshape(int width, int height)
{
glViewport(0, 0, width, height);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1, 1, -1, 1, -1, 1);
glMatrixMode(GL_MODELVIEW);
}

void drawTetraedro()
{
glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity();
glBegin(GL_TRIANGLE_STRIP);
glColor3f(.6,.7,0);
glVertex3f(1,0,0);glVertex3f(0,1,0);glVertex3f(0,0,1);
glColor3f(1,1,0);
glVertex3f(-.5,-.5,.5);glVertex3f(0,1,0);glVertex3f(0,0,1);
glColor3f(.6,.7,.4);
glVertex3f(-.5,-.5,.5);glVertex3f(1,0,0);glVertex3f(0,0,1);
glEnd();
glFlush();

}

void prismaTriangular()
{
glClear(GL_COLOR_BUFFER_BIT);
glLoadIdentity();
glBegin(GL_QUADS);
glColor3f(1,0,0);
glVertex3f(-0.5,0.5,-0.5);
glVertex3f(-0.5,-0.5,0.5);
glColor3f(1,.75,.75);
glVertex3f(0.5,-0.5,0.5);
glColor3d(1,.2,.2);
glVertex3f(0.5,0.5,-0.5);

glEnd();

glBegin(GL_TRIANGLE_STRIP);
glColor3f(.85,0,0);
glVertex3f(0,.72,0);
glColor3f(1,0,0);
glVertex3f(.5,.5,-.5);
glColor3f(1,.75,.75);
glVertex3f(-.5,.5,-.5);
glEnd();
glFlush();

}

void init()
{
glClearColor(0,0,0,0);
}

#include
#include "objetos.h"

int main(int argc, char **argv)
{
glutInit(&argc, argv);
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
glutCreateWindow("Prisma de base triangular");
init();
glutDisplayFunc(prismaTriangular);
glutReshapeFunc(reshape);
glutMainLoop();
return 0;
}