Loading obj file question

The rows that start with f are position/UV index pairs.

So, the 1/1 line refers to position at index 1 (v [color="#006666"]0.084387 [color="#006666"]1.041998 [color="#006666"]1.380985) and texture coordinate ([color="#000000"]vt [color="#006666"]0.000000 [color="#006666"]0.000000).

[color="#006666"][color="#006666"]Note also that obj files are indexed starting from 1.

The rows that start with f are position/UV index pairs.

So, the 1/1 line refers to position at index 1 (v [color="#006666"]0.084387 [color="#006666"]1.041998 [color="#006666"]1.380985) and texture coordinate ([color="#000000"]vt [color="#006666"]0.000000 [color="#006666"]0.000000).

Alright, but my understanding of vertices (at least in directx) is that each vertex can only have one texture coordinate, so how can I implement this in the code?

[color="#006666"][color="#006666"]Note also that obj files are indexed starting from 1.

So subtract 1 before putting the index into the buffer?

Thanks for your response

Yes, you noticed that Direct3D and the Wavefront Object format handle meshes differently.

You need to parse the vertex attributes into separate buffers, then when you parse a face, you construct a vertex by using the indexes to index the attributes in the buffers. Next, you have to see if this constructed vertex already exists in your final vertex buffer. If it doesn't exist, you add it to the vertex buffer and add it's index to the index buffer, then you use an associative container to associate that vertex with it's index. If it does exist already, then you add nothing to the vertex buffer and use your associative container to look up the index of that vertex and add that to the index buffer.

You may also need to handle triangulation, or simply make it a requirement that all models be triangulated. I also found that I needed to invert my texture coordinates and it uses counter clockwise order for front facing polygons. I'm not sure if that's because of blender or if that's just a part of the object format.

And one more thing if you don't mind, since I'm new to this I was wondering if this was a good way to load a 3d model. Thanks



char input[10] = "";
vector<Vertex> vertexVector;
vector<D3DXVECTOR3> vertexPos;
vector<D3DXVECTOR2> texCoord;
vector<DWORD> indexVector;
vector<DWORD> texCoordIndex;

//Read the file
while (input[0] != 'e')
{
//Get the file input
file>> input;

//If it is a texture coordinate put it in the texCoord vector
if(input[0] == 'v' && input[1] == 't')
{
D3DXVECTOR2 tex;

//U coordinate
file>> input;
tex.x = (float)atof(input);
//V coordinate
file>> input;
tex.y = (float)atof(input);

texCoord.push_back(tex);
}
//If it is a vector position, put it in the pos vector
else if(input[0] == 'v')
{
D3DXVECTOR3 pos;

//X coordinate
file>> input;
pos.x = (float)atof(input);
//Y coordinate
file>> input;
pos.y = (float)atof(input);
//Z coordinate
file>> input;
pos.z = (float)atof(input);

vertexPos.push_back(pos);
}
//If it is a index
else if(input[0] == 'f')
{
//There a three indices per 'f' and it is index/texture index so input[0] is the index and input[2] is the texture index
file>> input;
indexVector.push_back(atoi(&input[0]) - 1);
texCoordIndex.push_back(atoi(&input[2]) - 1);
file>> input;
indexVector.push_back(atoi(&input[0]) - 1);
texCoordIndex.push_back(atoi(&input[2]) - 1);
file>> input;
indexVector.push_back(atoi(&input[0]) - 1);
texCoordIndex.push_back(atoi(&input[2]) - 1);
}
}
//Put the information into the vertexVector
for(int i = 0; i < indexVector.size(); i++)
{
Vertex vertex;

vertex.Pos = vertexPos[indexVector];
vertex.Tex = texCoord[texCoordIndex];

vertex.Color = D3DXCOLOR(0.0f, 0.0f, 0.0f, 1.0f);

vertexVector.push_back(vertex);
}

int iNumVerts = vertexVector.size();
int iNumIndices = indexVector.size();

//Create the mesh
ID3DX10Mesh* pTempMesh;
D3DX10CreateMesh(g_pGame->GetDevice(), layout, iNumElements, "POSITION", iNumVerts, iNumIndices, D3DX10_MESH_32_BIT, &pTempMesh);
pTempMesh->SetVertexData(0, &vertexVector);
pTempMesh->SetIndexData(&indexVector, iNumIndices);

//optimize the vector
pTempMesh->GenerateAdjacencyAndPointReps(0.001f);
pTempMesh->Optimize(D3DX10_MESHOPT_ATTR_SORT | D3DX10_MESHOPT_VERTEX_CACHE, 0, 0);

pTempMesh->CommitToDevice();


A few things to be weary of:
1) Not all obj files follow that pattern precisely, depending on who/what created them. They can forgo the texture coordinate stream, or even have UVW instead of just UV.

2) Using std::vector without predeterming size can bloat your memory pretty quickly. From memory, default behaviour is to reallocate double in size each time the capacity is blown. So if you have 65537 (2^16+1) floats, it will jump to 131072 floats.

3) Parsing a text file is slower than loading a binary blob of your vertex data. In the future, when you are up for it and load-times become a problem, consider writing a step that loads the obj and saves out the resulting mesh in a way that can be read straight from disk without parsing.

I use an unordered_set so I can check to see if the vertex I'm constructing already exists, to prevent duplicates. Then I use an unordered_map to associate vertex to it's index.

This code is rough and makes a lot of assumptions, but it seems to work.


int main(int argc, char* argv[])
{
if(argc < 2)
return 0;

std::ifstream InFile(argv[1]);

if(!InFile)
return 0;

std::vector<vec3> positions;
std::vector<vec3> normals;
std::vector<vec2> texcoords;

std::unordered_set<Vertex> vertex_set;
std::unordered_map<Vertex, unsigned int> index_map;

std::vector<Vertex> vertices;
std::vector<unsigned int> indices;

std::string cmd;

for(;;)
{
InFile >> cmd;
if(!InFile)
break;

if(cmd == "v")
{
float x, y, z;
InFile >> x >> y >> z;
positions.push_back(vec3(x, y, z));
}
else if(cmd == "vt")
{
float u, v;
InFile >> u >> v;
texcoords.push_back(vec2(1.0f - u, 1.0f - v));
}
else if(cmd == "vn")
{
float x, y, z;
InFile >> x >> y >> z;
normals.push_back(vec3(x, y, z));
}
else if(cmd == "f")
{
int pos, norm, tex;

for(int i = 0; i < 3; ++i)
{
Vertex vertex;

InFile >> pos;
vertex.position = positions[pos - 1];

if(InFile.peek() == '/')
{
InFile.ignore();

if(InFile.peek() != '/')
{
InFile >> tex;
vertex.texcoord = texcoords[tex - 1];
}
if(InFile.peek() == '/')
{
InFile.ignore();

InFile >> norm;
vertex.normal = normals[norm - 1];
}
}

auto it = vertex_set.find(vertex);
if(it == vertex_set.end())
{
vertex_set.insert(vertex);
vertices.push_back(vertex);
int index = vertices.size() - 1;
indices.push_back(index);
index_map[vertex] = index;
}
else
{
indices.push_back(index_map[vertex]);
}
}
}
else
{
//nothing
}
}
}


Thanks, that was very helpful.