"Ningún juego dura tanto hasta que te lo terminas como el que te programas tú mismo,
ninguno te absorbe tanto y ninguno te produce tanta satisfacción cuando lo has acabado"
Programacion de videojuegos
Inicio Curso de programación de juegos 15. Carga de modelos y uso de "Vertex arrays"
Domingo 22 de Octubre del 2017

Menu principal
Colaborar (con PayPal)

Para continuar con el trabajo de esta Web y poder pagar el hosting, viene bien la ayuda que sea. Gracias a todos.

Importe: 

Ultimas descargas
19.Jan

Clase que permite dibujar texto en OpenGL con mucha facilidad.Usa FreeType2.Para ver que hace y c...


15. Carga de modelos y uso de "Vertex arrays" Imprimir Correo electrónico
Videojuegos - Curso de Programación de juegos
Escrito por Vicengetorix   
Índice de Artículos
15. Carga de modelos y uso de "Vertex arrays"
Carga del modelo
Vertex Arrays
Todas las páginas
Llegamos por fin, a uno de los temas que mas interesan al ser ya, muy vistoso el resultado; la carga de modelos hechos con un programa de diseño 3D.
El tema no es facil. Tiene la complicacion inicial de conocer el formato del fichero donde esta el modelo. Luego la carga puede ser mas o menos laboriosa. Al final tendremos que tener el modelo cargado de forma que lo podamos pintar lo mas eficientemente posible.
En nuestro caso usaremos el formato de modelos propio del programa Caligari truSpace, cuyos ficheros tienen extension ".COB". Lo haremos en su forma ASCII, los que se graban como fichero de texto y podemos editar con un sencillo editor. Esto pemite saber exactamente lo que hay dentro del fichero y no depender de unas especificaciones parciales y en ingles.
Luego pintaremos el modelo usando el metodo de "vertex arrays".

El primer aviso es para los que no tengan todavia el programa Caligari truSpace:
Si no tienes el programa, bajatelo, pero ya. La ultima version es gratis porque la empresa ha sido comprada por Microsoft y no se sabe que va a ser de ella (que den el programa gatis es un mal presagio).
El programa es totalmente funcional, con posibilidad de cargar modelos de varios formatos habituales, y grabarlos tambien a otros. Permite, ademas de modelar, hacer animaciones por huesos (esqueletales suena mal) y tambien permite convertirlas a animaciones por vertice. Permite triangular los modelos y no se que mas cosas. Un programa en condiciones, vaya, y totalmente gratis.
Ademas el formato .COB en ASCII nos dara la facilidad de entender bien que es cada cosa.
Veremos primero como es este formato para luego ver como lo cargamos.
Lo primero sera abrir un fichero .COB que se haya guardado en truSpace con la pestaña de ASCII en un editor de texto y ver como esta estructurado.

Lo primero en un fichero de estos es algo asi:

1
2
3
4
5
6
7
Caligari V00.01ALH             
BitM V0.01 Id 0 Parent 0 Size 00007756
ThumbNailHdrSize 40
ThumbHeader:28 00 00 00 5e 00 00 00 5e 00 00 00 01 00 18 00 00 00 00 ...
ColorBufSize 26696
ColorBufZipSize 2515
ZippedThumbnail:78 9c ed 99 d9 53 93 59 1a 87 fd 0f c4 6e ad 52 ab 0d ...

Hay que decir que en este tipo de ficheros hay mucha morralla. De esto, pasaremos de todo.
Hay dos lineas que empiezan con ThumbHeader y ZippedThumbnail que yo suelo borrar a mano porque acupan mucho y solo son un pequeño bitmap codificado para que se vea en el truSpace al meterlo en un repositorio (o algo asi).

Luego puede haber la definicion de un grupo, de la que paso tambien. Al final iremos a las zonas que nos interesan.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
PolH V0.08 Id 83869972 Parent 83869708 Size 00028088
Name Sphere
center 0.614419 0.20392 1.0758
x axis 0.999921 -0.0125365 0
y axis 0.0125365 0.999921 0
z axis 0 0 1
Transform
0.0345737 0.000204491 0 0.614419
-0.000433467 0.0163104 0 0.20392
0 0 0.0351248 1.0758
0 0 0 1
World Vertices 201
0.260287 0.109467 0.959493
0.199215 0.200480 0.959493
0.107814 0.260971 0.959493
-0.000000 0.281733 0.959493
-0.107815 0.259603 0.959493
-0.199215 0.197951 0.959493

PolH indica una malla de puntos. En nuestro caso, si el modelo esta formado por mas de una las uniremos y tendremos cargado una sola malla con el modelo completo.
Luego estan el nombre y los datos de los ejes para esta malla que no vamos a usar (nunca me ha hecho falta).
Despues tras la linea que pone Transform si que hay algo importante. Es una matriz de 4 x 4 que modifica cada uno de los vertices de esta malla, asi que tendremos que leerla para multiplicar cada vertice por esta matriz y asi obtener la posicion final.
Despues lo mas importante. Pone World Vertices, los vertices de la malla, y luego el numero de vertices de esta malla. Luego la lista de coordenadas de los vertices.

Tras los vertices, las coordenadas de textura.

1
2
3
4
5
6
7
8
9
0.374136 0.905620 0.183717
-0.084495 0.892289 0.415415
0.084495 0.893361 0.415415
Texture Vertices 249
0.062500 0.909091
0.125000 0.909091
0.187500 0.909091
0.250000 0.909091
0.035396 0.909091

Luego las caras de la malla, cada una con los indices de las coordenadas de vertice y de textura de cada vertice de la cara

1
2
3
4
5
6
7
8
9
10
11
12
13
14
0.903127 0.597715
0.906458 0.399723
0.905948 0.568487
Faces 326
Face verts 3 flags 0 mat 0
<97,4> <98,88> <0,0>
Face verts 3 flags 0 mat 0
<1,1> <0,0> <98,141>
Face verts 3 flags 0 mat 0
<1,1> <98,141> <96,89>
Face verts 3 flags 0 mat 0
<2,2> <1,1> <96,139>
Face verts 3 flags 0 mat 0
<2,2> <96,139> <95,90>

Cada cara indica los vertices que tiene. En nuestro caso deberan ser siempre 3, triangulos (no siempre es asi si no tenemos cuidado de triangular el modelo antes de guardarlo). Tambien el indice material con que pintarla (cada malla tiene sus materiales).
El formato de cada vertice es "<indice_de_vertice,indice_de_textura>", 3 por cara.

Cuando termina con las caras hay una serie de lineas que no usaremos. Luego encontraremos uno o mas materiales por cada malla. Un ejemplo de material sin textura.

1
2
3
4
5
6
7
8
9
10
11
12
13
Mat1 V0.07 Id 83764900 Parent 83869972 Size 00000106
mat# 0
shader: phong facet: auto32
rgb 0.258824,0.164706,0.141176
alpha 1 ka 0.1 ks 0.1 exp 0 ior 1
ShBx V0.04 Id 83764901 Parent 83764900 Size 00000607
Shader class: color
Shader name: "plain color" (plain)
Number of parameters: 1
colour: color (66, 42, 36)
Flags: 3
Shader class: transparency
...

La definicion de material es mas larga pero solo usaremos las primeras lineas.
La que pone mat# 0 es que es el material 0 (lo que ponia en cada cara).
La que empieza en rgb es el color del material.
la que empieza por alpha tiene factores que modificaran cada componente del material.
Ya no vamos a usar mas datos si no hay textura. Si la hubiera apareceria asi.

1
2
3
4
5
6
7
8
9
Mat1 V0.06 Id 85040684 Parent 85012492 Size 00000189
mat# 0
shader: phong facet: auto87
rgb 0.784314,0.784314,0.784314
alpha 1 ka 0.3 ks 0.3 exp 0.2 ior 1
texture: 35C:\Ficheros\3dmods\animal\RHINO.jpg
offset 0,0 repeats 1,1 flags 2
ShBx V0.02 Id 85040685 Parent 85040684 Size 00000715
Shader class: color

Vemos que aparece una linea que empieza por texture que no aparecia antes y contiene el path completo del fichero de la textura. Nosotros, en nuestro programa despreciaremos el path y nos quedaremos solo con el nombre de fichero para colocarlo luego donde nos de la gana. Las texturas no son siempre del tamaño que le gusta a OpenGL. Si no lo es, basta con cambiar el tamaño a 128x256, 512x64, ...
Tras esta linea, otra con los datos de offset y de repeticion de la textura. Esto tambien lo usaremos por si la textura fuera repetida y movida en el modelo.

Eso es todo lo que vamos a usar para cargar un modelo. Las listas del vertices, coordenadas de textura y de caras pueden ser muy largas, pero es lo que realmente necesitamos.
El que quiera investigar y usar mas cosas, adelante.

Hay una cosa que no se si echareis de menos, las normales. Otros formatos las incluyen, este no. Tranquilidad, lo que haremos sera generarlas nosotros a partir de los vertices de las caras.

Este es un modelo de ejemplo, el que usaremos en el programa del capitulo, sin texturas: triciclo.cob

y este, otro con textura para probar: rino.cob
y su textura: RHINO.jpg



¡Sólo los usuarios registrados pueden escribir comentarios!
+/- Comentarios
Buscar
cristiaan3003  - pregunta   |190.193.108.xxx |12-11-2009 07:24:44
hola queria saber como hago para triangular el modelo antes de guardarlo al
archivo .cob en el truespace, ya estube mirando el programa pero no encuentro la
opcion.
cristiaan3003@gmail.com, argentina , santa fe
Vicengetorix   |SAdministrator |12-11-2009 19:52:41
Esta respondido en el tema del foro que has puesto tambien.
lavz24  - Duda   |159.90.10.xxx |09-04-2010 15:59:20
Hola queria saber que otros formatos, soporta el opengl, por ejemplo puedo
cargar un .obj? o un .3ds?
Vicengetorix   |194.179.126.xxx |09-04-2010 19:40:07
El OpenGL no soporta ningun formato.
Es el programador el que debe trabajarse el
codigo para leer los vertices y pasarselos a OpenGL.
En este capitulo se da un
ejemplo con ficheros .COB de como hacer esto pero conociendo el formato de .OBJ
o .3DS o cualquier otro se puede hacer lo mismo.

Pregunta mejor en el foro, me
es mas comodo.

3.26 Copyright (C) 2008 Compojoom.com / Copyright (C) 2007 Alain Georgette / Copyright (C) 2006 Frantisek Hliva. All rights reserved."

 


Banner
Spanish Chinese (Simplified) English French German Japanese Portuguese Russian