18 replies to this topic

[Synthetix]

I have an OpenGL ES 2.0-based app I'm working on, and am having trouble with lighting. I would like to send both vertices and normals to the vertex shader, but I don't know of a way to do this. I can send the vertices to the shader and it renders the model properly using my index specified with GL_ELEMENT_ARRAY_BUFFER, but the lighting isn't rendered properly without the normals.

Here's the code I'm working with:

glEnableVertexAttribArray(0); //vertices
glEnableVertexAttribArray(1); //normals
glBindAttribLocation(prog, 0, "v_position"); //bind this var to 0
glBindAttribLocation(prog, 1, "v_normal"); //bind this var to 1

//generate buffers
GLuint vbuf_id[2],ibuf_id[2];
glGenBuffers(2, vbuf_id); //vertex buffers
glGenBuffers(2, ibuf_id); //index buffers

//create and bind buffer for vertices
glBindBuffer(GL_ARRAY_BUFFER, vbuf_id[0]); //vertex buffer
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
glBindBuffer(GL_ARRAY_BUFFER,0); //unbind

//create and bind another buffer for normals
glBindBuffer(GL_ARRAY_BUFFER, vbuf_id[1]); //normal buffer
glBufferData(GL_ARRAY_BUFFER, sizeof(normals), normals, GL_STATIC_DRAW);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
glBindBuffer(GL_ARRAY_BUFFER,0); //unbind

//create IBO (index buffer)
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibuf_id[0]);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(index), index, GL_STATIC_DRAW);

Which works great for vertices, using the supplied index. However, since the index only references the vertices, how do I include the normals? I have a list of normals from a COLLADA file, but I can't seem to get the vertex shader to process them correctly. I also had to remove the normals entries from the index because OpenGL wouldn't work if I included them. Apparently, the GL_ELEMENT_ARRAY_BUFFER wants packed entries for vertices ONLY.

What am I doing wrong? I'm happy to supply any additional information that may help.

[Brother Bob]

You are incorrect that the index only reference the vertices. An index references all enabled attributes. Since you are using generic attributes, there is no notation of vertex or normal, or anything for the matter, as far as OpenGL is concerned anyway since the attribute could be anything.

So, do you have exactly one normal for every position in the corresponding attribute array? If not, the normal array is not correct since you have normals without corresponding position, or vice versa.

[Synthetix]

You are incorrect that the index only reference the vertices. An index references all enabled attributes. Since you are using generic attributes, there is no notation of vertex or normal, or anything for the matter, as far as OpenGL is concerned anyway since the attribute could be anything.

Ah, got it. Thanks for clearing that up.

So, do you have exactly one normal for every position in the corresponding attribute array? If not, the normal array is not correct since you have normals without corresponding position, or vice versa.

I should have an equal number of vertices and normals, per the COLLADA file. I made sure it was exported properly and the model in question works fine on an OpenGL (non-ES) 2.0 implementation. I am just trying to get everything working on ES 2.0 for use on phones.

I can build either one or two arrays. One with vertices and normals interleaved, or two separate arrays that each correspond to a distinct attribute variable. Assuming I have two GL_ARRAY_BUFFERS, each attached to its own attribute variable in the vertex shader, how does OpenGL know which index values correspond to each array/attribute?

FYI, my index is from the COLLADA file, and looks like this (where V is a vertex position, and N is a normal):

VNVNVNVNVN...etc

Edited by Synthetix, 13 June 2012 - 06:17 PM.

[Brother Bob]

I can build either one or two arrays. One with vertices and normals interleaved, or two separate arrays that each correspond to a distinct attribute variable. Assuming I have two GL_ARRAY_BUFFERS, each attached to its own attribute variable in the vertex shader, how does OpenGL know which index values correspond to each array/attribute?

FYI, my index is from the COLLADA file, and looks like this (where V is a vertex position, and N is a normal):

VNVNVNVNVN...etc

As I said in the first quote that you acknowledged; an index references all enabled attribute arrays. You can only have one index array, and each index in that array will reference all enabled attributes to construct one vertex. Thus, if you have the index array [1, 4, 5], then you have three vertices; first vertex is constructed from the second position and the second normal; the second vertex is constructed from the fifth position and the fifth normal; and the third vertex is constructed from the sixth position and the sixth normal.

Each index references all enabled attributes to construct a single vertex, and the array of indices are reference in sequence to construct a sequence of vertices.

edit: And note it is irrelevant whether you have an interleaved array or two separate arrays. An array (in this context) is defined by the glVertexAttribPointer. Whether you make the two calls (one for positions and one for normals) to the same or different buffer objects, or with packed or strided arrays, is irrelevant. Two pointers; two arrays.

Edited by Brother Bob, 13 June 2012 - 06:48 PM.

[Synthetix]

As I said in the first quote that you acknowledged; an index references all enabled attribute arrays. You can only have one index array, and each index in that array will reference all enabled attributes to construct one vertex. Thus, if you have the index array [1, 4, 5], then you have three vertices; first vertex is constructed from the second position and the second normal; the second vertex is constructed from the fifth position and the fifth normal; and the third vertex is constructed from the sixth position and the sixth normal.

Okay. I understand. This explains why the model renders properly when I remove the normal entries from the index, because as I mentioned a COLLADA file contains an interleaved index of both vertices and normals: VNVNVNVNVNVN

So my predicament is I have two arrays, one for vertices and one for normals, but I am allowed only one index. The COLLADA file's index interleaves the indices for both in an integer array. I don't think there is any relation between the two indices.

Should I just not use the index at all and assemble the data manually?

Any ideas?

[Brother Bob]

So basically you have two index arrays; one for positions and one for normals? That is not how OpenGL works with arrays as it expects a single index array for all attributes. You have to rearrange the arrays, and possible duplicate certain attributes, so that the two index arrays are identical. The easiest way is to just flatten the arrays and don't use indices at all.

For example, iterate over the list of triangles and assemble a secondary array for the positions and the normals by reading the indices and the corresponding attributes from the file. What you end up with is a linear list of vertices that corresponds to the final order of the vertices if you reference the indices from the file.

[Synthetix]

So basically you have two index arrays; one for positions and one for normals? That is not how OpenGL works with arrays as it expects a single index array for all attributes. You have to rearrange the arrays, and possible duplicate certain attributes, so that the two index arrays are identical. The easiest way is to just flatten the arrays and don't use indices at all.

For example, iterate over the list of triangles and assemble a secondary array for the positions and the normals by reading the indices and the corresponding attributes from the file. What you end up with is a linear list of vertices that corresponds to the final order of the vertices if you reference the indices from the file.

Yeah, I think you're right. I'm going to try what you suggested and see if I can get it to work. I'll report back once I'm finished!

[L. Spiro]

So basically you have two index arrays; one for positions and one for normals? That is not how OpenGL works with arrays as it expects a single index array for all attributes.

Having only one vertex buffer is good for performance, but specifying multiple vertex buffers is perfectly legitimate.

Bind vertex buffer 0.
Enable attributes and set attribute pointers.

Bind vertex buffer 1.
Enable attributes and set attribute pointers.


Modify your shader so that it returns the color of the normals (stop doing lighting calculations) and check the result.
If it is all black, post your shader.


L. Spiro

[Synthetix]

Okay, here's what's happening now. I've removed the index buffer altogether, and am now just using glDrawArrays(). The way I accomplished this was by building a list of vertices using the COLLADA file's index myself, then passing the result to glBufferData(). It works if I don't use the normals. Here's what the output looks like if I use the values of the vertices as normals in the shader:

Obviously, the vertices are being read correctly. However, here's what I get when I add the normas:

What gives? I suspect this is a problem with my shader(s). Hopefully this "globe" shape will be a tell-tale sign of something I've done wrong.

Here are the shaders I'm using:

//vertex shader

attribute vec3 v_position;
attribute vec3 v_normal;
varying float lightIntensity;

uniform mat4 model;
//uniform mat4 view;
uniform mat4 proj;

void main(void)
{
  vec4 newPosition = proj * model * vec4(v_position,1.0);
  gl_Position = newPosition;

  //specify direction of light
  vec3 light_dir = vec3(0.9,0.8,-3.0);

  //if I use this, it looks like a messed up sphere
  vec4 newNormal = proj * model * vec4(v_normal,0.0);
	
  //if I use this, I can make out the shape of the model,
  //but the lighting over the model is wrong.
  //vec4 newNormal = proj * model * vec4(v_position,0.0);
	
  lightIntensity = max(0.0, dot(newNormal.xyz, light_dir));
}

//fragment shader

varying float lightIntensity;
void main(void)
{
  vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);
  gl_FragColor = vec4((yellow * lightIntensity * 0.2).rgb, 1.0);
}

[Brother Bob]

Are you using the normal data as position data? The geometry looks like a sphere, and normals are equivalent to points on a sphere.

[larspensjo]

Please show the new code, including the calls to glVertexAttribPointer().

[Synthetix]

Please show the new code, including the calls to glVertexAttribPointer().

Here's the new code:

//grab locations of attribute vars
glEnableVertexAttribArray(0); //vertices
glBindAttribLocation(prog, 0, "v_position"); //bind this var to 0
glEnableVertexAttribArray(1); //normals
glBindAttribLocation(prog, 1, "v_normal"); //bind this var to 1

//generate buffers
GLuint vbuf_id[2];
glGenBuffers(2, vbuf_id); //vertex buffers

//create and bind buffer for vertices
glBindBuffer(GL_ARRAY_BUFFER, vbuf_id[0]); //vertex buffer
glBufferData(GL_ARRAY_BUFFER, (model->size*sizeof(float))*3, (void*)modeldata, GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
glBindBuffer(GL_ARRAY_BUFFER,0); //unbind

//create and bind buffer for normals
glBindBuffer(GL_ARRAY_BUFFER, vbuf_id[1]); //normal buffer
glBufferData(GL_ARRAY_BUFFER, (model->size*sizeof(float))*3, (void*)normaldata, GL_STATIC_DRAW);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
glBindBuffer(GL_ARRAY_BUFFER,0); //unbind

And then I draw with this:

glDrawArrays(GL_TRIANGLES,0,(model->size*sizeof(float)));

[Brother Bob]

Looks very fishy when you're multiplying the size of a float by the size of the model in order to determine how many vertices to draw. It is necessary to multiply in glBufferData because there the size is the number of bytes, but in glDrawArrays it is the number of vertices.

[Synthetix]

I figured it out! The problem was the normals needed to precede the vertices when specifying the attribute arrays. So, order matters.

Here are the updated portions of the code:

//grab locations of attribute vars
//array of normals must come before vertices!
glEnableVertexAttribArray(0); //normals
glBindAttribLocation(prog, 0, "v_normals");
glEnableVertexAttribArray(1); //vertices
glBindAttribLocation(prog, 1, "v_position");

And also here:

//normals
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);
//vertices
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, (void*)0);

[larspensjo]

Are you using a Vertex Array Object? It may be that the code works anyway, but it is mandatory from OpenGL 3.

The VAO isn't a data buffer, it is a number of states that are saved and then easily restored when it is time to draw.

[L. Spiro]

You also need to normalize newNormal.


L. Spiro

Edited by L. Spiro, 15 June 2012 - 07:43 AM.

[Synthetix]

I figured it out! The problem was the normals needed to precede the vertices when specifying the attribute arrays. So, order matters.

I just thought I'd post an update to this. The order the attribute variables wasn't actually the problem. The problem was with the vertex shader. I didn't realize this until running it on a device with a PowerVR SGX 530 GPU (the previous GPU was an Nvidia one).

The problem was that gl_Position was being written too early in the shader. It should be the last thing written in the shader. Although some drivers may work when gl_Position is written in the middle of the vertex shader, others may fail. This behavior seems to be driver-specific.

Here is an updated version that works with every device I've tried:

//vertex shader

attribute vec3 v_position;
attribute vec3 v_normal;
varying float lightIntensity;

uniform mat4 model;
//uniform mat4 view;
uniform mat4 proj;

void main()
{
	//specify direction of light
	vec3 light_dir = vec3(0.9,0.8,-3.0);

	vec4 newNormal = proj * model * vec4(v_normal,0.0);
			
	lightIntensity = max(0.0, dot(newNormal.xyz, light_dir));

	//gl_Position must come LAST!
	vec4 newPosition = proj * model * vec4(v_position,1.0);
	gl_Position = newPosition;
}

[larspensjo]

The problem was that gl_Position was being written too early in the shader. It should be the last thing written in the shader. Although some drivers may work when gl_Position is written in the middle of the vertex shader, others may fail. This behavior seems to be driver-specific.

Are you sure about that? I have many shaders where gl_Position is not the last thing. Why does it have to be last?

[Synthetix]

Are you sure about that? I have many shaders where gl_Position is not the last thing. Why does it have to be last?

Yep, I just verified this. This is with a device running a PowerVR SGX 530 GPU. Now I can't say for sure or not whether other things in the code have any influence over this. I just know that if I write anything after gl_Position, the data for the vertices and normals gets swapped (i.e. OpenGL thinks vertex data is normal data and vice versa). That's without changing anything else, just literally moving up/down two lines of code and recompiling.

I indeed did not have to put gl_Position last when the vetex shader was running on an Nvidia chip. It didn't seem to care.

I also changed my code from using separate buffers to a single OpenGL buffer to hold both vertices and normals, but that didn't seem to affect this issue.

Edited by Synthetix, 28 June 2012 - 08:54 PM.