한 골격에서 다른 골격으로 애니메이션을 프로그래밍 방식으로 재 타겟팅하는 방법은 무엇입니까?

한 골격이 다른 골격에서 올바르게 보이도록 설계된 애니메이션을 전송하는 코드를 작성하려고합니다. 소스 애니메이션은 루트에서의 변환을 제외하고 회전으로 만 구성됩니다 ( CMU 모션 캡처 데이터베이스 의 mocap 애니메이션 ). 많은 3D 응용 프로그램 (예 : Maya)에는이 기능이 내장되어 있지만 게임용으로 (아주 간단한) 버전을 작성하려고합니다.

뼈 매핑에 대한 몇 가지 작업을 수행했으며 골격이 계층 적으로 유사하기 때문에 (biped) 척추 이외의 모든 것에 대해 1 : 1 뼈 매핑을 수행 할 수 있습니다 (나중에 작동 할 수 있음). 그러나 문제는 기본 스켈레톤 / 바인드 포즈가 다르고 뼈가 다른 스케일 (더 짧거나 길다)이므로 회전을 똑바로 복사하면 매우 이상하게 보입니다.

나는 lorancou의 솔루션과 비슷한 많은 것들을 시도하지 않았다 (즉, 애니메이션의 각 프레임에 뼈 특정 승수를 곱하는 것). 누구든지 이와 같은 자료 (종이, 소스 코드 등)에 대한 자료가 있다면 실제로 도움이 될 것입니다.

문제는 수치 적 안정성 중 하나였습니다. 2 개월 동안이 작업에 대해 약 30 시간의 작업이있었습니다. 회전 행렬을 대상 코드에 꽂기 전에 직교 정규화하면 소스 곱하기의 간단한 솔루션 * inverse (target)이 완벽하게 작동했습니다. 물론 리 타겟팅하는 것보다 더 많은 것이 있습니다 (특히 골격의 다른 모양, 즉 어깨 너비 등을 고려). 궁금한 사람이 있으면 간단하고 깔끔한 방법으로 사용하는 코드는 다음과 같습니다.

    public static SkeletalAnimation retarget(SkeletalAnimation animation, Skeleton target, string boneMapFilePath)
    {
        if(animation == null) throw new ArgumentNullException("animation");
        if(target == null) throw new ArgumentNullException("target");

        Skeleton source = animation.skeleton;
        if(source == target) return animation;

        int nSourceBones = source.count;
        int nTargetBones = target.count;
        int nFrames = animation.nFrames; 
        AnimationData[] sourceData = animation.data;
        Matrix[] sourceTransforms = new Matrix[nSourceBones];
        Matrix[] targetTransforms = new Matrix[nTargetBones];
        AnimationData[] temp = new AnimationData[nSourceBones];
        AnimationData[] targetData = new AnimationData[nTargetBones * nFrames];

        // Get a map where map[iTargetBone] = iSourceBone or -1 if no such bone
        int[] map = parseBoneMap(source, target, boneMapFilePath);

        for(int iFrame = 0; iFrame < nFrames; iFrame++)
        {
            int sourceBase = iFrame * nSourceBones;
            int targetBase = iFrame * nTargetBones;

            // Copy the root translation and rotation directly over
            AnimationData rootData = targetData[targetBase] = sourceData[sourceBase];

            // Get the source pose for this frame
            Array.Copy(sourceData, sourceBase, temp, 0, nSourceBones);
            source.getAbsoluteTransforms(temp, sourceTransforms);

            // Rotate target bones to face that direction
            Matrix m;
            AnimationData.toMatrix(ref rootData, out m);
            Matrix.Multiply(ref m, ref target.relatives[0], out targetTransforms[0]);
            for(int iTargetBone = 1; iTargetBone < nTargetBones; iTargetBone++)
            {
                int targetIndex = targetBase + iTargetBone;
                int iTargetParent = target.hierarchy[iTargetBone];
                int iSourceBone = map[iTargetBone];
                if(iSourceBone <= 0)
                {
                    targetData[targetIndex].rotation = Quaternion.Identity;
                    Matrix.Multiply(ref target.relatives[iTargetBone], ref targetTransforms[iTargetParent], out targetTransforms[iTargetBone]);
                }
                else
                {
                    Matrix currentTransform, inverseCurrent, sourceTransform, final, m2;
                    Quaternion rot;

                    // Get the "current" transformation (transform that would be applied if rot is Quaternion.Identity)
                    Matrix.Multiply(ref target.relatives[iTargetBone], ref targetTransforms[iTargetParent], out currentTransform);
                    Math2.orthoNormalize(ref currentTransform);
                    Matrix.Invert(ref currentTransform, out inverseCurrent);
                    Math2.orthoNormalize(ref inverseCurrent);

                    // Get the final rotation
                    Math2.orthoNormalize(ref sourceTransforms[iSourceBone], out sourceTransform);
                    Matrix.Multiply(ref sourceTransform, ref inverseCurrent, out final);
                    Math2.orthoNormalize(ref final);
                    Quaternion.RotationMatrix(ref final, out rot);

                    // Calculate this bone's absolute position to use as next bone's parent
                    targetData[targetIndex].rotation = rot;
                    Matrix.RotationQuaternion(ref rot, out m);
                    Matrix.Multiply(ref m, ref target.relatives[iTargetBone], out m2);
                    Matrix.Multiply(ref m2, ref targetTransforms[iTargetParent], out targetTransforms[iTargetBone]);
                }
            }
        }

        return new SkeletalAnimation(target, targetData, animation.fps, nFrames);
    }

가능한 가장 쉬운 방법은 원래 바인드 포즈를 새 골격과 일치시키는 것입니다 (새로운 골격이 아직 스키닝되지 않은 경우).

그렇게 할 수 없다면, 여기 시도해 볼 수있는 것이 있습니다. 이것은 직관 일뿐입니다. 아마도 많은 것들을 간과하고 있지만, 빛을 찾는 데 도움이 될 것입니다. 각 뼈에 대해 :

• "오래된"바인드 포즈에는 부모 뼈 와 비교하여이 뼈 의 상대적 회전 을 설명하는 쿼터니언 이 있습니다. 찾는 방법에 대한 힌트 는 다음과 같습니다 . 그것을 호출하자 .q_old

• 상사. "새로운"바인드 포즈를 위해 호출 해 봅시다 q_new.

• 여기에 설명 된대로 "새"바인드 포즈에서 "오래된"빈 포즈까지의 상대 회전을 찾을 수 있습니다 . 그렇습니다 q_new_to_old = inverse(q_new) * q_old.

• 그런 다음 하나의 애니메이션 키에 해당 뼈를 "이전"바인드 포즈에서 애니메이션 포즈로 변환하는 하나의 쿼터니언이 있습니다. 이것을 1이라고합시다 q_anim.

q_anim직접 사용하는 대신을 사용하십시오 q_new_to_old * q_anim. 애니메이션을 적용하기 전에 바인드 포즈 간의 방향 차이를 "취소"해야합니다.

트릭을 할 수 있습니다.

편집하다

위의 코드는 여기에 설명 된 논리를 따르는 것처럼 보이지만 반전되었습니다. 이것을하는 대신 :

multipliers[iSourceBone] = Quaternion.Invert(sourceBoneRot) * targetBoneRot;

당신은 그것을 시도 할 수 있습니다 :

multipliers[iSourceBone] = Quaternion.Invert(targetBoneRot) * sourceBoneRot;

소스 애니메이션을 적용하기 전에 동일한 최종 방향을 얻으려면 대상에서 소스로 변환해야한다고 생각합니다.