The bind pose is basically how your bones are first oriented

to find the position of a vertex, you will first find the vertex's weights position in bone space, then add the bones position to the weight making the weight now in "model" space, then you will average all the vertex's weights by using the bias factor to get the vertex's final position

To use the bone orientation quaternions to find the weights position, you first find the quaternions conjugate, which is:

orientationConjugate = (-orientation.x, -orientation.y, -orientation.z, orientation.w);	 // Negate the xyz axis' of the original orientation quaternion, and leave the w component alone

then you do a quaternion/quaternion multiplication with the orientation quaternion and the weights position:

finalWeightPos = orientation * weightPos;

you then multiply the finalWeightPos with the orientations conjugate:

finalWeightPos = finalWeightPos * orientationConjugate

You must do the multiplication in that order because quaternions are "noncomunitive" meaning the order in which you multiply them together DOES matter.

Finally, to get the vertex's final position, you will add the bones position to the weight, then multiply each weights position with it's bias factor (all the weights bias factor for each vertex adds up to 1), then add the resulting positions together to get the final vertex position:

finalWeightPos = finalWeightPos * weightBias;

finalWeightPos += bonePos;

finalVertexPos += finalWeightPos;

Some links that might be helpfull:

http://www.braynzars...php?p=D3D11MD51
http://www.braynzars...php?p=D3D11MD52
http://www.cprogramm...uaternions.html
http://content.gpwik...ic_Bones_System

so all together maybe something like this:

float3 finalVertexPos = float3(0,0,0);

for(int i = 0; i < numWeights; ++i)
{
	 Weight currWeight = modelWeights[currVertex.WeightStart + i];

	 float4 orientation = bones[currWeight.BoneID].Orientation;

	 float4 orientationConjugate = float4(-orientation.x, -orientation.y, -orientation.z, -orientation.w);

	 float4 finalWeightPos = (orientation * currWeight.Pos) * orientationConjugate;

	 finalWeightPos *= currWeight.Bias;

	 finalWeightPos += bones[currWeight.BoneID].Pos;

	 finalVertexPos += float3(finalWeightPos.x, finalWeightPos.y, finalWeightPos.z);
}

The "Weight" structure will need to have the weights bias factor, position, and bone id

Also, multiplying two quaternions together is not as simple as just "quat1 * quat2". opengl probably has a function to multiply them together, i know directx does (XMQuaternionMultiply).

Otherwise, to multiply two quaternions together: (copied from one of the links i mentioned above)

(Q₁ * Q₂).w = (w₁w₂ - x₁x₂ - y₁y₂ - z₁z₂)
(Q₁ * Q₂).x = (w₁x₂ + x₁w₂ + y₁z₂ - z₁y₂)
(Q₁ * Q₂).y = (w₁y₂ - x₁z₂ + y₁w₂ + z₁x₂)
(Q₁ * Q₂).z = (w₁z₂ + x₁y₂ - y₁x₂ + z₁w<sub>2)

The "w" component of the weights position is just zero (w = 0)</sub>

The bind pose is basically how your bones are first oriented

to find the position of a vertex, you will first find the vertex's weights position in bone space, then add the bones position to the weight making the weight now in "model" space, then you will average all the vertex's weights by using the bias factor to get the vertex's final position

To use the bone orientation quaternions to find the weights position, you first find the quaternions conjugate, which is:

orientationConjugate = (-orientation.x, -orientation.y, -orientation.z, orientation.w);	 // Negate the xyz axis' of the original orientation quaternion, and leave the w component alone

then you do a quaternion/quaternion multiplication with the orientation quaternion and the weights position:

finalWeightPos = orientation * weightPos;

you then multiply the finalWeightPos with the orientations conjugate:

finalWeightPos = finalWeightPos * orientationConjugate

You must do the multiplication in that order because quaternions are "noncomunitive" meaning the order in which you multiply them together DOES matter.

Finally, to get the vertex's final position, you will add the bones position to the weight, then multiply each weights position with it's bias factor (all the weights bias factor for each vertex adds up to 1), then add the resulting positions together to get the final vertex position:

finalWeightPos = finalWeightPos * weightBias;

finalWeightPos += bonePos;

finalVertexPos += finalWeightPos;

Some links that might be helpfull:

http://www.braynzars...php?p=D3D11MD51
http://www.braynzars...php?p=D3D11MD52
http://www.cprogramm...uaternions.html
http://content.gpwik...ic_Bones_System

so all together maybe something like this:

float3 finalVertexPos = float3(0,0,0);

for(int i = 0; i < numWeights; ++i)
{
	 Weight currWeight = modelWeights[currVertex.WeightStart + i];

	 float4 orientation = bones[currWeight.BoneID].Orientation;

	 float4 orientationConjugate = float4(-orientation.x, -orientation.y, -orientation.z, -orientation.w);

	 float4 finalWeightPos = (orientation * currWeight.Pos) * orientationConjugate;

	 finalWeightPos *= currWeight.Bias;

	 finalWeightPos += bones[currWeight.BoneID].Pos;

	 finalVertexPos += float3(finalWeightPos.x, finalWeightPos.y, finalWeightPos.z);
}

The bind pose is basically how your bones are first oriented

to find the position of a vertex, you will first find the vertex's weights position in bone space, then add the bones position to the weight making the weight now in "model" space, then you will average all the vertex's weights by using the bias factor to get the vertex's final position

To use the bone orientation quaternions to find the weights position, you first find the quaternions conjugate, which is:

orientationConjugate = (-orientation.x, -orientation.y, -orientation.z, orientation.w);	 // Negate the xyz axis' of the original orientation quaternion, and leave the w component alone

then you do a quaternion/quaternion multiplication with the orientation quaternion and the weights position:

finalWeightPos = orientation * weightPos;

you then multiply the finalWeightPos with the orientations conjugate:

finalWeightPos = finalWeightPos * orientationConjugate

You must do the multiplication in that order because quaternions are "noncomunitive" meaning the order in which you multiply them together DOES matter.

Finally, to get the vertex's final position, you will add the bones position to the weight, then multiply each weights position with it's bias factor (all the weights bias factor for each vertex adds up to 1), then add the resulting positions together to get the final vertex position:

finalWeightPos = finalWeightPos * weightBias;

finalWeightPos += bonePos;

finalVertexPos += finalWeightPos;

Some links that might be helpfull:

http://www.braynzars...php?p=D3D11MD51
http://www.braynzars...php?p=D3D11MD52
http://www.cprogramm...uaternions.html
http://content.gpwik...ic_Bones_System

so all together maybe something like this:

float3 finalVertexPos = float3(0,0,0);

for(int i = 0; i < numWeights; ++i)
{
     Weight currWeight = modelWeights[currVertex.WeightStart + i];

     float4 orientation = bones[currWeight.BoneID].Orientation;

     float4 orientationConjugate = float4(-orientation.x, -orientation.y, -orientation.z, -orientation.w);

     float4 finalWeightPos = (orientation * currWeight.Pos) * orientationConjugate;

     finalWeightPos *= currWeight.Bias;

     finalWeightPos += bones[currWeight.BoneID].Pos;

     finalVertexPos += finalWeightPos;
}

The bind pose is basically how your bones are first oriented

to find the position of a vertex, you will first find the vertex's weights position in bone space, then add the bones position to the weight making the weight now in "model" space, then you will average all the vertex's weights by using the bias factor to get the vertex's final position

To use the bone orientation quaternions to find the weights position, you first find the quaternions conjugate, which is:

orientationConjugate = (-orientation.x, -orientation.y, -orientation.z, orientation.w);	 // Negate the xyz axis' of the original orientation quaternion, and leave the w component alone

then you do a quaternion/quaternion multiplication with the orientation quaternion and the weights position:

finalWeightPos = orientation * weightPos;

you then multiply the finalWeightPos with the orientations conjugate:

finalWeightPos = finalWeightPos * orientationConjugate

You must do the multiplication in that order because quaternions are "noncomunitive" meaning the order in which you multiply them together DOES matter.

Finally, to get the vertex's final position, you will add the bones position to the weight, then multiply each weights position with it's bias factor (all the weights bias factor for each vertex adds up to 1), then add the resulting positions together to get the final vertex position:

finalWeightPos = finalWeightPos * weightBias;

finalWeightPos += bonePos;

finalVertexPos += finalWeightPos;

Some links that might be helpfull:

http://www.braynzars...php?p=D3D11MD51
http://www.braynzars...php?p=D3D11MD52
http://www.cprogramm...uaternions.html
http://content.gpwik...ic_Bones_System

The bind pose is basically how your bones are first oriented

to find the position of a vertex, you will first find the vertex's weights position in bone space, then add the bones position to the weight making the weight now in "model" space, then you will average all the vertex's weights by using the bias factor to get the vertex's final position

To use the bone orientation quaternions to find the weights position, you first find the quaternions conjugate, which is:

orientationConjugate = (-orientation.x, -orientation.y, -orientation.z, orientation.w);     // Negate the xyz axis' of the original orientation quaternion, and leave the w component alone

then you do a quaternion/quaternion multiplication with the orientation quaternion and the weights position:

finalWeightPos = orientation * weightPos;

you then multiply the finalWeightPos with the orientations conjugate:

finalWeightPos = finalWeightPos * orientationConjugate

You must do the multiplication in that order because quaternions are "noncomunitive" meaning the order in which you multiply them together DOES matter.

Finally, to get the vertex's final position, you will multiply each weights position with it's bias factor (all the weights bias factor for each vertex adds up to 1), add the resulting positions together, then add the bones position to get the final vertex position:

finalWeightPos = finalWeightPos * weightBias;

finalVertexPos += finalWeightPos;

// After you have added all weight positions to the final vertex position, add the bones position to the vertex's position

finalVertexPos += bonePos;

Some links that might be helpfull:

http://www.braynzarsoft.net/index.php?p=D3D11MD51
http://www.braynzarsoft.net/index.php?p=D3D11MD52
http://www.cprogramming.com/tutorial/3d/quaternions.html
http://content.gpwiki.org/index.php/OpenGL:Tutorials:Basic_Bones_System