Sign in to follow this  

OpenGL do i need to reserve space for vertex buffer?

This topic is 1848 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 am using opengles 2.0. but i think the answer will be same with openGL.
i am using VBO. every frame i bind the vertexBuffer and then use glBufferData to submit a vertexArray to GPU.the size of the vertexArray is different each frame. so i wonder if the space of the vertexBuffer reallocated every time?
i guess if the vertexArray i submit this time is bigger than last time, the space of vertexBuffer on GPU side need to reallocate, and it may inefficient. am i right? do i need to reserve space for the vertexBuffer to avoid reallocation?

i read on the opengles 2.0 reference and found the information that if we call glBufferData with * data set to NULL, it will perform space reservation, for example: glBufferData(GL_ARRAY_BUFFER, n_byte, NULL, usage); Edited by wantnon_cn

Share this post


Link to post
Share on other sites
Yes it would be reallocated every time. What you should do is allocate a buffer using the method you described that is "big enough" for anything you will ever put into it. On a side note it is a bad practice to call glBufferData every frame (its really slow). What you should do if the vertices are changing every frame is allocate you buffer as GL_DYNAMIC_DRAW and use glBufferSubData to upload only the vertices that have changed.

Share this post


Link to post
Share on other sites
In theory two Bad Things can happen:[list=1]
[*]If the size is different the buffer will need to be reallocated.
[*]If the buffer is currently in use for drawing the pipeline must stall until it is no longer in use before the update can complete.
[/list]

Either of these will cause you performance problems. Now, some drivers may get clever and decide to not reallocate if the new size is smaller than the old, but that's internal driver behaviour and shouldn't be relied on. Moving on.

Counter-intuitively, (1) may actually be significantly less of a performance problem than (2) is. The reason why is that with (1), if you've created your buffer with the proper usage flags, then the driver can make some intelligent decisions around how it allocates and releases memory. So it can decide to not release memory immediately but keep it hanging around for a few frames in case you need it again shortly, meaning that with (1) you reach a state where the driver is just handing you back a block of memory that you'd previously used a few frames ago each time you update, and no reallocations are actually happening at all (using the same size and usage flags for your glBufferData calls each time can clue the driver in on this being the behaviour you want).

In practice however you can rely on this behaviour fairly confidently (Doom 3 did it and you can bet that GPU vendors optimized around it's usage patterns). Regarding the usage flags, bear in mind here that they're just hints to the driver, and the driver is not actually obliged to honour them at all - AMD/ATI drivers (at least in the past) generally would completely ignore them and optimize the buffer around how your program actually used it instead. I'm not entirely certain if that's good behaviour or not...

(2) is where things can get nasty and cause you serious trouble. The way glBufferSubData is specified, it [i]must not[/i] return [i]before[/i] the data copy has completed. Because of GPU latency and GPU/CPU asynchronous operation, that means that you may incur a pipeline stall of (typically) up to 3 frames worth of time. See [url="http://www.opengl.org/sdk/docs/man/xhtml/glBufferSubData.xml"]http://www.opengl.or...fferSubData.xml[/url] and especially note:
[quote]If any rendering in the pipeline makes reference to data in the buffer object being updated by glBufferSubData, especially from the specific region being updated, that rendering must drain from the pipeline before the data store can be updated.[/quote]

The trick here is to call glBufferData with a NULL pointer, but with the same flags and size as when the buffer was first created - that will cause the driver to give you a new block of memory (hopefully using the pattern I described above where this memory is just something you'd previously used but the driver decided to keep for a while in case you need it again) but allow drawing to continue uninterrupted from the memory it was previously using. Then you can safely use glBufferSubData to update that without incurring any risk of stalling the pipeline.

With GL ES2 you're more or less stuck with this model; with ES3 (and GL3.x +, or older versions with the ARB_map_buffer_range extension) you've got a few more options that allow for creation of a proper streaming buffer pattern, similar to the tried-and-trusted D3D discard/no-overwrite pattern (which has been widely in use for well over a decade and is known to work well with dynamic buffer data). Edited by mhagain

Share this post


Link to post
Share on other sites
thank you guys , now i am more clear with this question [img]http://public.gamedev.net//public/style_emoticons/default/smile.png[/img] Edited by wantnon_cn

Share this post


Link to post
Share on other sites
That's a great answer from mhagain. I'm in a similar situation where a lot of my rendering is one-shot, variable sized stuff, also OpenGLES and I'm trying to work out how best to switch it over to using VBOs.

This might be veering a little off topic, but I just can't understand why VBOs should be the correct way to do things in this situation. It seems to me that in terms of expressing your wishes to OpenGL, then just pointing OpenGL at a bit of memory and saying "render this" seems to make more sense than creating/locking/unlocking buffers with just the right sizes/hints/setting and crossing your fingers that the driver is implemented in a sensible way.

Is there a reason that doing it with VBOs makes it possible for drivers to use more efficient code paths?

Share this post


Link to post
Share on other sites
Vbo are allocated on the gpu. So they are faster to access.

 

Not necessarily; GL doesn't make any promises about where it will allocate a VBO and is perfectly free to allocate one in system memory depending on usage hints (which it is free to ignore), current resource constraints, etc.

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