Ficheros 3D y normales

[Kherom]

* 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 

[Kherom]

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)

Código: [Seleccionar]

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);

[TrOnTxU]

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:

Código: [Seleccionar]

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

Código: [Seleccionar]

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  

[Kherom]

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 

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:

Código: [Seleccionar]

; 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):

Código: [Seleccionar]

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):

[Hechelion]

Dejo una captura de los cubos de lado 1 (Los que no tienen texturas, clik para ampliar):

Eso pasa la hacer clic.

403 - Forbidden

[TrOnTxU]

Eso pasa la hacer clic.

403 - Forbidden

El enlace esta linkado en el puerto 81, prueba este que he modificado yo: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:

Código: [Seleccionar]

"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):

Código: [Seleccionar]

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:

Código: [Seleccionar]

#define TY_STATIC_ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0]))

Espero que te sirva, un saludo!

[blau]

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... 

[Kherom]

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:

Código: [Seleccionar]

<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 Ahora a por las texturas!

[TrOnTxU]

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.