Let's say we are drawing a bunch of rectangles in OpenGL. That is, we're filling up a vertex buffer and then drawing them all in a single call call via drawArrays
, like this:
let count = 3;
gl.bindBuffer(gl.ARRAY_BUFFER, positionBuffer);
gl.bufferData(gl.ARRAY_BUFFER, points, gl.STATIC_DRAW);
gl.vertexAttribPointer(positionAttributeLocation, 2, gl.FLOAT, false, 0, 0);
gl.drawArrays(gl.TRIANGLES, 0, 6 * count);
My question is: is it guaranteed that later rectangles will be drawn on top of prior rectangles? I'm not using depth testing, and everything is 2D and on the same z-axis.
It always seems to be the case in my testing, but my reason for assuming it may not always be the case is that GPUs are parallel. That is, say we were to draw 100,000 rectangles. Obviously the GPU is not rendering them sequentially, as the GPU is a parallel device, and the rendering completes in milliseconds.
If that is indeed the case, then is it possible for rectangles earlier in the buffer to be drawn on top of rectangles later in the buffer? Because they are all drawn at the same time? And if so, is there any way to prevent this? For my application, I want to be positive that quads later in the vertex buffer are always drawn on top of previous quads.
Via Active questions tagged javascript - Stack Overflow https://ift.tt/2FdjaAW
Comments
Post a Comment