This sucks: OBJ Parser on Android, and trying to display a cube via OpenGL ES 2.0 with shaders

[tom_mai78101]

I've been tackling this since day 1, and my progress sucks. I'm stuck on parsing a simple OBJ file, with a cube mesh.

I could *ragequit* all day, all thanks to that "f". Even if I got them parsed, I don't even know what to do with them for use in OpenGL ES 2.0. Can't use the good ol' ByteBuffer (that's for ES 1.0/1.1).

If lightly possible, can someone give hints on the next step? I want to read up on the theories, and then I show my code that's follow the theories, and then hopefully, I get to see where I did wrong, and finally correct it with pin-point accuracy.

Thanks in advance.

 

[s3rius]

Without actually knowing what you're doing or what you don't know, it's a bit hard to comment on that.

I'm also not too sure what you mean by reading theories, then showing your code to do something...

Buuuut I know the problem with the faces. They're a bit annoying to get into a data format that OGL likes.

The easiest way to parse Obj is to:

Parse all "v" and put them into an array (v).
Parse all "vt" and put them into an array (vt).
Parse all "nv" and put them into an array (vn)

Create three arrays to hold your final vertex information. One for vertices, one for texture coords and one for normals (fv, fvt, fvn).

"f" usually has the format: <vert> <vert> <vert>
vert usually has the format: <number> / <number> / <number>

For every face:
    For every vert in face:
        Read the 3 numbers (a,b,c)
        push v[a-1] onto fv
        push vt[b-1] onto fvt
        push vn[c-1] onto fvn

You can potentially reduce the amount of data by using indexed buffers, but the design of Obj (= seperating position, texture UV and normal from each other) makes that pretty tedious.

Biggest problem is that Obj isn't a very strict format. Differences like having 3 or 4 verts in a face (triangle or quad), or not having a vt index.
So at the start I'd suggest limiting yourself to a strict rule set.

I'm not familiar with OGL:ES, nor do I know which language you're using. But I'm sure you can use some sort of buffer object since all modern OGL versions seem to operate with them.

 

[tom_mai78101]

Do you happen to know what I should do with two of each kind (v and fv, vt and fvt, vn and fvn)?

Why OBJ couldn't just use the first three types available? (Just by using v, vt, and vn only when trying to load the model and blitting it to the display)?

I have also seen an implementation that use the vertex and normal indices to point towards the target vertices and normals, then calculate the cross product of two vectors (each vector is the difference of two vertices), and finally normalize them. The result is then placed in the normal array, where the normal indices are pointing at. Is this redundant if there is already normals (vn) included in the file?

Otherwise, I don't see the point and usage of the vertex, normal, and texture indices. What are they for?

 

[s3rius]

v, vt and vn are not needed after you populate the other arrays. They're just temporarily needed so you know which pos/tex/normal belongs to which index.
fv, fvt and fvn contain the position, texture and normal data just how OpenGL wants it. So they are ready to be uploaded to OGL through buffer objects.

Taking the cross product of the vectors that comprise the triangle gives you the normal. So if you have vn entries in your Obj file then that's redundant.

At the end of the day, the Obj format is completely arbitrary. Whoever invented it simply thought it useful to use indices.
Maybe because the Obj files would be smaller this way, or maybe because some graphics modeling programs organize their data like this.

 

[tom_mai78101]

Thinking about this when I'm in a calm, collected state of mind makes me feel dumb.

In short, the most important part of the OBJ is the f. The rest are just for temporary loading the exact values for the f and its elements.

Thanks for helping me break down the OBJ into understandable concepts.

 

[tom_mai78101]

I have come across some problems I'm not able to explain very well without you guys trying it out.

I'm unable to get a cube to load correctly. I was able to make it rotate nicely on all axes.

The only way to make this program work is to install it on an Android device with the OS version >= 2.2 (Gingerbread or above). It runs OpenGL 2.0.

This is what it looks like right now:

This is the expected outcome:

Here's the Pastebin of my GLSurfaceView.Renderer portion:
http://pastebin.com/KE5nETFg

Here's the Pastebin of the Cube class, with the OBJ loader included:
http://pastebin.com/JuukRGku

Anyone had ideas? Thanks in advance.

 

[s3rius]

I don't have an Android device, but..

vertexIndices.add(Short.valueOf(line.split(" ")[1]));
vertexIndices.add(Short.valueOf(line.split(" ")[2]));
 vertexIndices.add(Short.valueOf(line.split(" ")[3]));

You're parsing faces here, and you try to split at " ". So you try to call things like Short.valueOf("2/3/4"). So even IF that returns a value, it's not what you want.
Or have you changed the Obj file in some way?

Next, in Obj indices start at 1. In OpenGL they start at 0. So you have to subtract -1 from the values in your ShortBuffer.

Also, after you've read all data from the Obj file, print them to the console and manually check if they're correct. Because I don't think they are.

vertices[i] = (f != null ? f : Float.NaN);
..
indices[i] = (s != null ? s : 1);

You can't just do that .. if one entry in your array equals null then that's a parsing error or an invalid Obj file.
You're covering up errors by swapping them with wrong(!) index or position data.
At the very least you should print out an error, or log the error in a logfile, when that happens.

 

[tom_mai78101]

When I export my OBJ files, the "f" isn't set to have "v/vt/vn" format, rather it just shows "v".

f vx vy vz.

I didn't use "Triangulate faces" option when I'm exporting.