OpenGL Animation seems to be missing bone data once in a while - c++

Question

Alright, so I've got basic models loading and rendering in an OpenGL engine. I had animations working for a model. However, when I tried adding multiple models with animations to a scene, I got a bunch of weird behaviour - the last model animated incorrectly.
In trying to isolate the issue, I believe I've happened upon something that might be related - when rendering a model, if I 'zero out' the bone data in OpenGL (that is, send in a bunch of identity matrices), and THEN send the actual bone data, I get weird 'stuttering' in a models animation. It looks like there is a gap in the animation, where the model suddenly goes back to it's neutral position, then quickly goes back to the animation on the next frame.
I'm using Debian 7 64bit with the proprietary NVidia graphics drivers installed (GeForce GTX 560M with 3GB VRAM).
I have a video of this happening here: http://jarrettchisholm.com/static/videos/wolf_model_animation_problem_1.ogv
It's a bit hard to see in the video (it doesn't catch all of the frames I guess). You can see it more clearly when the wolf is on its side. This happens throughout the animation.
My model render code:
for ( glm::detail::uint32 i = 0; i < meshes_.size(); i++ )
{
if ( textures_[i] != nullptr )
{
// TODO: bind to an actual texture position (for multiple textures per mesh, which we currently don't support...maybe at some point we will??? Why would we need multiple textures?)
textures_[i]->bind();
//shader->bindVariable( "Texture", textures_[i]->getBindPoint() );
}
if ( materials_[i] != nullptr )
{
materials_[i]->bind();
shader->bindVariable( "Material", materials_[i]->getBindPoint() );
}
if (currentAnimation_ != nullptr)
{
// This is when I send the Identity matrices to the shader
emptyAnimation_->bind();
shader->bindVariable( "Bones", emptyAnimation_->getBindPoint() );
glw::Animation* a = currentAnimation_->getAnimation();
a->setAnimationTime( currentAnimation_->getAnimationTime() );
// This generates the new bone matrices
a->generateBoneTransforms(globalInverseTransformation_, rootBoneNode_, meshes_[i]->getBoneData());
// This sends the new bone matrices to the shader,
// and also binds the buffer
a->bind();
// This sets the bind point to the Bone uniform matrix in the shader
shader->bindVariable( "Bones", a->getBindPoint() );
}
else
{
// Zero out the animation data
// TODO: Do we need to do this?
// TODO: find a better way to load 'empty' bone data in the shader
emptyAnimation_->bind();
shader->bindVariable( "Bones", emptyAnimation_->getBindPoint() );
}
meshes_[i]->render();
}
The shader binding code:
void GlslShaderProgram::bindVariable(std::string varName, GLuint bindPoint)
{
GLuint uniformBlockIndex = glGetUniformBlockIndex(programId_, varName.c_str());
glUniformBlockBinding(programId_, uniformBlockIndex, bindPoint);
}
Animation code:
...
// This gets called when we create an Animation object
void Animation::setupAnimationUbo()
{
bufferId_ = openGlDevice_->createBufferObject(GL_UNIFORM_BUFFER, 100 * sizeof(glm::mat4), &currentTransforms_[0]);
}
void Animation::loadIntoVideoMemory()
{
glBindBuffer(GL_UNIFORM_BUFFER, bufferId_);
glBufferSubData(GL_UNIFORM_BUFFER, 0, currentTransforms_.size() * sizeof(glm::mat4), &currentTransforms_[0]);
}
/**
* Will stream the latest transformation matrices into opengl memory, and will then bind the data to a bind point.
*/
void Animation::bind()
{
loadIntoVideoMemory();
bindPoint_ = openGlDevice_->bindBuffer( bufferId_ );
}
...
My OpenGL Wrapper code:
...
GLuint OpenGlDevice::createBufferObject(GLenum target, glmd::uint32 totalSize, const void* dataPointer)
{
GLuint bufferId = 0;
glGenBuffers(1, &bufferId);
glBindBuffer(target, bufferId);
glBufferData(target, totalSize, dataPointer, GL_DYNAMIC_DRAW);
glBindBuffer(target, 0);
bufferIds_.push_back(bufferId);
return bufferId;
}
...
GLuint OpenGlDevice::bindBuffer(GLuint bufferId)
{
// TODO: Do I need a better algorithm here?
GLuint bindPoint = bindPoints_[currentBindPoint_];
currentBindPoint_++;
if ( currentBindPoint_ > bindPoints_.size() )
currentBindPoint_ = 1;
glBindBufferBase(GL_UNIFORM_BUFFER, bindPoint, bufferId);
return bindPoint;
}
...
My Vertex shader:
#version 150 core
uniform mat4 projectionMatrix;
uniform mat4 viewMatrix;
uniform mat4 modelMatrix;
uniform mat4 pvmMatrix;
uniform mat3 normalMatrix;
in vec3 in_Position;
in vec2 in_Texture;
in vec3 in_Normal;
in ivec4 in_BoneIds;
in vec4 in_BoneWeights;
out vec2 textureCoord;
out vec3 normalDirection;
out vec3 lightDirection;
struct Light {
vec4 ambient;
vec4 diffuse;
vec4 specular;
vec4 position;
vec4 direction;
};
layout(std140) uniform Lights
{
Light lights[ 2 ];
};
layout(std140) uniform Bones
{
mat4 bones[ 100 ];
};
void main() {
// Calculate the transformation on the vertex position based on the bone weightings
mat4 boneTransform = bones[ in_BoneIds[0] ] * in_BoneWeights[0];
boneTransform += bones[ in_BoneIds[1] ] * in_BoneWeights[1];
boneTransform += bones[ in_BoneIds[2] ] * in_BoneWeights[2];
boneTransform += bones[ in_BoneIds[3] ] * in_BoneWeights[3];
vec4 tempPosition = boneTransform * vec4(in_Position, 1.0);
gl_Position = pvmMatrix * tempPosition;
vec4 lightDirTemp = viewMatrix * lights[0].direction;
textureCoord = in_Texture;
normalDirection = normalize(normalMatrix * in_Normal);
lightDirection = normalize(vec3(lightDirTemp));
}
I apologize if I haven't included enough information - I put in what I thought would be useful. If you want/need to see more, you can get all of the code at https://github.com/jarrettchisholm/glr under the master_animation_work branch.

Answer 1

It isn't really opengl specific.
When exporter exports model, some of them export "skin parade" pose. I.e. the pose in which "bone modifier" was initially applied.
In your case, It is probably one of those
Either your exporter exported this "skin parade" as the very first frame (and animation loops over it)
Or your animation framework can't loop around properly, - can't find next frame when it is on the last animation key, and use "skin parade" as the default key.
The problem is probably in routine that calculates transforms for animations.
Here's how you debug it.
Render debug bone hierarchy (using dumbest shader possible or even fixed-function opengl). Debug bone hierarchy could look like this:
In the picture - orange lines show current position of animation bones. Flying coordinates systems (the ones that are not connected) show default locations. triangle and square are debug geometry for other purposes and are not related to animation system.
Visually check if bone hierarchy moves correctly.
If this "default frame" appears in debug hierarchy (i.e. bones themselves take "skin parade" pose once in a while), it is either an animation framework problem, purely mathematical and it doesn't have anything to do with opengl itself, or it is exporter problem (extra frame)
If it does not appear there (i.e. bones move around properly BUT geometry stands in skin parade pose), it is shader problem.
Debug animation skeleton should be rendered without any bone weights - just calculate world-space position of bones and connect them with simple lines. Use dumbest shader possible or fixed-function.