spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

void FbxLoader::ProcessAnimationMatrices(BoneType* Bone, int AnimationNumber, int FrameNumber, FbxAMatrix ParentTransform){

    Bone->AnimationArray[AnimationNumber].KeyFrameArray[FrameNumber].GlobalTransform = Bone->AnimationArray[AnimationNumber].KeyFrameArray[FrameNumber].GlobalTransform * ParentTransform;

    int i;
    for (i = 0; i < Bone->ChildCount; i++){
        ProcessAnimationMatrices(Bone->Children[i], AnimationNumber, FrameNumber, Bone->AnimationArray[AnimationNumber].KeyFrameArray[FrameNumber].GlobalTransform);
    }
}

C-/C++-Quelltext

scaleMatrix = XMMatrixScaling(Animations[0].KeyFrameArray[i][FrameCount].Scale.x, Animations[0].KeyFrameArray[i][FrameCount].Scale.y, Animations[0].KeyFrameArray[i][FrameCount].Scale.z);

rotateMatrixX = XMMatrixRotationX(Animations[0].KeyFrameArray[i][FrameCount].Rotate.x / 180.0f * M_PI);
rotateMatrixY = XMMatrixRotationY(Animations[0].KeyFrameArray[i][FrameCount].Rotate.y / 180.0f * M_PI);
rotateMatrixZ = XMMatrixRotationZ(Animations[0].KeyFrameArray[i][FrameCount].Rotate.z / 180.0f * M_PI);


translationMatrix = XMMatrixTranslation(Animations[0].KeyFrameArray[i][FrameCount].Translate.x, Animations[0].KeyFrameArray[i][FrameCount].Translate.y, Animations[0].KeyFrameArray[i][FrameCount].Translate.z);

finalMatrix = XMMatrixMultiply(rotateMatrixX, rotateMatrixY);
finalMatrix = XMMatrixMultiply(finalMatrix, rotateMatrixZ);
finalMatrix = XMMatrixMultiply(finalMatrix, translationMatrix);
finalMatrix = XMMatrixMultiply(finalMatrix, scaleMatrix);
finalMatrix = XMMatrixMultiply(XMLoadFloat4x4(&BoneArray[i].GlobalBindposeInverse), finalMatrix);
finalMatrix = XMMatrixMultiply(finalMatrix, XMLoadFloat4x4(&BoneArray[i].ToRoot));
finalMatrix = XMMatrixTranspose(finalMatrix);

XMStoreFloat4x4(&(BoneMatrixArray[0].Bonematrix[i]), finalMatrix);

C-/C++-Quelltext

FbxAMatrix currentTransformOffset = Node->EvaluateGlobalTransform(currTime) * GetGeometryTransformation(Node);
FbxAMatrix GlobalTransform = currCluster->GetLink()->EvaluateGlobalTransform(currTime);
GlobalTransform = currentTransformOffset.Inverse()*GlobalTransform;

C-/C++-Quelltext

currCluster->GetTransformMatrix(transformMatrix);   // The transformation of the mesh at binding time
currCluster->GetTransformLinkMatrix(transformLinkMatrix);   // The transformation of the cluster(joint) at binding time from joint space to world space
globalBindposeInverseMatrix = transformLinkMatrix.Inverse() * transformMatrix * geometryTransform;

HLSL-Quelltext

cbuffer MatrixBuffer
{
    matrix globalTransformMatrix;
    matrix worldMatrix;
    matrix viewMatrix;
    matrix projectionMatrix;
    matrix transformMatrix;
    matrix rotateMatrix;
    float alpha;
    float3 padding;
};

cbuffer BoneMatrixBuffer{
    matrix BoneMatrix[128];
};



struct VertexInputType
{
    float4 position : POSITION;
    float4 normal : NORMAL;
    float2 tex : TEXCOORD;
    float4 boneWeights : BONEWEIGHT;
    uint4 boneIDs : BONEID;
};

struct PixelInputType
{
    float4 position : SV_POSITION;
    float3 normal : NORMAL;
    float4 worldPosition: WORLDPOSITION;
    float2 tex : TEXCOORD0;
    float alpha : ALPHA;
};


////////////////////////////////////////////////////////////////////////////////
// Vertex Shader
////////////////////////////////////////////////////////////////////////////////
PixelInputType AnimatedModelVertexShader(VertexInputType input)
{
    PixelInputType output;
    

    // Change the position vector to be 4 units for proper matrix calculations.
    input.position.w = 1.0f;
    input.normal.w=0.0f;

    float4 positions[4];

    
    positions[0]=mul(input.position,BoneMatrix[input.boneIDs.x]);
    positions[1]=mul(input.position,BoneMatrix[input.boneIDs.y]);
    positions[2]=mul(input.position,BoneMatrix[input.boneIDs.z]);
    positions[3]=mul(input.position,BoneMatrix[input.boneIDs.w]);
    

    if(input.boneWeights.x!=0.0f || input.boneWeights.y!=0.0f || input.boneWeights.z!=0.0f || input.boneWeights.w!=0.0f){
        output.position=input.boneWeights.x*positions[0] + input.boneWeights.y*positions[1] + input.boneWeights.z*positions[2] + input.boneWeights.w*positions[3];
    }
    else{
        output.position=input.position;
    }
    // Calculate the position of the vertex against the world, view, and projection matrices.
    
    output.position = mul(output.position, globalTransformMatrix);
    output.position = mul(output.position, transformMatrix);
    output.worldPosition=output.position;
    output.position = mul(output.position, viewMatrix);
    output.position = mul(output.position, projectionMatrix);
    
    output.alpha=alpha;

    output.normal=normalize(mul(input.normal,rotateMatrix).xyz);

    output.tex=input.tex;
    
    return output;
}