32.- Definiciones y estados OpenGL:

A estas alturas se supone que tenéis ya cierto nivel de OpenGL, es hora de que reviséis la documentación oficial OpenGL y aprendáis por vosotros mismos. En la tabla inferior están las definiciones y estados más usuales de OpenGL. No dudéis en revisar la documentación oficial, ya se que está en ingles, pero es lo que hay. Espero que con este nivel seáis capaces de seguir a la perfección el resto de las prácticas.

Muchas gracias por leer estos tutoriales y felicitaciones a churristian8 por currarse la versión web para Scenebeta.com.

Definición de las Caras Frontales.
 
glFrontFace( GL_enum Parámetros );
  Parámetros:
  - GL_CCW  // Sentido Antihorario.
  - GL_CW   // Sentido Horario.
 
glCullFace( GL_enum Parámetros );
  Parámetros:
  - GL_FRONT  // NO CALCULA LAS CARAS FRONTALES.
  - GL_BACK   // NO CALCULA LAS CARAS TRASERAS. 

Definición Puntos, Lineas y Polígonos
 
glPointSize( GLfloat tamaño ); // Establece el tamaño de los puntos
glLineWidth( GLfloat grosor ); // Establece el grosor de las líneas
 
GLushort patron = 0x5555; // Patrón de la Línea, usando los BITS.
GLint    factor = 5;      // Factor de repetición del Patrón.
glLineStipple( GLint factor, GLushort patron ); // Configuración de la Línea.
 
glPolygonMode( GL_enum Parámetros, GL_enum Modo );
  Parámetros:
  - GL_FRONT // CARA FRONTAL.
  - GL_BACK // CARA TRASERA.
  - GL_FRONT_AND_BACK // AMBAS CARAS.
  Modo:
  - GL_FILL  // RELLENO.
  - GL_LINE  // LINEAS.
  - GL_POINT // PUNTOS.
 
glShadeModel( GLenum ParámetroS );
  Parámetros:
  - GL_FLAT
  - GL_SMOOTH 

Estados OpenGL:
 
glEnable( GLenum parámetros );
glDisable( GLenum parámetros );
  parámetros:
  - GL_ALPHA_TEST
  - GL_AUTO_NORMAL
  - GL_BLEND
  - GL_COLOR_MATERIAL
  - GL_CULL_FACE
  - GL_DEPTH_TEST
  - GL_FOG
  - GL_LIGHT0_7
  - GL_LIGHTING
  - GL_LINE_SMOOTH
  - GL_LINE_STIPPLE
  - GL_NORMALIZE
  - GL_POINT_SMOOTH
  - GL_POLYGON_SMOOTH
  - GL_POLYGON_STIPPLE
  - GL_RESCALE_NORMAL
  - GL_STENCIL_TEST
  - GL_TEXTURE_1D
  - GL_TEXTURE_2D
  - GL_TEXTURE_GEN_Q
  - GL_TEXTURE_GEN_R
  - GL_TEXTURE_GEN_S
  - GL_TEXTURE_GEN_T
 
GLboolean glIsEnabled( GLenum parámetros );
  parámetros: Los mismos que para glEnable();
 
glPushAttrib( GLenum parámetros );
glPopAttrib();
  parámetros:
  - GL_COLOR_BUFFER_BIT   GL_ALPHA_TEST  | GL_BLEND  |  glClearColor();
  - GL_DEPTH_BUFFER_BIT   GL_DEPTH_TEST
  - GL_FOG_BIT            GL_FOG
  - GL_LINE_BIT           GL_LINE_SMOOTH | GL_LINE_STIPPLE
  - GL_STENCIL_BUFFER_BIT GL_STENCIL_TEST
  - GL_TRANSFORM_BIT      GL_MATRIX_MODE | GL_NORMALIZE
  - GL_LIGHTING_BIT
    GL_COLOR_MATERIAL | GL_COLOR_MATERIAL_FACE | GL_LIGHT_MODEL_LOCAL_VIEWER
    GL_LIGHTING       | GL_SHADE_MODEL         | GL_LIGHT_MODEL_TWO_SIDE
  - GL_POLYGON_BIT
    GL_CULL_FACE    | GL_CULL_FACE_MODE | GL_FRONT_FACE
    GL_POLYGON_MODE | GL_POLYGON_SMOOTH | GL_POLYGON_STIPPLE
  - GL_ENABLE_BIT
    GL_ALPHA_TEST     | GL_AUTO_NORMAL    | GL_BLEND
    GL_COLOR_MATERIAL | GL_CULL_FACE      | GL_DEPTH_TEST
    GL_FOG            | GL_LIGHT0_7       | GL_LIGHTING
    GL_LINE_SMOOTH    | GL_LINE_STIPPLE   | GL_NORMALIZE
    GL_POINT_SMOOTH   | GL_POLYGON_SMOOTH | GL_POLYGON_STIPPLE
    GL_STENCIL_TEST   | GL_TEXTURE_1D     | GL_TEXTURE_2D
    GL_TEXTURE_GEN_Q  | GL_TEXTURE_GEN_R  | GL_TEXTURE_GEN_S
    GL_TEXTURE_GEN_T 

Práctica Nº 21 - Superficie Nurbs

En la librería "GLU.H" incluida en OpenGL podemos crear rápidamente curvas y superficies NURB. Nos centraremos en las superficies puesto que son más complejas y útiles.

NURBS significa Non-Uniform Rational B-Spline ( concatenado-B racional no uniforme ). Los concatenados-B funcionan de forma similar a las curvas de Bezier, pero descomponiendo las curvas en segmentos. La forma de un segmento dado sólo sufre la influencia de los cuatro puntos de control más cercanos, produciendo una curva ensamblada, cada segmento de la cual exhibe características muy parecidas a las de la curva de bezier de cuarto orden. Esto implica que una gran curva con muchos puntos de control es inherentemente más suave, con cada uno de los puntos de unión entre segmentos exhibiendo una continuidad de tipo C3.

La potencia real de las NURBS es que podemos exprimir la influencia de los cuatro puntos de control de un segmento cualquiera de la curva para producir la suavidad necesaria. Este control se realiza a través de una secuencia de valores denominados nudos.

Para cada punto de control definimos dos valores nodales. El rango de valores para nudos se ajusta al dominio paramétrico de u y v, y no pueden ser descendientes. Esto se debe a que los valores de nudo determinan la influencia de los puntos de control que caen dentro de ese rango en el espacio u/v. La secuencia de nudos define la intensidad de la influencia de cada punto en el dominio. Si se repite el valor de un nudo, los puntos cercanos a este valor paramétrico tienen una mayor influencia.

La repetición de los valores de nudo se denomina multiplicidad nodal. Una mayor multiplicidad nodal decrece la curvatura de la curva o superficie dentro de esa región. Ejemplo de secuencia de nudos de las NURBS:

GLfloat Knots[8] = {0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 1.0f};

Descargar Practica nº21 (Solo usuarios registrados)

Práctica Nº 22 - Superficie Nurbs Trimming

A la superficie Nurbs vamos a practicarle un agujero con forma de triángulo usando la técnica llamada "Trimming". Consite en definir dos áreas, primero un área exterior que comprenda toda la figura, y luego un área interior con la forma del agujero.

Utilizaremos la funciones:

"gluBeginTrim( theNurb );"
 
"gluEndTrim( theNurb );"

Descargar Practica nº22 (Solo usuarios registrados)

Práctica Nº 23 - Carga Modelos "OBJ" y "MTL"

Usando un editor 3D, en este caso el "Wings 3D" he exportado dos modelos en formato OBJ + MTL. La librería "Cargador_Obj.h" s e en carga de leer los archivos en formato de texto y cargarlos en memoria. También en el caso de que los modelos tengan texturas las podemos cargar usando la librería "Texturas_2D.h".

El siguiente paso consiste en compilar dos listas dibujando los modelos cargados en memoria, terminado esto se deben borrar los objetos de la memoria para liberar espacio. No es así con el caso de las texturas, puesto que estas no se almacenan en las listas compiladas. El resto del código es sobradamente conocido si se ha seguido todas las prácticas.

Descargar Practica nº23 (Solo usuarios registrados)

Práctica Nº 24 - Mini Motor de Partículas

La idea es usar un array dinámico "<deque>" para insertar una cierta cantidad de procesos de diversas clases. Luego se recorre el array usando la función miembro "control" la cual efectúa los cálculos pertinentes de movimiento, destrucción y generación de nuevos procesos.

Terminada la primera vuelta se vuelve a recorrer pero esta vez usando la función miembro "mostrar" para pintar en la pantalla todos los procesos.

Para crear una array dinámico usamos "deque < c_proceso *> procesos;", como podemos ver solo nos permite insertar un tipo de clase llamada "c_proceso", pero nosotros queremos insertar tres tipos de clases diferentes: "c_esfera", "c_cubo" y "c_chispa".

La solución al problema consiste en utilizar dos funciones miembro virtuales y la herencia de clases.

Todas las clases tienen definida la misma función miembro virtual llamada "mostrar", pero cuando la ejecutamos muestra cosas diferentes según sea una esfera, un cubo, o una chispa.

La función miembro "control" es común he igual para todas las clases, por eso es solo definida en la clase base que es "c_proceso". El resto de las clases heredan de la clase base "c_proceso" sus datos y funciones miembro. Las funciones miembro son públicas, mientras los datos miembro son privados o protegidos.

El destructor de todas las clases también es virtual, esto tiene sentido cuando vemos que no se comportan de igual manera las clases cuando se destruyen. Cuando se destruye por ejemplo un cubo, este genera una cierta cantidad de chispas que duran un instante. Pero cuando se destruye una chispa no sucede nada más.

Descargar Practica nº24 (Solo usuarios registrados)

Práctica Nº 25 - Sonido y Musica de Fondo

Esta práctica es la misma que la 24, nos centraremos en la implementación del sonido y la música de fondo usando "SDL_mixer". Estudiar la documentación SDL y mirar el código de la librería "Sonido.h"

Descargar Practica nº25 (Solo usuarios registrados)

Práctica Nº 26 - Textura Cube_Map

GL_ARB_texture_cube_map -> GL_TEXTURE_CUBE_MAP_EXT

La librería "Entorno.h" además de encargarse de dibujar el entorno, también crea de forma muy sencilla una textura Cube_Map. Solo hay que ver el resultado para comprender sencillamente de que se trata.

A partir de esta práctica primero tenemos que comprobar que la tarjeta gráfica es compatible con las extensiones que utilicemos.

Descargar Practica nº26 (Solo usuarios registrados)

Práctica Nº 27 - Multitextura

GL_ARB_multitexture

En la práctica anterior usamos una Textura Cube_Map en un modelo OBJ que no tenía texturas. ¿ Pero que pasa si las tiene ? ...

La solución más elegante es utilizar "glActiveTextureARB( GL_TEXTURE0_ARB );" para que la tarjeta combine las diferentes texturas automáticamente.

Solo están implementadas "GL_TEXTURE0_ARB" y "GL_TEXTURE1_ARB" pero puede que vuestra tarjeta soporte más números de texturas para combinar, el número exacto lo podéis mirar con "sdl_con_opengl->Texture_Units_ARB".

Descargar Practica nº27 (Solo usuarios registrados)