Buenas, acabo de retomar C++ y OpenGL y quiero dedicarme éste verano a hacer juegos o demos en 3D pero me he encontrado con un problema: No se de dónde sacar modelos 3D para hacer pruebas, ya que hasta ahora sólo he encontrado algunos con una burrada de polígonos y 0 animaciones. Me interesaría encontrar cosas sencillas, coches a los que se les pueda mover las ruedas (que sean independientes del coche y con el centro en el punto correcto) , algún personaje y quizás elementos de attrezzo... ¿Sabéis de alguna página donde encontrarlos?

PD:No sabía muy bien dónde poner esto, lo pongo aquí por que imagino que otros programadores habrán topado con el mismo problema. Si algún mod considera que estaría mejor en otro sitio agradeceré que lo mueva.

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] Expand

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

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:

Código [Seleccionar] Expand

; 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] Expand

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

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] Expand

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

[* Calcular normales al vueldo:]

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

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

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.

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



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

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.

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:

Código [Seleccionar] Expand

*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

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.

Joooder era eso, gracias, ya me carga la textura, aunque con el color invertido, pero es un comienzo :D Tanto mover las cosas de sitio...

Para glu yo nunca he inicializado nada y no he tenido problemas. Aunque sólo he usado gluPerspective y poco más. Que yo sepa son más funciones sobre la misma base.

La que sí que me sigue sin funcionar es

glTexImage2D(GL_TEXTURE_2D, 0, 3, biWidth, biHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, imagen);

Que era la función que iba a usar al principio, pero de ésta no se cómo sacar los errores que produce, sabes cómo? Sólo la he conseguido usar con la librería corona, aquí sustituyéndola no hace nada, y como no tiene valor de retorno no se sacar los errores.

Si claro, si no no me habría dado cuenta del error, lo que pasa es que está con la API de Windows y no con Glu y está un poco caótico de los cambios que he hecho, limpiando la basura quedaría algo así:

Código [Seleccionar] Expand

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>

HWND hWndPrincipal, hWndConsola;

MSG Mensaje;

RECT med, rect;

HDC hDC;

HGLRC OGLrc;

GLuint portada;

LRESULT CALLBACK PrincipalProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
GLuint cargaBMP(const char * ruta);
void iniciaOGL(void);
void pinta(void);

int WINAPI WinMain (HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
WNDCLASSEX principal;

principal.cbSize = sizeof(WNDCLASSEX);
principal.style = CS_HREDRAW | CS_VREDRAW;
principal.lpfnWndProc = PrincipalProc;
principal.cbClsExtra = 0;
principal.cbWndExtra = 0;
principal.hInstance = hInstance;
principal.hIcon = NULL;
principal.hCursor = LoadCursor(0, IDC_ARROW);
principal.hbrBackground= (HBRUSH)(COLOR_WINDOW);
principal.lpszMenuName = NULL;
principal.lpszClassName = "principal";
principal.hIconSm = NULL;

RegisterClassEx (&principal);

hWndPrincipal = CreateWindow("principal", "Casino",
WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX,
100, 100, 512, 512, 0, 0, hInstance, 0);

ShowWindow(hWndPrincipal, nCmdShow);

UpdateWindow(hWndPrincipal);

portada=cargaBMP("Principal.bmp");

iniciaOGL();

while(1)
{
if (PeekMessage(&Mensaje, NULL, 0, 0, PM_NOREMOVE))
{
if(!GetMessage(&Mensaje, NULL, 0, 0))
return (int)Mensaje.wParam;
TranslateMessage(&Mensaje);
DispatchMessage(&Mensaje);
}
pinta();
}
}

LRESULT CALLBACK PrincipalProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_DESTROY:
PostQuitMessage(0);
return 0;
break;
}
return DefWindowProc(hwnd, msg, wParam, lParam);
}

GLuint cargaBMP(const char * ruta)
{
GLuint gluint;
unsigned char c, d;
unsigned int n, i, biSizeImage, bfOffbits, biWidth, biHeight;
float  p;
short u;
void *imagen;

FILE *bmp;
bmp=fopen(ruta, "rb");

//Busco el desfase y lo guardo
fseek (bmp, 10, 0);
fread(&bfOffbits, 4, 1, bmp);

//Busco el ancho y lo guardo
fseek (bmp, 18, 0);
fread(&biWidth, 4, 1, bmp);

//Busco el alto y lo guardo
fseek (bmp, 22, 0);
fread(&biHeight, 4, 1, bmp);
//Busco la posición en la que se almacena el tamaño de la imagen y la guardo
fseek (bmp, 34, 0);
fread(&biSizeImage, 4, 1, bmp);

imagen = malloc (biSizeImage);
fseek (bmp, bfOffbits, 0);
fread(imagen, biSizeImage, 1, bmp);

fclose(bmp);

  glGenTextures(1, &gluint);
  glBindTexture(GL_TEXTURE_2D, gluint);
 
  glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
  glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                   GL_LINEAR_MIPMAP_NEAREST );
  glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
  glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
  glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

  int err;
  FILE * ERR;
  ERR=fopen("ERR.txt", "a");
err=gluBuild2DMipmaps(GL_TEXTURE_2D, 3, biWidth,
    biHeight, GL_RGBA, GL_UNSIGNED_BYTE, imagen);
  if (err)
  {
char c;
char error[100];
const GLubyte * rrr=gluErrorString(err);
int i=0;
do{
c=*rrr;
error[i]=c;
rrr++;
i++;
}while(c!=0);
MessageBox(NULL, error, "gluBuild2DMipmaps()", MB_OK | MB_ICONERROR);
}
  return gluint;
}

void iniciaOGL(void)
{
static PIXELFORMATDESCRIPTOR pfd =
{
        sizeof(PIXELFORMATDESCRIPTOR),
        1,
        PFD_DRAW_TO_WINDOW |
        PFD_SUPPORT_OPENGL |
        PFD_DOUBLEBUFFER |
        PFD_TYPE_RGBA,
        32,
        0,0,0,0,0,0, // ignorados
        0, // Sin buffer alpha
        0, // Shift bit ignorado
        0, // Buffer de acumulación ignorado
        0,0,0,0, // Bits de acumulación ignorados
        32, // Z-Buffer
        0, // Sin buffer de pincel (Stencil)
        0, // Sin buffer auxiliar
        PFD_MAIN_PLANE, // Layer de dibujo principal
        0, // Reservado
        0,0,0, // Layers de máscara ignorados
};

hDC=GetDC(hWndPrincipal);
int PixF=ChoosePixelFormat(hDC,&pfd);
SetPixelFormat(hDC,PixF,&pfd);
OGLrc=wglCreateContext(hDC);
wglMakeCurrent(hDC,OGLrc);

SwapBuffers(hDC);
}

void pinta(void)
{
static int bloq=0;

glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);

glClearColor( 0.0f, 0.0f, 0.0f, 0.0f );
  glClear( GL_COLOR_BUFFER_BIT );

  glEnable(GL_TEXTURE_2D);
 
glBindTexture(GL_TEXTURE_2D, portada);

glColor3f(0.9,0.5,0.3);

glBegin(GL_QUADS);
    glTexCoord2d(0.0,0.0); glVertex2d(-1.0,-1.0);
    glTexCoord2d(1.0,0.0); glVertex2d(+1.0,-1.0);
    glTexCoord2d(1.0,1.0); glVertex2d(+1.0,+1.0);
    glTexCoord2d(0.0,1.0); glVertex2d(-1.0,+1.0);
glEnd();

Sleep(33);

SwapBuffers(hDC);
}


Para compilarlo modo GUI y --opengl32 -lglu32 en el linker.

Supuesta mente debería tener textura y no generar el error, o al menos es lo que me pasa en otros programas, como un buscaminas que hice hace unas semanas, pero ahora no hay manera.

Saludos a todos, tengo un problema con OpenGL que no logro solucionar:

Cuando comencé con OpenGL utilizaba una librería en c++ que no puedo usar en c, por lo que he decidido cargar las imágenes yo mismo. Pero al intentarlo me he encontrado con un error de  "Memoria insuficiente" al intentar cargar una imagen compuesta por un simple array de 16 bytes. La cosa es que tras comerme mucho el tarro probé la función en un programa anterior y no da problemas, me permite cargar imágenes con normalidad, pero en todos los que hago después me da el mismo error y no encuentro la diferencia.

Aquí dejo una versión resumida del código que da problemas (concretamente en la función "gluBuild2DMipmaps()"):

Código [Seleccionar] Expand

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>

int main(void)
{
GLuint textura;
/*int biSizeImage, bfOffbits, biWidth, biHeight;
FILE * bmp;

bmp=fopen(imagen, "r");

//Busco el desfase y lo guardo
fseek (bmp, 10, 0);
fread(&bfOffbits, 4, 1, bmp);

//Busco el ancho y lo guardo
fseek (bmp, 18, 0);
fread(&biWidth, 4, 1, bmp);

//Busco el alto y lo guardo
fseek (bmp, 22, 0);
fread(&biHeight, 4, 1, bmp);

printf("%i\n", biWidth);
printf("%i\n", biHeight);
//Busco la posición en la que se almacena el tamaño de la imagen y la guardo
fseek (bmp, 34, 0);
fread(&biSizeImage, 4, 1, bmp);

imagend = malloc (biSizeImage);
fseek (bmp, bfOffbits, 0);
fread(imagend, biSizeImage, 1, bmp);
fclose(bmp);*/

  glGenTextures(1, &textura);
  glBindTexture(GL_TEXTURE_2D, textura);
 
unsigned char imagenprueba[16]={255,0,0,255,0,255,0,255,0,0,0,0,0,128,255,128};

int err;
  //FILE * ERR;
  //ERR=fopen("ERR.txt", "a");
err=gluBuild2DMipmaps(GL_TEXTURE_2D, 3, 2,
    2, GL_RGBA, GL_UNSIGNED_BYTE, imagenprueba);
  if (err)
  {
char c;
char error[100];
const GLubyte * rrr=gluErrorString(err);
int i=0;
do{
c=*rrr;
error[i]=c;
rrr++;
i++;
}while(c!=0);
MessageBox(NULL, error, "gluBuild2DMipmaps()", MB_OK | MB_ICONERROR);
    //fwrite(error,1,100, ERR);
    //fputc(10,ERR);
}
  //fclose(ERR);
}


Aquí más resumido (sin las partes comentadas):

Código [Seleccionar] Expand

#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <GL/gl.h>
#include <GL/glu.h>

int main(void)
{
GLuint textura;
  glGenTextures(1, &textura);
  glBindTexture(GL_TEXTURE_2D, textura);
 
unsigned char imagenprueba[16]={255,0,0,255,0,255,0,255,0,0,0,0,0,128,255,128};

int err;
err=gluBuild2DMipmaps(GL_TEXTURE_2D, 3, 2,
    2, GL_RGBA, GL_UNSIGNED_BYTE, imagenprueba);
  if (err)
  {
char c;
char error[100];
const GLubyte * rrr=gluErrorString(err);
int i=0;
do{
c=*rrr;
error[i]=c;
rrr++;
i++;
}while(c!=0);
MessageBox(NULL, error, "gluBuild2DMipmaps()", MB_OK | MB_ICONERROR);
}
}