Sign in to follow this  

OpenGL OpenGL ES 2.0: How to specify normals when using an index?

This topic is 2028 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

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:

[CODE]
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);
[/CODE]

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.

Share this post


Link to post
Share on other sites
You are incorrect that the index only reference the vertices. An index references [i]all[/i] 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.

Share this post


Link to post
Share on other sites
[quote name='Brother Bob' timestamp='1339631913' post='4948985']
You are incorrect that the index only reference the vertices. An index references [i]all[/i] 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.
[/quote]
Ah, got it. Thanks for clearing that up.

[quote]
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.
[/quote]
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

Share this post


Link to post
Share on other sites
[quote name='Synthetix' timestamp='1339633016' post='4948991']
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
[/quote]
As I said in the first quote that you acknowledged; an index references [i]all[/i] 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

Share this post


Link to post
Share on other sites
[quote name='Brother Bob' timestamp='1339634584' post='4948997']
As I said in the first quote that you acknowledged; an index references [i]all[/i] 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.
[/quote]
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?

Share this post


Link to post
Share on other sites
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.

Share this post


Link to post
Share on other sites
[quote name='Brother Bob' timestamp='1339637563' post='4949007']
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.
[/quote]
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!

Share this post


Link to post
Share on other sites
[quote name='Brother Bob' timestamp='1339637563' post='4949007']
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. [/quote]
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

Share this post


Link to post
Share on other sites
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:
[attachment=9471:no-norms.png]
Obviously, the vertices are being read correctly. However, here's what I get when I add the normas:
[attachment=9472:with-norms.png]
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:

[CODE]
//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));
}
[/CODE]


[CODE]
//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);
}
[/CODE]

Share this post


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

Share this post


Link to post
Share on other sites
[quote name='larspensjo' timestamp='1339697178' post='4949222']
Please show the new code, including the calls to glVertexAttribPointer().
[/quote]

Here's the new code:

[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
[/CODE]

And then I draw with this:

[CODE]
glDrawArrays(GL_TRIANGLES,0,(model->size*sizeof(float)));
[/CODE]

Share this post


Link to post
Share on other sites
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.

Share this post


Link to post
Share on other sites
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:

[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");
[/CODE]

And also here:

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

Share this post


Link to post
Share on other sites
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.

Share this post


Link to post
Share on other sites
You also need to normalize [background=rgb(248, 248, 248)]newNormal[/background].


L. Spiro Edited by L. Spiro

Share this post


Link to post
Share on other sites
[quote name='Synthetix' timestamp='1339741288' post='4949454']
I figured it out! The problem was the normals needed to precede the vertices when specifying the attribute arrays. So, order matters.
[/quote]

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 [i]last thing written in the shader.[/i] 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:

[CODE]
//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;
}
[/CODE]

Share this post


Link to post
Share on other sites
[quote name='Synthetix' timestamp='1340867001' post='4953573']
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.
[/quote]

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

Share this post


Link to post
Share on other sites
[quote name='larspensjo' timestamp='1340883327' post='4953628']
Are you sure about that? I have many shaders where gl_Position is not the last thing. Why does it have to be last?
[/quote]

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 [i]did not[/i] 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

Share this post


Link to post
Share on other sites
Sign in to follow this  

  • Similar Content

    • By xhcao
      Does sync be needed to read texture content after access texture image in compute shader?
      My simple code is as below,
      glUseProgram(program.get());
      glBindImageTexture(0, texture[0], 0, GL_FALSE, 3, GL_READ_ONLY, GL_R32UI);
      glBindImageTexture(1, texture[1], 0, GL_FALSE, 4, GL_WRITE_ONLY, GL_R32UI);
      glDispatchCompute(1, 1, 1);
      // Does sync be needed here?
      glUseProgram(0);
      glBindFramebuffer(GL_READ_FRAMEBUFFER, framebuffer);
      glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                     GL_TEXTURE_CUBE_MAP_POSITIVE_X + face, texture[1], 0);
      glReadPixels(0, 0, kWidth, kHeight, GL_RED_INTEGER, GL_UNSIGNED_INT, outputValues);
       
      Compute shader is very simple, imageLoad content from texture[0], and imageStore content to texture[1]. Does need to sync after dispatchCompute?
    • By Jonathan2006
      My question: is it possible to transform multiple angular velocities so that they can be reinserted as one? My research is below:
      // This works quat quaternion1 = GEQuaternionFromAngleRadians(angleRadiansVector1); quat quaternion2 = GEMultiplyQuaternions(quaternion1, GEQuaternionFromAngleRadians(angleRadiansVector2)); quat quaternion3 = GEMultiplyQuaternions(quaternion2, GEQuaternionFromAngleRadians(angleRadiansVector3)); glMultMatrixf(GEMat4FromQuaternion(quaternion3).array); // The first two work fine but not the third. Why? quat quaternion1 = GEQuaternionFromAngleRadians(angleRadiansVector1); vec3 vector1 = GETransformQuaternionAndVector(quaternion1, angularVelocity1); quat quaternion2 = GEQuaternionFromAngleRadians(angleRadiansVector2); vec3 vector2 = GETransformQuaternionAndVector(quaternion2, angularVelocity2); // This doesn't work //quat quaternion3 = GEQuaternionFromAngleRadians(angleRadiansVector3); //vec3 vector3 = GETransformQuaternionAndVector(quaternion3, angularVelocity3); vec3 angleVelocity = GEAddVectors(vector1, vector2); // Does not work: vec3 angleVelocity = GEAddVectors(vector1, GEAddVectors(vector2, vector3)); static vec3 angleRadiansVector; vec3 angularAcceleration = GESetVector(0.0, 0.0, 0.0); // Sending it through one angular velocity later in my motion engine angleVelocity = GEAddVectors(angleVelocity, GEMultiplyVectorAndScalar(angularAcceleration, timeStep)); angleRadiansVector = GEAddVectors(angleRadiansVector, GEMultiplyVectorAndScalar(angleVelocity, timeStep)); glMultMatrixf(GEMat4FromEulerAngle(angleRadiansVector).array); Also how do I combine multiple angularAcceleration variables? Is there an easier way to transform the angular values?
    • By dpadam450
      I have this code below in both my vertex and fragment shader, however when I request glGetUniformLocation("Lights[0].diffuse") or "Lights[0].attenuation", it returns -1. It will only give me a valid uniform location if I actually use the diffuse/attenuation variables in the VERTEX shader. Because I use position in the vertex shader, it always returns a valid uniform location. I've read that I can share uniforms across both vertex and fragment, but I'm confused what this is even compiling to if this is the case.
       
      #define NUM_LIGHTS 2
      struct Light
      {
          vec3 position;
          vec3 diffuse;
          float attenuation;
      };
      uniform Light Lights[NUM_LIGHTS];
       
       
    • By pr033r
      Hello,
      I have a Bachelor project on topic "Implenet 3D Boid's algorithm in OpenGL". All OpenGL issues works fine for me, all rendering etc. But when I started implement the boid's algorithm it was getting worse and worse. I read article (http://natureofcode.com/book/chapter-6-autonomous-agents/) inspirate from another code (here: https://github.com/jyanar/Boids/tree/master/src) but it still doesn't work like in tutorials and videos. For example the main problem: when I apply Cohesion (one of three main laws of boids) it makes some "cycling knot". Second, when some flock touch to another it scary change the coordination or respawn in origin (x: 0, y:0. z:0). Just some streng things. 
      I followed many tutorials, change a try everything but it isn't so smooth, without lags like in another videos. I really need your help. 
      My code (optimalizing branch): https://github.com/pr033r/BachelorProject/tree/Optimalizing
      Exe file (if you want to look) and models folder (for those who will download the sources):
      http://leteckaposta.cz/367190436
      Thanks for any help...

    • By Andrija
      I am currently trying to implement shadow mapping into my project , but although i can render my depth map to the screen and it looks okay , when i sample it with shadowCoords there is no shadow.
      Here is my light space matrix calculation
      mat4x4 lightViewMatrix; vec3 sun_pos = {SUN_OFFSET * the_sun->direction[0], SUN_OFFSET * the_sun->direction[1], SUN_OFFSET * the_sun->direction[2]}; mat4x4_look_at(lightViewMatrix,sun_pos,player->pos,up); mat4x4_mul(lightSpaceMatrix,lightProjMatrix,lightViewMatrix); I will tweak the values for the size and frustum of the shadow map, but for now i just want to draw shadows around the player position
      the_sun->direction is a normalized vector so i multiply it by a constant to get the position.
      player->pos is the camera position in world space
      the light projection matrix is calculated like this:
      mat4x4_ortho(lightProjMatrix,-SHADOW_FAR,SHADOW_FAR,-SHADOW_FAR,SHADOW_FAR,NEAR,SHADOW_FAR); Shadow vertex shader:
      uniform mat4 light_space_matrix; void main() { gl_Position = light_space_matrix * transfMatrix * vec4(position, 1.0f); } Shadow fragment shader:
      out float fragDepth; void main() { fragDepth = gl_FragCoord.z; } I am using deferred rendering so i have all my world positions in the g_positions buffer
      My shadow calculation in the deferred fragment shader:
      float get_shadow_fac(vec4 light_space_pos) { vec3 shadow_coords = light_space_pos.xyz / light_space_pos.w; shadow_coords = shadow_coords * 0.5 + 0.5; float closest_depth = texture(shadow_map, shadow_coords.xy).r; float current_depth = shadow_coords.z; float shadow_fac = 1.0; if(closest_depth < current_depth) shadow_fac = 0.5; return shadow_fac; } I call the function like this:
      get_shadow_fac(light_space_matrix * vec4(position,1.0)); Where position is the value i got from sampling the g_position buffer
      Here is my depth texture (i know it will produce low quality shadows but i just want to get it working for now):
      sorry because of the compression , the black smudges are trees ... https://i.stack.imgur.com/T43aK.jpg
      EDIT: Depth texture attachment:
      glTexImage2D(GL_TEXTURE_2D, 0,GL_DEPTH_COMPONENT24,fbo->width,fbo->height,0,GL_DEPTH_COMPONENT,GL_FLOAT,NULL); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, fbo->depthTexture, 0);
  • Popular Now