Method build

OgreMain/src/Animation/OgreSkeletonAnimationDef.cpp:66–220

-----------------------------------------------------------------------------------

    }
    //-----------------------------------------------------------------------------------
    void SkeletonAnimationDef::build( const v1::Skeleton *skeleton, const v1::Animation *animation,
                                      Real frameRate )
    {
        mOriginalFrameRate = frameRate;
        mNumFrames = animation->getLength() * frameRate;

        // Converts Bone Index -> Slot Index
        const SkeletonDef::BoneToSlotVec &boneToSlot = mSkeletonDef->getBoneToSlot();
        const SkeletonDef::IndexToIndexMap &slotToBone = mSkeletonDef->getSlotToBone();

        // 1st Pass: Count the number of keyframes, so we know how
        // much memory to allocate, as we don't listen for resizes.
        // We also build a list of unique keyframe timestamps per block
        //(i.e. merge the keyframes from two bones that the same block)
        v1::Animation::OldNodeTrackIterator itor = animation->getOldNodeTrackIterator();
        {
            // Count the number of blocks needed by counting the number of unique keyframes per block.
            // i.e. When ARRAY_PACKED_REALS = 4; if 2 bones are in the same block and have the same
            // keyframe time value, we'll need 4 slots (aka. 1 block). If those 2 bones have two
            // different time values, we'll need 8 slots.
            TimestampVec emptyVec;
            TimestampsPerBlock timestampsByBlock;

            while( itor.hasMoreElements() )
            {
                size_t boneIdx = itor.peekNextKey();
                v1::OldNodeAnimationTrack *track = itor.getNext();

                if( track->getNumKeyFrames() > 0 )
                {
                    // Old V1 skeletons would wrap around to keyframe[0] if keyframe[n-1] did not
                    // cover until the end of the animation. We need to mimic that behavior.
                    // (See v1::AnimationTrack::getKeyFramesAtTime)
                    const bool extraKeyFrameAtEnd =
                        track->getKeyFrame( track->getNumKeyFrames() - 1u )->getTime() <
                        animation->getLength();

                    uint32 slotIdx = boneToSlot[boneIdx];
                    uint32 blockIdx = SkeletonDef::slotToBlockIdx( slotIdx );

                    TimestampsPerBlock::iterator itKeyframes = timestampsByBlock.find( blockIdx );
                    if( itKeyframes == timestampsByBlock.end() )
                    {
                        itKeyframes = timestampsByBlock.emplace( (size_t)blockIdx, emptyVec ).first;
                    }

                    itKeyframes->second.reserve( track->getNumKeyFrames() + (size_t)extraKeyFrameAtEnd );

                    for( size_t i = 0; i < track->getNumKeyFrames(); ++i )
                    {
                        Real timestamp = track->getKeyFrame( (uint16)i )->getTime();
                        TimestampVec::iterator it = std::lower_bound(
                            itKeyframes->second.begin(), itKeyframes->second.end(), timestamp );
                        if( it == itKeyframes->second.end() || *it != timestamp )
                            itKeyframes->second.insert( it, timestamp );
                    }

                    if( extraKeyFrameAtEnd )