Saludos. Estoy aprendiendo a cargar modelos 3D desde ficheros .3DS y ya se cómo cargar la maya, pero no encuentro por ningún lado la información de las normales. ¿Sabéis si se almacena? ¿Y qué otro tipo de fichero podría utilizar que sí las guarde?
Por que si un icosaedro representa un icosaedro calcular las normales es fácil, pero si representa una esfera ya es más complicado, y en una malla más compleja todavía más, y tiene que haber una forma de que el editor 3D guarde esa información digo yo, pero encontrar la información me está costando.
Desconozco completamente lo relativo a ficheros 3ds, pero ¿has probado a mirar los ficheros de blender?
Al ser un proyecto open source, tienes acceso completo a toda la información sobre la estructura del fichero, con lo cual debería ser más fácil programar una herramienta que cargue su contenido.
http://wiki.blender.org/index.php/Dev:Source/Architecture
Lo había pensado pero lo veo incluso más enrevesado :P He estado mirando por encima y no he encontrado ni los vértices, sólo información de la escena en general y de forma poco clara... Yo sólo quiero un formato binario con los vértices, sus normales, los índices de las caras y la información de las texturas :P
Por ejemplo éste otro formato (aparte de estar en modo texto, que no me gusta :P) tampoco contiene las normales:
*3DSMAX_ASCIIEXPORT 200
*COMMENT "AsciiExport Version 2,00 - Fri Feb 10 16:40:39 2012"
*SCENE {
*SCENE_FILENAME ""
*SCENE_FIRSTFRAME 0
*SCENE_LASTFRAME 100
*SCENE_FRAMESPEED 30
*SCENE_TICKSPERFRAME 160
*SCENE_BACKGROUND_STATIC 0.0000 0.0000 0.0000
*SCENE_AMBIENT_STATIC 0.0000 0.0000 0.0000
}
*GEOMOBJECT {
*NODE_NAME "Box001"
*NODE_TM {
*NODE_NAME "Box001"
*INHERIT_POS 0 0 0
*INHERIT_ROT 0 0 0
*INHERIT_SCL 0 0 0
*TM_ROW0 1.0000 0.0000 0.0000
*TM_ROW1 0.0000 -0.0000 1.0000
*TM_ROW2 0.0000 -1.0000 -0.0000
*TM_ROW3 0.0000 0.0000 0.0000
*TM_POS 0.0000 0.0000 0.0000
*TM_ROTAXIS -1.0000 -0.0000 -0.0000
*TM_ROTANGLE 1.5708
*TM_SCALE 1.0000 1.0000 1.0000
*TM_SCALEAXIS 0.0000 0.0000 0.0000
*TM_SCALEAXISANG 0.0000
}
*MESH {
*TIMEVALUE 0
*MESH_NUMVERTEX 8
*MESH_NUMFACES 12
*MESH_VERTEX_LIST {
*MESH_VERTEX 0 -0.5000 0.0000 -0.5000
*MESH_VERTEX 1 0.5000 0.0000 -0.5000
*MESH_VERTEX 2 -0.5000 -0.0000 0.5000
*MESH_VERTEX 3 0.5000 -0.0000 0.5000
*MESH_VERTEX 4 -0.5000 -1.0000 -0.5000
*MESH_VERTEX 5 0.5000 -1.0000 -0.5000
*MESH_VERTEX 6 -0.5000 -1.0000 0.5000
*MESH_VERTEX 7 0.5000 -1.0000 0.5000
}
*MESH_FACE_LIST {
*MESH_FACE 0: A: 0 B: 2 C: 3 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 2 *MESH_MTLID 1
*MESH_FACE 1: A: 3 B: 1 C: 0 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 2 *MESH_MTLID 1
*MESH_FACE 2: A: 4 B: 5 C: 7 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 3 *MESH_MTLID 0
*MESH_FACE 3: A: 7 B: 6 C: 4 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 3 *MESH_MTLID 0
*MESH_FACE 4: A: 0 B: 1 C: 5 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 4 *MESH_MTLID 4
*MESH_FACE 5: A: 5 B: 4 C: 0 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 4 *MESH_MTLID 4
*MESH_FACE 6: A: 1 B: 3 C: 7 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 5 *MESH_MTLID 3
*MESH_FACE 7: A: 7 B: 5 C: 1 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 5 *MESH_MTLID 3
*MESH_FACE 8: A: 3 B: 2 C: 6 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 6 *MESH_MTLID 5
*MESH_FACE 9: A: 6 B: 7 C: 3 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 6 *MESH_MTLID 5
*MESH_FACE 10: A: 2 B: 0 C: 4 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 7 *MESH_MTLID 2
*MESH_FACE 11: A: 4 B: 6 C: 2 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 7 *MESH_MTLID 2
}
}
*PROP_MOTIONBLUR 0
*PROP_CASTSHADOW 1
*PROP_RECVSHADOW 1
}
Y algún otro formato en modo texto que he estado mirando tampoco las contiene :S
Voy a aventurar una respuesta y puede que no tenga que ver con los ficheros 3ds....
La información de las normales deberías poder sacarla perfectamente de los triángulos, coges dos vectores del triangulo y con un producto vectorial sacas la normal, porque supongo que los triángulos irán guardados con un orden horario o anithorario pero siempre el mismo.
:)
Cita de: blau en 12 de Febrero de 2012, 09:26:53 PM
Voy a aventurar una respuesta y puede que no tenga que ver con los ficheros 3ds....
La información de las normales deberías poder sacarla perfectamente de los triángulos, coges dos vectores del triangulo y con un producto vectorial sacas la normal, porque supongo que los triángulos irán guardados con un orden horario o anithorario pero siempre el mismo.
:)
Si, si no me equivoco debería ser antihorario, pero es más tedioso y sobre todo me daría la normal de una cara, lo que es útil en el caso de un cubo, pero no de una esfera. Vamos que si la superficie del polígono es plana me sirve, pero si es curva con una normal por cara no se suavizaría correctamente, haría falta una normal por vértice y esas serían más complicadas de sacar.
Hola,
El formato .OBJ puede guardar las normales por vértice. Si no las tiene, puedes abrirlo con Blender y exportarlo con las normales, es una opción del exportador de Blender.
Lo de calcular las normales a mano también es una buena idea. :)
Saludos,
Cita de: Kherom en 12 de Febrero de 2012, 09:38:47 PM
Si, si no me equivoco debería ser antihorario, pero es más tedioso y sobre todo me daría la normal de una cara, lo que es útil en el caso de un cubo, pero no de una esfera. Vamos que si la superficie del polígono es plana me sirve, pero si es curva con una normal por cara no se suavizaría correctamente, haría falta una normal por vértice y esas serían más complicadas de sacar.
Así a bote pronto, para sacarlas por vértice, acumulas las normales "normalizadas" por cada vértice y al final divides por el numero de normales que hayas acumulado en ese vértice. ;)
Cita de: blau en 13 de Febrero de 2012, 10:59:15 AM
Cita de: Kherom en 12 de Febrero de 2012, 09:38:47 PM
Si, si no me equivoco debería ser antihorario, pero es más tedioso y sobre todo me daría la normal de una cara, lo que es útil en el caso de un cubo, pero no de una esfera. Vamos que si la superficie del polígono es plana me sirve, pero si es curva con una normal por cara no se suavizaría correctamente, haría falta una normal por vértice y esas serían más complicadas de sacar.
Así a bote pronto, para sacarlas por vértice, acumulas las normales "normalizadas" por cada vértice y al final divides por el numero de normales que hayas acumulado en ese vértice. ;)
Si y no, funcionaría a medias, no se cómo se hace en motores comerciales y demás, pero ese método podría funcionar sólo hasta cierto punto, con esa técnica se mostraría bien una esfera pero no un cubo, y según que superficies se mostrarían sólo regular. Por ejemplo (Dibujo en plan cutre xD):
(http://s2.subirimagenes.com/fondosycapturas/previo/thump_7433219sinttulo1.jpg)
Siendo A la figura original con las normales en cada punto en rojo, lo que yo quiero en un modelo 3D con un perfil como B, y lo que dices daría algo como C, las normales serían perpendiculares a las caras planas y en la cara curva habría 2 normales distintas (En 3D habría 3) lo que harían que quedase siavizada. La verdad no tengo ni idea de cómo se suele hacer, pero no estaría mal que un editor 3D guardase las normales de la forma correcta (dando a las curvas sus normales correctas).
Ejem...
creo que o tienes la superficie A o la B
tanto en A como en B el método que te describí funciona igual, ten en cuenta que para conseguir la A, tienes que tener muchos triangulitos pequeños, si le aplicas el método te sale lo mismo que tu dibujas en A.
Otra cosa es que hagas un mapa de normales para el modelo, pero eso iría en una textura aparte y no tiene nada que ver.
Un saludo.
No, haciendo lo que dices se puede o obtener el modelo facetado o obtener algo como C con la suma de normales, pero lo de B no se puede conseguir, o te queda facetado o te queda como en C. Aunque por lo que estoy viendo lo normal es seguir C o hacerlo facetado, pero a mí me gustaría una información más precisa de cada normal. Ten en cuenta que si sumas las normales en cada vértice las normales de los vértices inferiores de la cara inferior no coinciden con las superiores, con lo que o representas curvo todo el objeto o lo representas plano entero.
Si quieres lo de B no compartas vértices. ;)
Cita de: blau en 14 de Febrero de 2012, 12:33:37 AM
Si quieres lo de B no compartas vértices. ;)
Si no comparto vértices al sacar las normales de la cara intermedia no van a salir esas y no va a quedar suavizado, y si los comparto la cara intermedia va a quedar medio suavizada y las otras 2 caras también xD
Vamos, que el problema está en que es imposible saber si una cara es curva o plana si el fichero no te lo dice, por lo que o tratas todas como planas o tratas todas como curvas, no hay medias tintas, no puedes saber si un icosaedro es un icosaedro o una esfera sólo con la información de los vértices, necesitas algo más.
Creo que nadie calcula las normales "al vuelo" al cargar el modelo.
Si quieres "compresion" al menos guarda las coordenadas polares.
Por lo que veo tardarias menos utilizando un formato binario propio.
Nada complicado. Una cabecera con el tipo de datos (tipo de vertices, tipo de indices, attributos de los vertices), el tamaño de los buffers(vertices e indices).
Con un par de structs y un par de funciones lo tienes.
El exportador es otra cosa. Si no quieres hacerte uno propio exporta desde el paquete de modelado a Collada o FBX. Luego con una aplicacion de linea de comandos lo conviertes a tu formato. Existe open collada y el sdk de fbx para facilitarte la vida (aunque a veces parece en que te la hacen imposible). Tambien puedes mirar el source de Horde3d, el "ColladaConverter" tiene su propio "lector de Collada", es bastante "lightweight" y es OpenSource.
Como ultima opcion (que suele ser la bomba), es crearte tu exportador que lea directamente de los archivo Maya o 3dsmax. Pero eso es ya mas curro, y Collada y FBX los puedes exportar desde practicamente cualquier paquete de modelado.
Como ultima opcion (que a mi no me agrada demasiado) esta el formato .x (si es que aun existe) de DX.
Y seguro que alguno más habrá por ahi.
Espero haber sido de alguna ayuda. :)
Gracias, lo de el formato propio es algo que haría seguro, mucho más cómodo, de hecho la idea (en un futuro incierto) es hacerme mi propio editor y guardar todos los datos de los escenarios en un fichero propio. Pero primero necesito la información desde el editor 3D por lo que tengo que pasar por sus ficheros si o si (no se cómo exportar a mi propio formato desde Blender o 3D Max), ¿Es muy complicado? En el .3DS no he visto las normales y en otros las he visto pero sólo por cara, echaré un vistazo a los que me dices.
Respecto a que nadie calcula las normales "al vuelo" en algún código lo he visto xD Yo lo he hecho hace un rato y cada cara me ha salido como le ha parecido xDDD Creo que es por el orden de los vértices o así, aún no he probado más :P
EDIT: Acabo de guardar un FBX en ASCII y parece que es justo lo que necesitaba, permite elegir lo qué guardar, invertir el eje y y el z y contiene todas las normales :D Aunque parece un poco complicado con muchos datos que no me interesan pero bueno, el 3DS también lo era y ya lo leí xD
* Calcular normales al vueldo:
Las normales se pueden modificar desde el editor por una razon. Los grafistas pueden "jugar" con ellas. Por eso no tiene por que existir una normal "perfecta", hay una normal "por defecto", pero la idea es que se pueda poner la normal que se quiera (siempre normalizada, claro).
Al menos eso es lo que yo tenia entendido, por eso exporto las normales.
* Exportador:
Exportar a tu propio formato directamente desde el el paquete de modelado no lo recomiendo por varias razones.
Complicado o no depende de como lo hagas:
- En Maya/Max lo puedes hacer en c++, como un plug-in utilizando el sdk de cada uno.
- En maya ademas puedes hacer un plug-in en python.
- En max ademas con maxScript puede acceder a la informacion de todos los vertices.
- En blender ni idea, pero supongo que "python rules".
Problemas que veo al exportar desde el modelador, que no tienes al leer un FBX/Collada:
- Un exportador por paquete de modelado.
- Diferentes SDKs/lenguajes para cada paquete.
- Seguramente tendras que triangular (aunque generalmente hay un comando en todos los paquetes para hacerlo)
Mi posición:
Sigo pensando que lo más rapido para ver resultados es convertir desde FBX o Collada. Y si en un futuro quieres saltarte el paso de exportar a collada desde el programa de modelado, lee directamente el binario .max o .mb.
Otra solución para saltarte la exportacion es uitlizar scripts de maya o max e invocar estos progrmas para que exporten a tu formato intermedio, como hace Unity3d.
Pienso que es mucho más comodo procesar las mayas y convertirlas a tu formato desde una aplicacion de consola que desde un "exportador".
Las razones principales son que no necesitas el programa de modelado en la maquina que esta compilando los "assets" o "recursos".
Y que lo puedes poner en un server a modo de "farm", comprobando cuando hay subidos cambios en el content repository, y de ahi vas compilando los recursos que hagan falta.
Y demás tonterias que se me ocurren.
Pero igual la que te importa es que creo que acabarias antes:
1) instalandote un exportador de collada en tu programa de modelado
2) bajando el Horde3d
3) cogiendo la aplicacion "colladaConverter" de Horde y modificando el metodo "exportGeometry" de la clase converter para exportar a tu propio formato
4) aprovechando el tiempo que te has ahorrado para hacerte una cerveza con tus amigos :)
Además creo que si te lo montas bien puedes hacer tu exportador cada vez menos dependiente del ColladaConverter de Horde, y acabar con una libreria de exportación propia (pasito a pasito claro).
Un saludo
[EDIT]
No habia visto el EDIT de que ya tienes lo de FBX, ups ^_^'
El ASCII de FBX viene bien para ver el contenido. Pero quizás te interese utilizar el SDK de FBX que hay en la pagina de Autodesk.
Hay que aprender, pero te puede ahorrar esfuerzo, y ademas podras leer FBX binarios tambien :)
Cita de: TrOnTxU en 14 de Febrero de 2012, 09:51:16 PM
* Calcular normales al vueldo:
Las normales se pueden modificar desde el editor por una razon. Los grafistas pueden "jugar" con ellas. Por eso no tiene por que existir una normal "perfecta", hay una normal "por defecto", pero la idea es que se pueda poner la normal que se quiera (siempre normalizada, claro).
Al menos eso es lo que yo tenia entendido, por eso exporto las normales.
Eso es lo que hablaba con blau antes, le decía que no quería calcular las normales al vuelo por que no serían del todo correctas, las quería cargar desde el fichero, pero como no conocía ningún formato hasta hace nada no sabía cuál elegir después de fracasar con el .3DS (que no incluye normales).
[cuote][EDIT]
No habia visto el EDIT de que ya tienes lo de FBX, ups
El ASCII de FBX viene bien para ver el contenido. Pero quizás te interese utilizar el SDK de FBX que hay en la pagina de Autodesk.
Hay que aprender, pero te puede ahorrar esfuerzo, y ademas podras leer FBX binarios tambien[/cuote]
Había guardado el FBX en ASCII para ver cómo era, la idea de cargarlo en modo texto no me gusta nada, creo que voy a empezar a ver cómo cargo el binario (de momento a rebuscar en la documentación) y después es posible que eche un vistazo a lo demás que me has dicho.
Gracias por la información, me ha parecido muy útil ;)
Vale aprovechando que en la versión ASCII las coordenadas están igual que en un array he probado a copiarlas y pegarlas en mi programa para ver cómo queda la cosa antes de hacer un cargador y pese a intentarlo de 3 formas distintas siempre hay 3 o 4 triángulos (Es un simple cubo) que se muestran mal, ¿Qué puede ser? ¿Tengo que ordenarlos o algo así?
Con el .3DS me venían los vértices y los índices y me me cargaba la malla bien (sin normales eso si xD)
glTranslatef(0,3,0);
glDisable(GL_TEXTURE_2D);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
float vertices[108]={-3.10156011581421,-3.1333703994751,0,3.10156011581421,-3.1333703994751,0,-3.10156011581421,3.1333703994751,0,3.10156011581421
,3.1333703994751,0,-3.10156011581421,-3.1333703994751,5.31373310089111,3.10156011581421,-3.1333703994751,5.31373310089111
,-3.10156011581421,3.1333703994751,5.31373310089111,3.10156011581421,3.1333703994751,5.31373310089111,3.10156011581421
,3.1333703994751,0,-3.10156011581421,-3.1333703994751,0,3.10156011581421,3.1333703994751,5.31373310089111,-3.10156011581421
,-3.1333703994751,5.31373310089111,-3.10156011581421,-3.1333703994751,0,3.10156011581421,-3.1333703994751,0,3.10156011581421
,-3.1333703994751,5.31373310089111,3.10156011581421,-3.1333703994751,5.31373310089111,-3.10156011581421,-3.1333703994751
,5.31373310089111,-3.10156011581421,-3.1333703994751,0,3.10156011581421,-3.1333703994751,0,3.10156011581421,3.1333703994751
,0,3.10156011581421,3.1333703994751,5.31373310089111,3.10156011581421,3.1333703994751,5.31373310089111,3.10156011581421
,-3.1333703994751,5.31373310089111,3.10156011581421,-3.1333703994751,0,3.10156011581421,3.1333703994751,0,-3.10156011581421
,3.1333703994751,0,-3.10156011581421,3.1333703994751,5.31373310089111,-3.10156011581421,3.1333703994751,5.31373310089111
,3.10156011581421,3.1333703994751,5.31373310089111,3.10156011581421,3.1333703994751,0,-3.10156011581421,3.1333703994751
,0,-3.10156011581421,-3.1333703994751,0,-3.10156011581421,-3.1333703994751,5.31373310089111,-3.10156011581421,-3.1333703994751
,5.31373310089111,-3.10156011581421,3.1333703994751,5.31373310089111,-3.10156011581421,3.1333703994751,0} ;
float normales[108]={0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1
,0,0,-1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0
,-1,0,0,-1,0,0};
short index[36]={0,2,-4,8,1,-10,4,5,-8,10,6,-12,12,13,-15,15,16,-18,18,19,-21,21,22,-24,24,25,-27,27,28,-30,30,31,-33,33,34,-36};
glVertexPointer(3, GL_FLOAT, 0, vertices);
glNormalPointer(GL_FLOAT, 0, normales);
glDrawArrays(GL_TRIANGLES, 0, 36);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
int i;
glTranslatef(10,0,0);
for (i=0; i<12; i++)
{
glBegin(GL_TRIANGLES);
glNormal3f(normales[index[i*3]*3],normales[index[i*3]*3+1],normales[index[i*3]*3+2]);
glVertex3f(vertices[index[i*3]*3],vertices[index[i*3]*3+1],vertices[index[i*3]*3+2]);
glNormal3f(normales[(index[i*3]+1)*3],normales[(index[i*3]+1)*3+1],normales[(index[i*3]+1)*3+2]);
glVertex3f(vertices[(index[i*3]+1)*3],vertices[(index[i*3]+1)*3+1],vertices[(index[i*3]+1)*3+2]);
glNormal3f(normales[(index[i*3]+2)*3],normales[(index[i*3]+2)*3+1],normales[(index[i*3]+2)*3+2]);
glVertex3f(vertices[(index[i*3]+2)*3],vertices[(index[i*3]+2)*3+1],vertices[(index[i*3]+2)*3+2]);
glEnd();
}
glTranslatef(10,0,0);
for (i=0; i<12; i++)
{
glBegin(GL_TRIANGLES);
glNormal3f(normales[i*9],normales[i*9+1],normales[i*9+2]);
glVertex3f(vertices[i*9],vertices[i*9+1],vertices[i*9+2]);
glNormal3f(normales[i*9+3],normales[i*9+4],normales[i*9+5]);
glVertex3f(vertices[i*9+3],vertices[i*9+4],vertices[i*9+5]);
glNormal3f(normales[i*9+6],normales[i*9+7],normales[i*9+8]);
glVertex3f(vertices[i*9+6],vertices[i*9+7],vertices[i*9+8]);
glEnd();
}
if (texturas)
glEnable(GL_TEXTURE_2D);
A bote pronto tengos dos preguntas sobre el código:
1) Porque pintas primero con gldrawArrays y luego con glBegin / End?
Creo que lo segundo sobra.
2) Si me fijo en drawArrays (que es la que utilizaria yo).
Tendrias que pasarle un stride de 12 bytes (4*3) a gl*Pointer, no?
No sé si sera eso, mi codigo quedaria asi:
glVertexPointer(3, GL_FLOAT, 12, vertices);
glNormalPointer(GL_FLOAT, 12, normales);
Aunque yo pondria posicion y normal en un mismo array (suele ser más eficiente).
Puedes comprobar tambien como tienes el configurado en face-culling (activa que pinte los dos lados para comprobarlo).
Para depurar prueba a hacer un plano o algo con menos vertices., y intenta que las coordenadas estén redeondeadas (crealo "numericamente" en el max y asegurate de que tenga de lado 1.0f o algo más facil de visualizar).
Siento no poder ayudarte más, pero asi a primera vista no veo nada más raro.
Un saludo
EDIT:
Otras cosas que no habia visto!
Vale, me autocontesto la primera: pintas tres cubos, el primero (con glDrawArrays que es el que a mi me mola) en (0,3,0) relativo a donde esta la matriz cuando entras a este trozo de código. Los otros dos estan pintados en (10,0,0) y (20,0,0) respectivamente. No?
El primero con indices, y el segundo si ellos, directamente recorriendo los vertices. (No puedo asegurar que estos dos loops te funcionen bien)
Veo otro problema con glDrawArrays, y es que no estas utilizando los indices en esta funcion. Si quieres inidices prueba con
glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_SHORT, index);
Otro problemilla más, esta vez en los inidices:
No deberias tener indices negativos!!!!!!
Deberian ser unsigned, y todos desde 0!!!
Y por ultimo parece que el ultimo float de vertices es 0, y no parece haber ningun otro punto en z = 0, lo cual es un poco extraño.
Espero habe sido de ayuda al final ^_^'
Dibujo 3 cubos con 3 métodos. En cuanto a el 4*3=12 sería como si pusiese los vértices en el mismo array que las normales como has dicho que haces tú, imagino, aunque si lo pongo sale lo mismo 8o
Lo de los índices no me había hecho ni fijar, pero poniéndolos todos en positivo salía lo mismo así que supongo que el signo se ignora o si no no me explico cómo no casca o hace cosas muy raras.
Los 0 deberían ser por que la cara base está en el suelo (O al menos ahí la dibujé xD)
Éste es el fichero:
; FBX 6.1.0 project file
; Copyright (C) 1997-2009 Autodesk Inc. and/or its licensors.
; All rights reserved.
; ----------------------------------------------------
FBXHeaderExtension: {
FBXHeaderVersion: 1003
FBXVersion: 6100
CreationTimeStamp: {
Version: 1000
Year: 2012
Month: 2
Day: 14
Hour: 23
Minute: 5
Second: 49
Millisecond: 917
}
Creator: "FBX SDK/FBX Plugins version 2011.1"
}
; Document Description
;------------------------------------------------------------------
Document: {
Name: ""
}
; Document References
;------------------------------------------------------------------
References: {
}
; Object definitions
;------------------------------------------------------------------
Definitions: {
Version: 100
Count: 3
ObjectType: "Model" {
Count: 1
}
ObjectType: "SceneInfo" {
Count: 1
}
ObjectType: "GlobalSettings" {
Count: 1
}
}
; Object properties
;------------------------------------------------------------------
Objects: {
Model: "Model::Box001", "Mesh" {
Version: 232
Properties60: {
Property: "QuaternionInterpolate", "bool", "",0
Property: "RotationOffset", "Vector3D", "",0,0,0
Property: "RotationPivot", "Vector3D", "",0,0,0
Property: "ScalingOffset", "Vector3D", "",0,0,0
Property: "ScalingPivot", "Vector3D", "",0,0,0
Property: "TranslationActive", "bool", "",0
Property: "TranslationMin", "Vector3D", "",0,0,0
Property: "TranslationMax", "Vector3D", "",0,0,0
Property: "TranslationMinX", "bool", "",0
Property: "TranslationMinY", "bool", "",0
Property: "TranslationMinZ", "bool", "",0
Property: "TranslationMaxX", "bool", "",0
Property: "TranslationMaxY", "bool", "",0
Property: "TranslationMaxZ", "bool", "",0
Property: "RotationOrder", "enum", "",0
Property: "RotationSpaceForLimitOnly", "bool", "",0
Property: "RotationStiffnessX", "double", "",0
Property: "RotationStiffnessY", "double", "",0
Property: "RotationStiffnessZ", "double", "",0
Property: "AxisLen", "double", "",10
Property: "PreRotation", "Vector3D", "",0,0,0
Property: "PostRotation", "Vector3D", "",0,0,0
Property: "RotationActive", "bool", "",0
Property: "RotationMin", "Vector3D", "",0,0,0
Property: "RotationMax", "Vector3D", "",0,0,0
Property: "RotationMinX", "bool", "",0
Property: "RotationMinY", "bool", "",0
Property: "RotationMinZ", "bool", "",0
Property: "RotationMaxX", "bool", "",0
Property: "RotationMaxY", "bool", "",0
Property: "RotationMaxZ", "bool", "",0
Property: "InheritType", "enum", "",1
Property: "ScalingActive", "bool", "",0
Property: "ScalingMin", "Vector3D", "",1,1,1
Property: "ScalingMax", "Vector3D", "",1,1,1
Property: "ScalingMinX", "bool", "",0
Property: "ScalingMinY", "bool", "",0
Property: "ScalingMinZ", "bool", "",0
Property: "ScalingMaxX", "bool", "",0
Property: "ScalingMaxY", "bool", "",0
Property: "ScalingMaxZ", "bool", "",0
Property: "GeometricTranslation", "Vector3D", "",0,0,0
Property: "GeometricRotation", "Vector3D", "",0,0,0
Property: "GeometricScaling", "Vector3D", "",1,1,1
Property: "MinDampRangeX", "double", "",0
Property: "MinDampRangeY", "double", "",0
Property: "MinDampRangeZ", "double", "",0
Property: "MaxDampRangeX", "double", "",0
Property: "MaxDampRangeY", "double", "",0
Property: "MaxDampRangeZ", "double", "",0
Property: "MinDampStrengthX", "double", "",0
Property: "MinDampStrengthY", "double", "",0
Property: "MinDampStrengthZ", "double", "",0
Property: "MaxDampStrengthX", "double", "",0
Property: "MaxDampStrengthY", "double", "",0
Property: "MaxDampStrengthZ", "double", "",0
Property: "PreferedAngleX", "double", "",0
Property: "PreferedAngleY", "double", "",0
Property: "PreferedAngleZ", "double", "",0
Property: "LookAtProperty", "object", ""
Property: "UpVectorProperty", "object", ""
Property: "Show", "bool", "",1
Property: "NegativePercentShapeSupport", "bool", "",1
Property: "DefaultAttributeIndex", "int", "",0
Property: "Freeze", "bool", "",0
Property: "LODBox", "bool", "",0
Property: "Lcl Translation", "Lcl Translation", "A+",0.247086048126221,1.23613262176514,0
Property: "Lcl Rotation", "Lcl Rotation", "A+",0,0,0
Property: "Lcl Scaling", "Lcl Scaling", "A+",1,1,1
Property: "Visibility", "Visibility", "A+",1
Property: "MaxHandle", "int", "UH",2
Property: "Color", "ColorRGB", "N",0.650980392156863,0.898039215686275,0.898039215686275
Property: "BBoxMin", "Vector3D", "N",0,0,0
Property: "BBoxMax", "Vector3D", "N",0,0,0
}
MultiLayer: 0
MultiTake: 1
Shading: T
Culling: "CullingOff"
Vertices: -3.10156011581421,-3.1333703994751,0,3.10156011581421,-3.1333703994751,0,-3.10156011581421,3.1333703994751,0,3.10156011581421
,3.1333703994751,0,-3.10156011581421,-3.1333703994751,5.31373310089111,3.10156011581421,-3.1333703994751,5.31373310089111
,-3.10156011581421,3.1333703994751,5.31373310089111,3.10156011581421,3.1333703994751,5.31373310089111,3.10156011581421
,3.1333703994751,0,-3.10156011581421,-3.1333703994751,0,3.10156011581421,3.1333703994751,5.31373310089111,-3.10156011581421
,-3.1333703994751,5.31373310089111,-3.10156011581421,-3.1333703994751,0,3.10156011581421,-3.1333703994751,0,3.10156011581421
,-3.1333703994751,5.31373310089111,3.10156011581421,-3.1333703994751,5.31373310089111,-3.10156011581421,-3.1333703994751
,5.31373310089111,-3.10156011581421,-3.1333703994751,0,3.10156011581421,-3.1333703994751,0,3.10156011581421,3.1333703994751
,0,3.10156011581421,3.1333703994751,5.31373310089111,3.10156011581421,3.1333703994751,5.31373310089111,3.10156011581421
,-3.1333703994751,5.31373310089111,3.10156011581421,-3.1333703994751,0,3.10156011581421,3.1333703994751,0,-3.10156011581421
,3.1333703994751,0,-3.10156011581421,3.1333703994751,5.31373310089111,-3.10156011581421,3.1333703994751,5.31373310089111
,3.10156011581421,3.1333703994751,5.31373310089111,3.10156011581421,3.1333703994751,0,-3.10156011581421,3.1333703994751
,0,-3.10156011581421,-3.1333703994751,0,-3.10156011581421,-3.1333703994751,5.31373310089111,-3.10156011581421,-3.1333703994751
,5.31373310089111,-3.10156011581421,3.1333703994751,5.31373310089111,-3.10156011581421,3.1333703994751,0
PolygonVertexIndex: 0,2,-4,8,1,-10,4,5,-8,10,6,-12,12,13,-15,15,16,-18,18,19,-21,21,22,-24,24,25,-27,27,28,-30,30,31,-33,33,34,-36
Edges: 0,1,2,3,4,6,7,8,9,10,13,14,16,19,20,25,26,32,5,11,12,15,17,18,21,22,23,24,27,28,29,30,31,33,34,35
GeometryVersion: 124
LayerElementNormal: 0 {
Version: 101
Name: ""
MappingInformationType: "ByVertice"
ReferenceInformationType: "Direct"
Normals: 0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1
,0,0,-1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0
,-1,0,0,-1,0,0
}
LayerElementUV: 0 {
Version: 101
Name: "UVChannel_1"
MappingInformationType: "ByVertice"
ReferenceInformationType: "Direct"
UV: 1,0,0,0,1,1,0,1,0,0,1,0,0,1,1,1,0,1,1,0,1,1,0,0,0,0,1,0,1,1,1,1,0,1,0,0,0,0,1,0,1,1,1,1,0,1,0,0,0,0,1,0,1,1,1
,1,0,1,0,0,0,0,1,0,1,1,1,1,0,1,0,0
}
Layer: 0 {
Version: 100
LayerElement: {
Type: "LayerElementNormal"
TypedIndex: 0
}
LayerElement: {
Type: "LayerElementUV"
TypedIndex: 0
}
}
NodeAttributeName: "Geometry::Box001_ncl1_1"
}
SceneInfo: "SceneInfo::GlobalInfo", "UserData" {
Type: "UserData"
Version: 100
MetaData: {
Version: 100
Title: ""
Subject: ""
Author: ""
Keywords: ""
Revision: ""
Comment: ""
}
Properties60: {
Property: "DocumentUrl", "KString", "", "H:\DevCPP\Prueba3D\Caja.FBX"
Property: "SrcDocumentUrl", "KString", "", "H:\DevCPP\Prueba3D\Caja.FBX"
Property: "Original", "Compound", ""
Property: "Original|ApplicationVendor", "KString", "", "Autodesk"
Property: "Original|ApplicationName", "KString", "", "3ds Max"
Property: "Original|ApplicationVersion", "KString", "", "2011.1"
Property: "Original|DateTime_GMT", "DateTime", "", "14/02/2012 22:05:49.915"
Property: "Original|FileName", "KString", "", "H:\DevCPP\Prueba3D\Caja.FBX"
Property: "LastSaved", "Compound", ""
Property: "LastSaved|ApplicationVendor", "KString", "", "Autodesk"
Property: "LastSaved|ApplicationName", "KString", "", "3ds Max"
Property: "LastSaved|ApplicationVersion", "KString", "", "2011.1"
Property: "LastSaved|DateTime_GMT", "DateTime", "", "14/02/2012 22:05:49.915"
}
}
GlobalSettings: {
Version: 1000
Properties60: {
Property: "UpAxis", "int", "",2
Property: "UpAxisSign", "int", "",1
Property: "FrontAxis", "int", "",1
Property: "FrontAxisSign", "int", "",-1
Property: "CoordAxis", "int", "",0
Property: "CoordAxisSign", "int", "",1
Property: "OriginalUpAxis", "int", "",2
Property: "OriginalUpAxisSign", "int", "",1
Property: "UnitScaleFactor", "double", "",2.54
Property: "OriginalUnitScaleFactor", "double", "",2.54
Property: "AmbientColor", "ColorRGB", "",0,0,0
Property: "DefaultCamera", "KString", "", "Producer Perspective"
Property: "TimeMode", "enum", "",6
Property: "TimeSpanStart", "KTime", "",0
Property: "TimeSpanStop", "KTime", "",153953860000
}
}
}
; Object connections
;------------------------------------------------------------------
Connections: {
Connect: "OO", "Model::Box001", "Model::Scene"
}
;Takes and animation section
;----------------------------------------------------
Takes: {
Current: ""
Take: "Take 001" {
FileName: "Take_001.tak"
LocalTime: 0,46186158000
ReferenceTime: 0,46186158000
;Models animation
;----------------------------------------------------
;Generic nodes animation
;----------------------------------------------------
;Textures animation
;----------------------------------------------------
;Materials animation
;----------------------------------------------------
;Constraints animation
;----------------------------------------------------
}
}
;Version 5 settings
;------------------------------------------------------------------
Version5: {
AmbientRenderSettings: {
Version: 101
AmbientLightColor: 0,0,0,1
}
FogOptions: {
FlogEnable: 0
FogMode: 0
FogDensity: 0.002
FogStart: 0.3
FogEnd: 1000
FogColor: 1,1,1,1
}
Settings: {
FrameRate: "30"
TimeFormat: 1
SnapOnFrames: 0
ReferenceTimeIndex: -1
TimeLineStartTime: 0
TimeLineStopTime: 153953860000
}
RendererSetting: {
DefaultCamera: "Producer Perspective"
DefaultViewingMode: 0
}
}
He probado éste otro fichero (más sencillo al tener el cubo lado 1 clavado) y tengo el mismo problema: La mayoría de los triángulos salen bien pero algunos tienen vértices malos (de hecho son exactamente los mismos triángulos los que salen mal, pero más pequeñs):
glTranslatef(0,2,0);
glDisable(GL_TEXTURE_2D);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
float vertices[108]={-0.5,-0.5,0,0.5,-0.5,0,-0.5,0.5,0,0.5,0.5,0,-0.5,-0.5,1,0.5,-0.5,1,-0.5,0.5,1,0.5,0.5,1,0.5,0.5,0,-0.5,-0.5,0,0.5
,0.5,1,-0.5,-0.5,1,-0.5,-0.5,0,0.5,-0.5,0,0.5,-0.5,1,0.5,-0.5,1,-0.5,-0.5,1,-0.5,-0.5,0,0.5,-0.5,0,0.5,0.5,0,0.5,0.5
,1,0.5,0.5,1,0.5,-0.5,1,0.5,-0.5,0,0.5,0.5,0,-0.5,0.5,0,-0.5,0.5,1,-0.5,0.5,1,0.5,0.5,1,0.5,0.5,0,-0.5,0.5,0,-0.5
,-0.5,0,-0.5,-0.5,1,-0.5,-0.5,1,-0.5,0.5,1,-0.5,0.5,0} ;
float normales[108]={0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1
,0,0,-1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0
,-1,0,0,-1,0,0};
short index[36]={0,2,-4,8,1,-10,4,5,-8,10,6,-12,12,13,-15,15,16,-18,18,19,-21,21,22,-24,24,25,-27,27,28,-30,30,31,-33,33,34,-36};
glVertexPointer(3, GL_FLOAT, 0, vertices);
glNormalPointer(GL_FLOAT, 0, normales);
glDrawArrays(GL_TRIANGLES, 0, 36);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
int i;
glTranslatef(2,0,0);
for (i=0; i<12; i++)
{
glBegin(GL_TRIANGLES);
glNormal3f(normales[index[i*3]*3],normales[index[i*3]*3+1],normales[index[i*3]*3+2]);
glVertex3f(vertices[index[i*3]*3],vertices[index[i*3]*3+1],vertices[index[i*3]*3+2]);
glNormal3f(normales[(index[i*3]+1)*3],normales[(index[i*3]+1)*3+1],normales[(index[i*3]+1)*3+2]);
glVertex3f(vertices[(index[i*3]+1)*3],vertices[(index[i*3]+1)*3+1],vertices[(index[i*3]+1)*3+2]);
glNormal3f(normales[(index[i*3]+2)*3],normales[(index[i*3]+2)*3+1],normales[(index[i*3]+2)*3+2]);
glVertex3f(vertices[(index[i*3]+2)*3],vertices[(index[i*3]+2)*3+1],vertices[(index[i*3]+2)*3+2]);
glEnd();
}
glTranslatef(2,0,0);
for (i=0; i<12; i++)
{
glBegin(GL_TRIANGLES);
glNormal3f(normales[i*9],normales[i*9+1],normales[i*9+2]);
glVertex3f(vertices[i*9],vertices[i*9+1],vertices[i*9+2]);
glNormal3f(normales[i*9+3],normales[i*9+4],normales[i*9+5]);
glVertex3f(vertices[i*9+3],vertices[i*9+4],vertices[i*9+5]);
glNormal3f(normales[i*9+6],normales[i*9+7],normales[i*9+8]);
glVertex3f(vertices[i*9+6],vertices[i*9+7],vertices[i*9+8]);
glEnd();
}
if (texturas)
glEnable(GL_TEXTURE_2D);Dejo una captura de los cubos de lado 1 (Los que no tienen texturas, clik para ampliar):
(http://s3.subirimagenes.com:81/otros/previo/thump_7441505subir.jpg) (http://s3.subirimagenes.com:81/otros/7441505subir.jpg)
Cita de: Kherom en 15 de Febrero de 2012, 02:51:49 PM
Dejo una captura de los cubos de lado 1 (Los que no tienen texturas, clik para ampliar):
Eso pasa la hacer clic.
Citar
403 - Forbidden
Cita de: Hechelion en 16 de Febrero de 2012, 12:23:49 AM
Eso pasa la hacer clic.
Citar
403 - Forbidden
El enlace esta linkado en el puerto 81, prueba este que he modificado yo:http://s3.subirimagenes.com/otros/7441505subir.jpg (http://s3.subirimagenes.com/otros/7441505subir.jpg)
En cuanto al problema en si, como he dicho creo que seria mejor que utilizaras directamente el sdk de autodesk (te evitarias estos problemas), para CONVERTIR, y que no cargues FBX desde el "runtime" directamente.
El problema que tienes es por los indices negativos que te he dicho. Y porque creo que (como te he comentado antes) no estas pintando bien con indices. No tienes que usa glDrawArrays sino drawElements.
En cuanto a los indices negativos, hay que convertirlos! Por arte de magia no van a aparecer los inidices corectos. Tendrias que repasar la teoria de numeros negativos (complemento a1 y a2) y saber como se "auto-castean" los signed y unsigned ... porque los 16bits de un short = -4 NO SON 4(b0000000000000100)!!
En el caso del FBX, si no usas el sdk, tendrás que aplicar:
"uIndex[j] = (index[j] >= 0) ? index[j] : ( (-1) ^index[j] );"Los códigos negativos indican el final de un poly, lo cual quiere decir que puede que haya polys de mas de 3 lados(no es tu caso si te fijas).
El sdk de fbx lo hace directamente, y si no recuerdo mal podias triangular la malla, si no lo estaba ya, con funciones del mismo.
He echo un "UnitTest" en mi SDK(compilando el render system como opengl) para demostrartelo. Pongo el código (obvia las funciones especificas del SDK, y centrate en la conversion de inidices y las llamadas a OpenGL):
TY_TEST( StratosQuestion, CommonOGL )
{
Matrix4f posMatrix;
F32 radAngle = 0.0f;
F32 clearColor [] = { 0.0f, 0.0f, 1.0f, 0.0f };
g_RenderSystem.set_backface_culling(false);
g_RenderSystem.set_projection_matrix( CameraPerspective().x );
short index[]={0,2,-4,8,1,-10,4,5,-8,10,6,-12,12,13,-15,15,16,-18,18,19,-21,21,22,-24,24,25,-27,27,28,-30,30,31,-33,33,34,-36};
float vertices[]={-0.5,-0.5,0,0.5,-0.5,0,-0.5,0.5,0,0.5,0.5,0,-0.5,-0.5,1,0.5,-0.5,1,-0.5,0.5,1,0.5,0.5,1,0.5,0.5,0,-0.5,-0.5,0,0.5
,0.5,1,-0.5,-0.5,1,-0.5,-0.5,0,0.5,-0.5,0,0.5,-0.5,1,0.5,-0.5,1,-0.5,-0.5,1,-0.5,-0.5,0,0.5,-0.5,0,0.5,0.5,0,0.5,0.5
,1,0.5,0.5,1,0.5,-0.5,1,0.5,-0.5,0,0.5,0.5,0,-0.5,0.5,0,-0.5,0.5,1,-0.5,0.5,1,0.5,0.5,1,0.5,0.5,0,-0.5,0.5,0,-0.5
,-0.5,0,-0.5,-0.5,1,-0.5,-0.5,1,-0.5,0.5,1,-0.5,0.5,0} ;
float normales[108]={0,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,-1,0,0,-1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0,-1
,0,0,-1,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,0,1,0,-1,0,0,-1,0,0,-1,0,0,-1,0,0
,-1,0,0,-1,0,0};
int indexSize = TY_STATIC_ARRAY_SIZE(index);
int vertexSize = TY_STATIC_ARRAY_SIZE(vertices);
unsigned short uIndex[1024]; // 2KB --> mas vale prevenir que currar!!
for (int j = 0; j < indexSize ; j++)
{
uIndex[j] = (index[j] >= 0) ? index[j] : ( (-1) ^index[j] );
}
for (int i = 0; i < 400; i++)
{
g_RenderSystem.clear(TYE_CLEAR_FLAG_BOTH, clearColor);
radAngle+=0.03f;
posMatrix = Matrix4f();
posMatrix.rotate(0.0f, radAngle, 0.0f);
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState(GL_NORMAL_ARRAY);
glVertexPointer(3, GL_FLOAT, 12, vertices);
glNormalPointer(GL_FLOAT, 12, normales);
posMatrix.translate(+0.0f, 0.0f, -5.0f);
g_RenderSystem.set_position_matrix( posMatrix.x );
glDrawElements(GL_TRIANGLES, indexSize, GL_UNSIGNED_SHORT, uIndex);
glDisableClientState(GL_VERTEX_ARRAY);
glDisableClientState(GL_NORMAL_ARRAY);
// swap buffers
g_pMainDisplay->swap_buffers();
// sleep 10ms
g_pDisplayManager->update();
TY_SLEEP_MS(10);
}
}
TY_STATIC_ARRAY_SIZE, lo utilizo para saber cuantos elementos hay el array:
#define TY_STATIC_ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) Espero que te sirva, un saludo!
Por si te sirve de algo, yo recuerdo haber hecho algo parecido en collada y no tener tanto problema...
El formato es fácil de leer y está todo bastante claro.
Tb recuerdo haber intentado leer un .fbx y haberme acojonado mucho... muchas versiones... y un poco enrevesado... ^_^'
Gracias por las respuestas, aunque tengo que mirarlas con más calma por que cuando veo en el código cosas que no conozco me cueta mucho leerlo xD dejé el tema por otros asuntos pero ya me he vuelto a poner con él.
Por ahora he conseguido cargar un modelo sencillo sin texturas desde un .dae (collada).
Después de mirar por ahí he descubierto cómo se ordenaban las los índices y una vez hecho eso ha salido correctamente, el truco estaba en que en los íncices se alternaban vértices, normales y coordenadas de textura:
<polygons count="12">
<input semantic="VERTEX" offset="0" source="#Box001-lib-Vertex"/>
<input semantic="NORMAL" offset="1" source="#Box001-lib-Normal0"/>
<input semantic="TEXCOORD" offset="2" set="0" source="#Box001-lib-UV0"/>
<p>
0 0 9 2 1 11 3 2 10
</p>
<p>
3 3 10 1 4 8 0 5 9
</p>
<p>
4 6 8 5 7 9 7 8 11
</p>
<p>
7 9 11 6 10 10 4 11 8
</p>
<p>
0 12 4 1 13 5 5 14 7
</p>
<p>
5 15 7 4 16 6 0 17 4
</p>
<p>
1 18 0 3 19 1 7 20 3
</p>
<p>
7 21 3 5 22 2 1 23 0
</p>
<p>
3 24 4 2 25 5 6 26 7
</p>
<p>
6 27 7 7 28 6 3 29 4
</p>
<p>
2 30 0 0 31 1 4 32 3
</p>
<p>
4 33 3 6 34 2 2 35 0
</p>
</polygons>
La pega es que el fichero es xml y me da mucha pereza cargarlo así xD Con lo fácil que es tener la posición de comienzo de los datos y la final para cargarlos en memoria de golpe xD
EDIT: Vale gracias a tu post ya he conseguido cargar también el fichero FBX, había probado a hacer positivas los indices negativos pero sin éxito. Lo que no entiendo es ésto: (-1) ^index[j]
En cuanto a DrawArrays lo estaba usando bien, antes lo que hacía era ordenar los vértices en un array y así pintar el array de golpe (también había probado de la otra forma e incluso polígono a polígono con bucles for :P Ahora a por las texturas!
(http://fotos.subefotos.com/602b52f1a51dbd58e55773d88c6c8847o.jpg)
Cita de: Kherom en 01 de Marzo de 2012, 02:59:06 PM
Lo que no entiendo es ésto: (-1) ^index[j]
Es la codificación que utiliza el FBX. Cuando hay final de poligono el inidice es negativo, y el valor es el indice negativo menos 1. Por lo tanto la transformación a positivo seria multiplicar por 1 y restar 1. p.e: (-8) * (-1) - 1 = 8 -1 = 7. Utilizar el operador XOR es simplemente porque es más rápido, aunque si transformas los indices antes da igual que lo hagas multiplicando y restando no pasa nada.