I already have a mesh that sits on the GPU and is instanced.
I need the mesh skeleton to go the gpu as uniform data.
But…
Why use a uniform buffer if I could just put the mesh skeleton behind the mesh data in the same buffer, and line up the attributes accordingly?
How were you planning on accessing that data?
I don’t see anything in the specification that prohibits binding a single buffer to multiple targets, but it does say that the implementation may optimise storage based upon the first target to which a buffer is bound. In any case, I don’t see the advantage to having both the attribute data and uniform values in the same buffer.
I am thinking it would be easier to just have one buffer to hold all my information for a model, the geometry and skeletal data.
Then I will use VertexAttribPointers to access them in the shader.
I wont be binding 1 buffer to multiple targets. I am going to have one buffer bound to GL_ARRAY_BUFFER and fill it with all the data of the model–geometry and skeletal.
I have read up on uniform arrays, it looks like the only reason to use them is if you are going to be using uniform blocks and if you want to access that buffer with different array programs? That’s a question… im not entirely sure what the deal is with uniform buffers
In any case, I don’t see the advantage to having both the attribute data and uniform values in the same buffer.
Is there a down side?
What do you mean by “skeletal” data?
If you mean the list of transforms needed to display a skinned model, that is not something you can adequately access via vertex attributes. Under skinning, each vertex gets its matrix by a combination of transforms from several transforms. So your vertex shader will have to look something like this:
vec4 position = vec4(0.0);
for(int i = 0; i < N; ++i)
{
position += (Transform[i] * in_position) * in_weight[i];
}
Transform is an array of transformations. Every vertex could access any transformation in this array. But vertex attributes only change per-vertex or per-instance. So there’s no real way you can provide each vertex with a palette of matrices.
So what information exactly are you trying to pass here?
Yes that is exactly what I am trying to pass, the transforms and weights.
I was thinking I could use glVertexAttribDivisor less than zero to get the data to stay for all the instances of the models.
I looked at the spec and its GLuint so I can’t. Uniforms are for information for all instances, or per draw call. Since the skeleton is for all the instances and not per instance or vertex it needs to be in a uniform format. Thanks.
How?
The vertex shader doesn’t get to decide what data to read from an attribute array. It gets invoked once for each vertex, with one element from each enabled attribute array stored in the corresponding attribute variable.
It sounds like you’re not entirely sure what the deal is with attributes versus uniforms.
An attribute is a variable which has different values for each vertex. If you had a C “struct” for each vertex, an attribute would be one of its fields.
A uniform variable is a variable whose value is constant (uniform) for the duration of a draw call, i.e. it has the same value for each vertex and fragment processed by the shaders.
Alright. I wanted to delete my other post but i was too late. I understand the vertex-fetching system. But glVertexAttribDivisor: could that be used if we make the second parameter the number of instances sent to glDrawArraysInstanced?
So create one skeletal data, send that to the GPU for all instances
eg.glDrawArraysInstanced(1, num_instnaces)
[QUOTE=Septimra;1271825]I understand the vertex-fetching system. But glVertexAttribDivisor: could that be used if we make the second parameter the number of instances sent to glDrawArraysInstanced?
So create one skeletal data, send that to the GPU for all instances[/QUOTE]
You’d have one instance containing all of the vertices. The skeleton would be per-instance data.
But the main problem with that is that you probably can’t fit a non-trivial skeleton into the maximum number of vertex attributes. At one point, even fitting a skeleton into uniforms was problematic, so you’d use a texture.
[QUOTE=GClements;1271826]You’d have one instance containing all of the vertices. The skeleton would be per-instance data.
But the main problem with that is that you probably can’t fit a non-trivial skeleton into the maximum number of vertex attributes. At one point, even fitting a skeleton into uniforms was problematic, so you’d use a texture.[/QUOTE]
To elaborate on this point a bit, most skeleton data for any humanoid figure contains lots of transforms. For example, a fully articulated hand requires no less than 15 bones (transformations) each.
The largest limit on the number of vertex attributes I have seen… is 32 vec4’s. In terms of mat4x3’s, that’s less than 10, and that’s ignores your vertex data. So doing things the way you want can’t even give you a functioning hand, let alone a whole human figure.
[QUOTE=Septimra;1271825]Alright. I wanted to delete my other post but i was too late. I understand the vertex-fetching system. But glVertexAttribDivisor: could that be used if we make the second parameter the number of instances sent to glDrawArraysInstanced?
So create one skeletal data, send that to the GPU for all instances[/QUOTE]
Septimra, it would help motivate your question if you’d detail your requirements and how you plan (algorithmically) to implement skeletal animation on the GPU before we start debating whether GL widget A versus widget B is better (or even possible) for your algorithm.
You keep talking about “skeleton data”. Some “skeleton data” is defined on the mesh and some is defined elsewhere. What skeleton data are you talking about? Just the joint final transforms for a single animation track? Or something else? Again, back to your algorithm.
Answers to these questions will help make your original question concrete and allow folks to offer more specific advice:
I understand what I did wrong now. But your questions got me thinking.
But like I said before I understand my mishap… it now looks pretty silly that i didnt see it. But I’m on the right path for this render system?
Ok, good. Yeah, you can use whatever kind of uniform storage you want to pass this into the shader (textures, simple uniforms, buffers, etc.) Since you’ll be changing it potentially every frame for every character (with your CPU pose calc appoach), you should prefer a type of uniform which performs well on your GPUs with frequent updates.
Also, for the simple keyframe interp scenario, you might put your post transform interp on the GPU, computed in vertex shaders. That can be quite a bit faster than doing it on the CPU, and greatly reduces the amount of uniform data that needs to stream to the GPU per frame per skeletal instance.