0

In my opengl program (opengl 3.3 core profile) i have an array with N float elements in it. I pass the array to a VBO and specify it as an array of vertex attributes at index 0. Here data is the array:

glBufferData(GL_ARRAY_BUFFER, sizeof(data), data, GL_STATIC_DRAW);
glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, sizeof(float), (void*)0);

I want the attribute to update once per instance, so

glVertexAttribDivisor(0, 1);

The question is what happens when the program is told to draw N * N instances of an object with a call to glDraw*Instanced()?

There are only N elements in the array so I guess the first N instances will be drawn as expected. But what happens after that? Will it cycle through the array again to draw another set of N instances and then again to draw another one and then another one and so on until it draws all of them? Or will it just treat attribute 0 as if it was set to NULL or something for the remaining N * (N - 1) instances? If so, is there a way to make it cycle through the array as described above?

The only solution i can think of is not making the array instanced and changing its size to N * N with values inside repeating N times but that would take up unnecessary amount of memory.

qqpilla
  • 5
  • 3

1 Answers1

1

You get the exact same thing that happens if you render more vertices than there is storage in the buffer objects: out-of-bound reads. If robust memory accesses are enabled in your context, then this value will be either zero or some other value within the storage of the buffer object. Without robust accesses however, out-of-bound reads result in undefined behavior and "may result in GL interruption or termination".

So... don't do that.

If so, is there a way to make it cycle through the array as described above?

Does it have to be that way exactly?

The divisor you passed to glVertexAttribDivisor is a divisor. If it isn't zero, it takes the instance index and divides it by the divisor, and that result is used as the index into the instance array. So if you pass N as the divisor, Which means that the first N instances get the value from index 0, the next N instances get the value from index 1, etc.

This will iterate in a different order from the "cycling" behavior you want, but it ultimately does the same thing.

Note that, unless there is some other instance array involved with a different divisor or your vertex shader uses gl_InstanceID, all this will do is render the same thing N times. Which probably isn't useful.

Nicol Bolas
  • 449,505
  • 63
  • 781
  • 982
  • I also pass another array containing 4 `(x, y)` positions which are meant to represent corners of a square. The divisor for these coords is set to `N * N` so they never actually change. I need to draw this square `N * N` times and the array described in the question is actually an array of offsets. I need to apply the offsets to 'x' and 'y' coords of the square so that the squares make up a grid. I have an idea on how to apply needed offset to `x` and `y`separately using `gl_InstanceID` but that requires iterating through the offsets array. So yeah, i do need them to be "cycling". – qqpilla Oct 27 '22 at 16:32
  • @qqpilla: If you're doing all of this for runtime performance... instancing isn't the best in this case. Quads aren't a great example of where instancing is useful. Just build an array of quads using buffer streaming techniques and render them as separate quads. In most cases, that will be faster. – Nicol Bolas Oct 27 '22 at 16:34
  • @qqpilla: "*The divisor for these coords is set to N * N so they never actually change.*" Wait: why don't you just make them not-instanced? The uninstanced data will be repeated for each instance; that's what instancing is *for*. – Nicol Bolas Oct 27 '22 at 16:36
  • Yes, it actually makes sense to make them not-instanced... Still trying to understand how instancing works. Your last comment really shed some light onto the topic for me. – qqpilla Oct 27 '22 at 17:20