c++ - obj - Importación y visualización de archivos.fbx en OpenGl

opengl c++ windows

Question

He estado tratando de importar y mostrar un archivo fbx usando FBX SDK.Untill . Logré cargar el archivo, pero me quedé atrapado en la parte donde tengo que mostrarlo. Las preguntas:

1. ¿Qué son exactamente esos índices?
2. ¿Cómo debería mostrar los vértices?

Aquí está la clase que hice:

3dModelBasicStructs.h

struct vertex
{
float x,y,z;
};

struct texturecoords
{
float a,b;
};

struct poligon
{
int a,b,c;
};

Model.h

#ifndef MODEL_H
#define MODEL_H
#define FBXSDK_NEW_API

#define MAX_VERTICES 80000
#define MAX_POLIGONS 80000


#include <fbxsdk.h>
#include "3dModelBasicStructs.h"
#include <iostream>
#include <GL/glut.h>
using namespace std;

class Model
{

     public:

         Model(char*);
         ~Model();

         void ShowDetails();

         char* GetModelName();
         void  SetModelName( char* );
         void  GetFbxInfo( FbxNode* );
         void  RenderModel();
                     void  InitializeVertexBuffer( vertex* );

      private:

          char Name[25];

          vertex vertices[MAX_VERTICES];
          poligon poligons[MAX_POLIGONS];

          int *indices;
          int numIndices;

          int numVertices;


};


#endif

Model.cpp

#include "Model.h"






Model::Model(char *filename)
{
cout<<"/nA model has been built!";

numVertices=0;
numIndices=0;

FbxManager *manager = FbxManager::Create();

FbxIOSettings *ioSettings = FbxIOSettings::Create(manager, IOSROOT);
manager->SetIOSettings(ioSettings);

FbxImporter *importer=FbxImporter::Create(manager,"");
importer->Initialize(filename,-1,manager->GetIOSettings());

FbxScene *scene = FbxScene::Create(manager,"tempName");

importer->Import(scene);
importer->Destroy();

FbxNode* rootNode = scene->GetRootNode();
this->SetModelName(filename);
if(rootNode) { this->GetFbxInfo(rootNode); }

}

Model::~Model()
{
cout<<"/nA model has been destroied!";
}


void Model::ShowDetails()
{
cout<<"/nName:"<<Name;
cout<<"/nVertices Number:"<<numVertices;
cout<<"/nIndices which i never get:"<<indices;

}

char* Model::GetModelName()
{
return Name;
}

void Model::SetModelName(char *x)
{
strcpy(Name,x);
}

void Model::GetFbxInfo( FbxNode* Node )
{

int numKids = Node->GetChildCount();
FbxNode *childNode = 0;

for ( int i=0 ; i<numKids ; i++)
{
    childNode = Node->GetChild(i);
    FbxMesh *mesh = childNode->GetMesh();

    if ( mesh != NULL)
    {
//================= Get Vertices ====================================
        int numVerts = mesh->GetControlPointsCount();

        for ( int j=0; j<numVerts; j++)
        {
            FbxVector4 vert = mesh->GetControlPointAt(j);
            vertices[numVertices].x=(float)vert.mData[0];
            vertices[numVertices].y=(float)vert.mData[1];
            vertices[numVertices++].z=(float)vert.mData[2];
            cout<<"/n"<<vertices[numVertices-1].x<<" "<<vertices[numVertices-    1].y<<" "<<vertices[numVertices-1].z;
this->InitializeVertexBuffer(vertices);
        }
//================= Get Indices ====================================
        int *indices = mesh->GetPolygonVertices();
        numIndices+=mesh->GetPolygonVertexCount();
    }
    this->GetFbxInfo(childNode);
}
}

void Model::RenderModel()
{
glDrawElements(GL_TRIANGLES,36,GL_INT,indices);
}
void Model::InitializeVertexBuffer(vertex *vertices)
{
glEnableClientState(GL_VERTEX_ARRAY);
glVertexPointer(3,GL_FLOAT,0,vertices);
//glDrawArrays(GL_TRIANGLES,0,36);
}

Tristemente, cuando trato de usar drawelements obtengo este error: Excepción no controlada en 0x77e215de en A new begging.exe: 0xC0000005: Acceso a la ubicación de lectura de la violación 0xcdcdcdcd.

Answer 1

2) ¿Cómo debo mostrar los vértices?

Preguntas como estas indican que debe trabajar con algunos tutoriales de OpenGL. Esos son los conceptos básicos y usted necesita saberlos.

Este es un buen comienzo para su problema, pero tendrá que trabajar en todo el tutorial http://opengl.datenwolf.net/gltut/html/Basics/Tut01%20Siguiendo%20the%20Data.html

1) ¿Qué son exactamente esos índices?

Tienes una lista de vértices. El índice de un vértice es la posición en la que se encuentra en esa lista. Puede dibujar matrices de vértices por sus índices usando glDrawElements

Actualización debido a comentario

Digamos que tienes un cubo con vértices compartidos (poco común en OpenGL, pero soy demasiado flojo para anotar 24 vértices).

Los tengo en mi programa en una matriz, que forma una lista de sus posiciones. Los cargas desde un archivo, les estoy escribiendo una matriz C:

GLfloat vertices[3][] = {
    {-1,-1, 1},
    { 1,-1, 1},
    { 1, 1, 1},
    {-1, 1, 1},
    {-1,-1,-1},
    { 1,-1,-1},
    { 1, 1,-1},
    {-1, 1,-1},
};

Esto le da a los índices de vértices (posición en la matriz), en la imagen se ve como

Para dibujar un cubo debemos decirle a OpenGL en qué vértices, en qué orden hacer una cara. Así que echemos un vistazo a las caras:

Vamos a construir ese cubo de triángulos. 3 índices consecutivos forman un triángulo. Para el cubo esto es

GLuint face_indices[3][] = {
    {0,1,2},{2,3,0},
    {1,5,6},{6,2,1},
    {5,4,7},{7,6,5},
    {4,0,3},{3,7,4},
    {3,2,6},{6,7,2},
    {4,5,0},{1,0,5}
};

Puede dibujar esto y luego apuntar OpenGL a la matriz de vértices

glVertexPointer(3, GL_FLOAT, 0, &vertices[0][0]);

y emitir una llamada de lotes en la matriz con vértices. Hay 6 * 2 = 12 triángulos, cada triángulo formado por 3 vértices, que forma una lista de 36 índices.

glDrawElements(GL_TRIANGLES, 36, GL_UNSIGNED_INT, &face_indices[0][0]);