/*

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

This source file is part of OGRE

    (Object-oriented Graphics Rendering Engine)

For the latest info, see http://www.ogre3d.org/

Copyright (c) 2000-2014 Torus Knot Software Ltd

Permission is hereby granted, free of charge, to any person obtaining a copy

of this software and associated documentation files (the "Software"), to deal

in the Software without restriction, including without limitation the rights

to use, copy, modify, merge, publish, distribute, sublicense, and/or sell

copies of the Software, and to permit persons to whom the Software is

furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in

all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,

OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN

THE SOFTWARE.

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

*/

#include "OgreStableHeaders.h"

#include "OgreSkeletonManager.h"

#include "OgreEdgeListBuilder.h"

#include "OgreAnimation.h"

#include "OgreAnimationState.h"

#include "OgreAnimationTrack.h"

#include "OgreOptimisedUtil.h"

#include "OgreTangentSpaceCalc.h"

#include "OgreLodStrategyManager.h"

#include "OgrePixelCountLodStrategy.h"

#include "OgreDefaultHardwareBufferManager.h"

namespace Ogre {

    //-----------------------------------------------------------------------

    Mesh::Mesh(ResourceManager* creator, const String& name, ResourceHandle handle,

        const String& group, bool isManual, ManualResourceLoader* loader)

        : Resource(creator, name, handle, group, isManual, loader),

        mBoundRadius(0.0f),

        mBoneBoundingRadius(0.0f),

        mBoneAssignmentsOutOfDate(false),

        mHasManualLodLevel(false),

        mLodStrategy(LodStrategyManager::getSingleton().getDefaultStrategy()),

        mBufferManager(0),

        mVertexBufferUsage(HBU_GPU_ONLY),

        mIndexBufferUsage(HBU_GPU_ONLY),

        mVertexBufferShadowBuffer(false),

        mIndexBufferShadowBuffer(false),

        mPreparedForShadowVolumes(false),

        mEdgeListsBuilt(false),

        mAutoBuildEdgeLists(false), // will be set to true by serializers of 1.20 and below

        mSharedVertexDataAnimationType(VAT_NONE),

        mSharedVertexDataAnimationIncludesNormals(false),

        mAnimationTypesDirty(true),

        mPosesIncludeNormals(false),

        sharedVertexData(0)

    {

        // Init first (manual) lod

        MeshLodUsage lod;

        lod.userValue = 0; // User value not used for base LOD level

        lod.value = getLodStrategy()->getBaseValue();

        mMeshLodUsageList.push_back(lod);

    }

    //-----------------------------------------------------------------------

    Mesh::~Mesh()

    {

        if (!HardwareBufferManager::getSingletonPtr()) // LogManager might be also gone already

        {

            printf("ERROR: '%s' is being destroyed after HardwareBufferManager. This is a bug in user code.\n", mName.c_str());

            OgreAssertDbg(false,  "Mesh destroyed after HardwareBufferManager"); // assert in debug mode

            return; // try not to crash

        }

        // have to call this here reather than in Resource destructor

        // since calling virtual methods in base destructors causes crash

        unload();

    }

    //-----------------------------------------------------------------------

    HardwareBufferManagerBase* Mesh::getHardwareBufferManager()

    {

        return mBufferManager ? mBufferManager : HardwareBufferManager::getSingletonPtr();

    }

    //-----------------------------------------------------------------------

    SubMesh* Mesh::createSubMesh()

    {

        SubMesh* sub = OGRE_NEW SubMesh();

        sub->parent = this;

        mSubMeshList.push_back(sub);

        if (isLoaded())

            _dirtyState();

        return sub;

    }

    //-----------------------------------------------------------------------

    SubMesh* Mesh::createSubMesh(const String& name)

    {

        SubMesh *sub = createSubMesh();

        nameSubMesh(name, (ushort)mSubMeshList.size()-1);

        return sub ;

    }

    //-----------------------------------------------------------------------

    void Mesh::destroySubMesh(unsigned short index)

    {

        OgreAssert(index < mSubMeshList.size(), "");

        SubMeshList::iterator i = mSubMeshList.begin();

        std::advance(i, index);

        OGRE_DELETE *i;

        mSubMeshList.erase(i);

        // Fix up any name/index entries

        for(SubMeshNameMap::iterator ni = mSubMeshNameMap.begin(); ni != mSubMeshNameMap.end();)

        {

            if (ni->second == index)

            {

                SubMeshNameMap::iterator eraseIt = ni++;

                mSubMeshNameMap.erase(eraseIt);

            }

            else

            {

                // reduce indexes following

                if (ni->second > index)

                    ni->second = ni->second - 1;

                ++ni;

            }

        }

        // fix edge list data by simply recreating all edge lists

        if( mEdgeListsBuilt)

        {

            this->freeEdgeList();

            this->buildEdgeList();

        }

        if (isLoaded())

            _dirtyState();

    }

    //-----------------------------------------------------------------------

    void Mesh::destroySubMesh(const String& name)

    {

        unsigned short index = _getSubMeshIndex(name);

        destroySubMesh(index);

    }

    //---------------------------------------------------------------------

    void Mesh::nameSubMesh(const String& name, ushort index)

    {

        mSubMeshNameMap[name] = index ;

    }

    //---------------------------------------------------------------------

    void Mesh::unnameSubMesh(const String& name)

    {

        SubMeshNameMap::iterator i = mSubMeshNameMap.find(name);

        if (i != mSubMeshNameMap.end())

            mSubMeshNameMap.erase(i);

    }

    //-----------------------------------------------------------------------

    SubMesh* Mesh::getSubMesh(const String& name) const

    {

        ushort index = _getSubMeshIndex(name);

        return getSubMesh(index);

    }

    //-----------------------------------------------------------------------

    void Mesh::postLoadImpl(void)

    {

        // Prepare for shadow volumes?

        if (MeshManager::getSingleton().getPrepareAllMeshesForShadowVolumes())

        {

            if (mEdgeListsBuilt || mAutoBuildEdgeLists)

            {

                prepareForShadowVolume();

            }

            if (!mEdgeListsBuilt && mAutoBuildEdgeLists)

            {

                buildEdgeList();

            }

        }

#if !OGRE_NO_MESHLOD

        // The loading process accesses LOD usages directly, so

        // transformation of user values must occur after loading is complete.

        // Transform user LOD values (starting at index 1, no need to transform base value)

        for (auto& m : mMeshLodUsageList)

            m.value = mLodStrategy->transformUserValue(m.userValue);

        // Rewrite first value

        mMeshLodUsageList[0].value = mLodStrategy->getBaseValue();

#endif

    }

    //-----------------------------------------------------------------------

    void Mesh::prepareImpl()

    {

        // Load from specified 'name'

        if (getCreator()->getVerbose())

            LogManager::getSingleton().logMessage("Mesh: Loading "+mName+".");

        mFreshFromDisk =

            ResourceGroupManager::getSingleton().openResource(

                mName, mGroup, this);

        // fully prebuffer into host RAM

        mFreshFromDisk = DataStreamPtr(OGRE_NEW MemoryDataStream(mName,mFreshFromDisk));

    }

    //-----------------------------------------------------------------------

    void Mesh::unprepareImpl()

    {

        mFreshFromDisk.reset();

    }

    void Mesh::loadImpl()

    {

        // If the only copy is local on the stack, it will be cleaned

        // up reliably in case of exceptions, etc

        DataStreamPtr data(mFreshFromDisk);

        mFreshFromDisk.reset();

        if (!data) {

            OGRE_EXCEPT(Exception::ERR_INVALID_STATE,

                        "Data doesn't appear to have been prepared in " + mName,

                        "Mesh::loadImpl()");

        }

        String baseName, strExt;

        StringUtil::splitBaseFilename(mName, baseName, strExt);

        auto codec = Codec::getCodec(strExt);

        if (!codec)

            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "No codec found to load " + mName);

        codec->decode(data, this);

    }

    //-----------------------------------------------------------------------

    void Mesh::unloadImpl()

    {

        // Teardown submeshes

        for (auto & i : mSubMeshList)

        {

            OGRE_DELETE i;

        }

        if (sharedVertexData)

        {

            resetVertexData();

        }

        // Clear SubMesh lists

        mSubMeshList.clear();

        mSubMeshNameMap.clear();

        freeEdgeList();

#if !OGRE_NO_MESHLOD

        // Removes all LOD data

        removeLodLevels();

#endif

        mPreparedForShadowVolumes = false;

        // remove all poses & animations

        removeAllAnimations();

        removeAllPoses();

        // Clear bone assignments

        mBoneAssignments.clear();

        mBoneAssignmentsOutOfDate = false;

        // Removes reference to skeleton

        mSkeleton.reset();

    }

    //-----------------------------------------------------------------------

    void Mesh::reload(LoadingFlags flags)

    {

        bool wasPreparedForShadowVolumes = mPreparedForShadowVolumes;

        bool wasEdgeListsBuilt = mEdgeListsBuilt;

        bool wasAutoBuildEdgeLists = mAutoBuildEdgeLists;

        Resource::reload(flags);

        if(flags & LF_PRESERVE_STATE)

        {

            if(wasPreparedForShadowVolumes)

                prepareForShadowVolume();

            if(wasEdgeListsBuilt)

                buildEdgeList();

            setAutoBuildEdgeLists(wasAutoBuildEdgeLists);

        }

    }

    //-----------------------------------------------------------------------

    MeshPtr Mesh::clone(const String& newName, const String& newGroup)

    {

        // This is a bit like a copy constructor, but with the additional aspect of registering the clone with

        //  the MeshManager

        // New Mesh is assumed to be manually defined rather than loaded since you're cloning it for a reason

        String theGroup = newGroup.empty() ? this->getGroup() : newGroup;

        MeshPtr newMesh = MeshManager::getSingleton().createManual(newName, theGroup);

        if(!newMesh) // interception by collision handler

            return newMesh;

        newMesh->mBufferManager = mBufferManager;

        newMesh->mVertexBufferUsage = mVertexBufferUsage;

        newMesh->mIndexBufferUsage = mIndexBufferUsage;

        newMesh->mVertexBufferShadowBuffer = mVertexBufferShadowBuffer;

        newMesh->mIndexBufferShadowBuffer = mIndexBufferShadowBuffer;

        // Copy submeshes first

        for (auto *subi : mSubMeshList)

        {

            subi->clone("", newMesh.get());

        }

        // Copy shared geometry and index map, if any

        if (sharedVertexData)

        {

            newMesh->resetVertexData(sharedVertexData->clone(true, mBufferManager));

            newMesh->sharedBlendIndexToBoneIndexMap = sharedBlendIndexToBoneIndexMap;

        }

        // Copy submesh names

        newMesh->mSubMeshNameMap = mSubMeshNameMap ;

        // Copy any bone assignments

        newMesh->mBoneAssignments = mBoneAssignments;

        newMesh->mBoneAssignmentsOutOfDate = mBoneAssignmentsOutOfDate;

        // Copy bounds

        newMesh->mAABB = mAABB;

        newMesh->mBoundRadius = mBoundRadius;

        newMesh->mBoneBoundingRadius = mBoneBoundingRadius;

        newMesh->mAutoBuildEdgeLists = mAutoBuildEdgeLists;

        newMesh->mEdgeListsBuilt = mEdgeListsBuilt;

#if !OGRE_NO_MESHLOD

        newMesh->mHasManualLodLevel = mHasManualLodLevel;

        newMesh->mLodStrategy = mLodStrategy;

        newMesh->mMeshLodUsageList = mMeshLodUsageList;

#endif

        // Unreference edge lists, otherwise we'll delete the same lot twice, build on demand

        MeshLodUsageList::iterator lodOldi;

        lodOldi = mMeshLodUsageList.begin();

        for (auto& lodi : newMesh->mMeshLodUsageList) {

            MeshLodUsage& lod = *lodOldi;

            lodi.manualName = lod.manualName;

            lodi.userValue = lod.userValue;

            lodi.value = lod.value;

            if (lod.edgeData) {

                lodi.edgeData = lod.edgeData->clone();

            }

            ++lodOldi;

        }

        newMesh->mSkeleton = mSkeleton;

        // Keep prepared shadow volume info (buffers may already be prepared)

        newMesh->mPreparedForShadowVolumes = mPreparedForShadowVolumes;

        newMesh->mEdgeListsBuilt = mEdgeListsBuilt;

        // Clone vertex animation

        for (auto & i : mAnimationsList)

        {

            Animation *newAnim = i.second->clone(i.second->getName());

            newMesh->mAnimationsList[i.second->getName()] = newAnim;

        }

        // Clone pose list

        for (auto & i : mPoseList)

        {

            Pose* newPose = i->clone();

            newMesh->mPoseList.push_back(newPose);

        }

        newMesh->mSharedVertexDataAnimationType = mSharedVertexDataAnimationType;

        newMesh->mAnimationTypesDirty = true;

        newMesh->load();

        newMesh->touch();

        return newMesh;

    }

    //-----------------------------------------------------------------------

    const AxisAlignedBox& Mesh::getBounds(void) const

    {

        return mAABB;

    }

    //-----------------------------------------------------------------------

    void Mesh::_setBounds(const AxisAlignedBox& bounds, bool pad)

    {

        mAABB = bounds;

        mBoundRadius = Math::boundingRadiusFromAABB(mAABB);

        if( mAABB.isFinite() )

        {

            Vector3 max = mAABB.getMaximum();

            Vector3 min = mAABB.getMinimum();

            if (pad)

            {

                // Pad out the AABB a little, helps with most bounds tests

                Vector3 scaler = (max - min) * MeshManager::getSingleton().getBoundsPaddingFactor();

                mAABB.setExtents(min  - scaler, max + scaler);

                // Pad out the sphere a little too

                mBoundRadius = mBoundRadius + (mBoundRadius * MeshManager::getSingleton().getBoundsPaddingFactor());

            }

        }

    }

    //-----------------------------------------------------------------------

    void Mesh::_setBoundingSphereRadius(Real radius)

    {

        mBoundRadius = radius;

    }

    //-----------------------------------------------------------------------

    void Mesh::_setBoneBoundingRadius(Real radius)

    {

        mBoneBoundingRadius = radius;

    }

    //-----------------------------------------------------------------------

    void Mesh::_updateBoundsFromVertexBuffers(bool pad)

    {

        bool extendOnly = false; // First time we need full AABB of the given submesh, but on the second call just extend that one.

        if (sharedVertexData){

            _calcBoundsFromVertexBuffer(sharedVertexData, mAABB, mBoundRadius, extendOnly);

            extendOnly = true;

        }

        for (auto & i : mSubMeshList){

            if (i->vertexData){

                _calcBoundsFromVertexBuffer(i->vertexData, mAABB, mBoundRadius, extendOnly);

                extendOnly = true;

            }

        }

        if (pad)

        {

            Vector3 max = mAABB.getMaximum();

            Vector3 min = mAABB.getMinimum();

            // Pad out the AABB a little, helps with most bounds tests

            Vector3 scaler = (max - min) * MeshManager::getSingleton().getBoundsPaddingFactor();

            mAABB.setExtents(min - scaler, max + scaler);

            // Pad out the sphere a little too

            mBoundRadius = mBoundRadius + (mBoundRadius * MeshManager::getSingleton().getBoundsPaddingFactor());

        }

    }

    void Mesh::_calcBoundsFromVertexBuffer(VertexData* vertexData, AxisAlignedBox& outAABB, Real& outRadius, bool extendOnly /*= false*/)

    {

        if (vertexData->vertexCount == 0) {

            if (!extendOnly) {

                outAABB = AxisAlignedBox(Vector3::ZERO, Vector3::ZERO);

                outRadius = 0;

            }

            return;

        }

        const VertexElement* elemPos = vertexData->vertexDeclaration->findElementBySemantic(VES_POSITION);

        HardwareVertexBufferSharedPtr vbuf = vertexData->vertexBufferBinding->getBuffer(elemPos->getSource());

        HardwareBufferLockGuard vertexLock(vbuf, HardwareBuffer::HBL_READ_ONLY);

        unsigned char* vertex = static_cast<unsigned char*>(vertexLock.pData);

        if (!extendOnly){

            // init values

            outRadius = 0;

            float* pFloat;

            elemPos->baseVertexPointerToElement(vertex, &pFloat);

            Vector3 basePos(pFloat[0], pFloat[1], pFloat[2]);

            outAABB.setExtents(basePos, basePos);

        }

        size_t vSize = vbuf->getVertexSize();

        unsigned char* vEnd = vertex + vertexData->vertexCount * vSize;

        Real radiusSqr = outRadius * outRadius;

        // Loop through all vertices.

        for (; vertex < vEnd; vertex += vSize) {

            float* pFloat;

            elemPos->baseVertexPointerToElement(vertex, &pFloat);

            Vector3 pos(pFloat[0], pFloat[1], pFloat[2]);

            outAABB.getMinimum().makeFloor(pos);

            outAABB.getMaximum().makeCeil(pos);

            radiusSqr = std::max<Real>(radiusSqr, pos.squaredLength());

        }

        outRadius = std::sqrt(radiusSqr);

    }

    //-----------------------------------------------------------------------

    void Mesh::setSkeletonName(const String& skelName)

    {

        if (skelName != getSkeletonName())

        {

            if (skelName.empty())

            {

                // No skeleton

                mSkeleton.reset();

            }

            else

            {

                // Load skeleton

                try {

                    mSkeleton = static_pointer_cast<Skeleton>(SkeletonManager::getSingleton().load(skelName, mGroup));

                }

                catch (...)

                {

                    mSkeleton.reset();

                    // Log this error

                    String msg = "Unable to load skeleton '";

                    msg += skelName + "' for Mesh '" + mName + "'. This Mesh will not be animated.";

                    LogManager::getSingleton().logError(msg);

                }

            }

            if (isLoaded())

                _dirtyState();

        }

    }

    //-----------------------------------------------------------------------

    void Mesh::addBoneAssignment(const VertexBoneAssignment& vertBoneAssign)

    {

        mBoneAssignments.emplace(vertBoneAssign.vertexIndex, vertBoneAssign);

        mBoneAssignmentsOutOfDate = true;

    }

    //-----------------------------------------------------------------------

    void Mesh::clearBoneAssignments(void)

    {

        mBoneAssignments.clear();

        mBoneAssignmentsOutOfDate = true;

    }

    //-----------------------------------------------------------------------

    void Mesh::_initAnimationState(AnimationStateSet* animSet)

    {

        // Animation states for skeletal animation

        if (mSkeleton)

        {

            // Delegate to Skeleton

            mSkeleton->_initAnimationState(animSet);

            // Take the opportunity to update the compiled bone assignments

            _updateCompiledBoneAssignments();

        }

        // Animation states for vertex animation

        for (auto & i : mAnimationsList)

        {

            // Only create a new animation state if it doesn't exist

            // We can have the same named animation in both skeletal and vertex

            // with a shared animation state affecting both, for combined effects

            // The animations should be the same length if this feature is used!

            if (!animSet->hasAnimationState(i.second->getName()))

            {

                animSet->createAnimationState(i.second->getName(), 0.0,

                    i.second->getLength());

            }

        }

    }

    //---------------------------------------------------------------------

    void Mesh::_refreshAnimationState(AnimationStateSet* animSet)

    {

        if (mSkeleton)

        {

            mSkeleton->_refreshAnimationState(animSet);

        }

        // Merge in any new vertex animations

        for (auto& i : mAnimationsList)

        {

            // Create animation at time index 0, default params mean this has weight 1 and is disabled

            auto anim = i.second;

            const String& animName = anim->getName();

            if (!animSet->hasAnimationState(animName))

            {

                animSet->createAnimationState(animName, 0.0, anim->getLength());

            }

            else

            {

                // Update length incase changed

                AnimationState* animState = animSet->getAnimationState(animName);

                animState->setLength(anim->getLength());

                animState->setTimePosition(std::min(anim->getLength(), animState->getTimePosition()));

            }

        }

    }

    //-----------------------------------------------------------------------

    void Mesh::_updateCompiledBoneAssignments(void)

    {

        if (mBoneAssignmentsOutOfDate)

            _compileBoneAssignments();

        for (auto *m : mSubMeshList)

        {

            if (m->mBoneAssignmentsOutOfDate)

            {

                m->_compileBoneAssignments();

            }

        }

    }

    //-----------------------------------------------------------------------

    typedef std::multimap<Real, Mesh::VertexBoneAssignmentList::iterator> WeightIteratorMap;

    unsigned short Mesh::_rationaliseBoneAssignments(size_t vertexCount, Mesh::VertexBoneAssignmentList& assignments)

    {

        // Iterate through, finding the largest # bones per vertex

        unsigned short maxBones = 0;

        bool existsNonSkinnedVertices = false;

        VertexBoneAssignmentList::iterator i;

        for (size_t v = 0; v < vertexCount; ++v)

        {

            // Get number of entries for this vertex

            short currBones = static_cast<unsigned short>(assignments.count(v));

            if (currBones <= 0)

                existsNonSkinnedVertices = true;

            // Deal with max bones update

            // (note this will record maxBones even if they exceed limit)

            if (maxBones < currBones)

                maxBones = currBones;

            // does the number of bone assignments exceed limit?

            if (currBones > OGRE_MAX_BLEND_WEIGHTS)

            {

                // To many bone assignments on this vertex

                // Find the start & end (end is in iterator terms ie exclusive)

                std::pair<VertexBoneAssignmentList::iterator, VertexBoneAssignmentList::iterator> range;

                // map to sort by weight

                WeightIteratorMap weightToAssignmentMap;

                range = assignments.equal_range(v);

                // Add all the assignments to map

                for (i = range.first; i != range.second; ++i)

                {

                    // insert value weight->iterator

                    weightToAssignmentMap.emplace(i->second.weight, i);

                }

                // Reverse iterate over weight map, remove lowest n

                unsigned short numToRemove = currBones - OGRE_MAX_BLEND_WEIGHTS;

                WeightIteratorMap::iterator remIt = weightToAssignmentMap.begin();

                while (numToRemove--)

                {

                    // Erase this one

                    assignments.erase(remIt->second);

                    ++remIt;

                }

            } // if (currBones > OGRE_MAX_BLEND_WEIGHTS)

            // Make sure the weights are normalised

            // Do this irrespective of whether we had to remove assignments or not

            //   since it gives us a guarantee that weights are normalised

            //  We assume this, so it's a good idea since some modellers may not

            std::pair<VertexBoneAssignmentList::iterator, VertexBoneAssignmentList::iterator> normalise_range = assignments.equal_range(v);

            Real totalWeight = 0;

            // Find total first

            for (i = normalise_range.first; i != normalise_range.second; ++i)

            {

                totalWeight += i->second.weight;

            }

            // Now normalise if total weight is outside tolerance

            if (!Math::RealEqual(totalWeight, 1.0f))

            {

                for (i = normalise_range.first; i != normalise_range.second; ++i)

                {

                    i->second.weight = i->second.weight / totalWeight;

                }

            }

        }

        if (maxBones > OGRE_MAX_BLEND_WEIGHTS)

        {

            // Warn that we've reduced bone assignments

            LogManager::getSingleton().logWarning("the mesh '" + mName + "' "

                "includes vertices with more than " +

                StringConverter::toString(OGRE_MAX_BLEND_WEIGHTS) + " bone assignments. "

                "The lowest weighted assignments beyond this limit have been removed, so "

                "your animation may look slightly different. To eliminate this, reduce "

                "the number of bone assignments per vertex on your mesh to " +

                StringConverter::toString(OGRE_MAX_BLEND_WEIGHTS) + ".");

            // we've adjusted them down to the max

            maxBones = OGRE_MAX_BLEND_WEIGHTS;

        }

        if (existsNonSkinnedVertices)

        {

            // Warn that we've non-skinned vertices

            LogManager::getSingleton().logWarning("the mesh '" + mName + "' "

                "includes vertices without bone assignments. Those vertices will "

                "transform to wrong position when skeletal animation enabled. "

                "To eliminate this, assign at least one bone assignment per vertex "

                "on your mesh.");

        }

        return maxBones;

    }

    //-----------------------------------------------------------------------

    void  Mesh::_compileBoneAssignments(void)

    {

        if (sharedVertexData)

        {

            unsigned short maxBones = _rationaliseBoneAssignments(sharedVertexData->vertexCount, mBoneAssignments);

            if (maxBones != 0)

            {

                compileBoneAssignments(mBoneAssignments, maxBones,

                    sharedBlendIndexToBoneIndexMap, sharedVertexData);

            }

        }

        mBoneAssignmentsOutOfDate = false;

    }

    //---------------------------------------------------------------------

    void Mesh::buildIndexMap(const VertexBoneAssignmentList& boneAssignments,

        IndexMap& boneIndexToBlendIndexMap, IndexMap& blendIndexToBoneIndexMap)

    {

        if (boneAssignments.empty())

        {

            // Just in case

            boneIndexToBlendIndexMap.clear();

            blendIndexToBoneIndexMap.clear();

            return;

        }

        typedef std::set<unsigned short> BoneIndexSet;

        BoneIndexSet usedBoneIndices;

        // Collect actually used bones

        for (auto& itVBA : boneAssignments)

        {

            usedBoneIndices.insert(itVBA.second.boneIndex);

        }

        // Allocate space for index map

        blendIndexToBoneIndexMap.resize(usedBoneIndices.size());

        boneIndexToBlendIndexMap.resize(*usedBoneIndices.rbegin() + 1);

        // Make index map between bone index and blend index

        unsigned short blendIndex = 0;

        for (auto& itBoneIndex : usedBoneIndices)

        {

            boneIndexToBlendIndexMap[itBoneIndex] = blendIndex;

            blendIndexToBoneIndexMap[blendIndex] = itBoneIndex;

            ++blendIndex;

        }

    }

    //---------------------------------------------------------------------

    void Mesh::compileBoneAssignments(

        const VertexBoneAssignmentList& boneAssignments,

        unsigned short numBlendWeightsPerVertex,

        IndexMap& blendIndexToBoneIndexMap,

        VertexData* targetVertexData)

    {

        // Create or reuse blend weight / indexes buffer

        // Indices are always a UBYTE4 no matter how many weights per vertex

        VertexDeclaration* decl = targetVertexData->vertexDeclaration;

        VertexBufferBinding* bind = targetVertexData->vertexBufferBinding;

        unsigned short bindIndex;

        // Build the index map brute-force. It's possible to store the index map

        // in .mesh, but maybe trivial.

        IndexMap boneIndexToBlendIndexMap;

        buildIndexMap(boneAssignments, boneIndexToBlendIndexMap, blendIndexToBoneIndexMap);

        const VertexElement* testElem =

            decl->findElementBySemantic(VES_BLEND_INDICES);

        if (testElem)

        {

            // Already have a buffer, unset it & delete elements

            bindIndex = testElem->getSource();

            // unset will cause deletion of buffer

            bind->unsetBinding(bindIndex);

            decl->removeElement(VES_BLEND_INDICES);

            decl->removeElement(VES_BLEND_WEIGHTS);

        }

        else

        {

            // Get new binding

            bindIndex = bind->getNextIndex();

        }

        // type of Weights is settable on the MeshManager.

        VertexElementType weightsBaseType = MeshManager::getSingleton().getBlendWeightsBaseElementType();

        VertexElementType weightsVertexElemType = VertexElement::multiplyTypeCount( weightsBaseType, numBlendWeightsPerVertex );

        HardwareVertexBufferSharedPtr vbuf = getHardwareBufferManager()->createVertexBuffer(

            sizeof( unsigned char ) * 4 + VertexElement::getTypeSize( weightsVertexElemType ),

                targetVertexData->vertexCount,

                HardwareBuffer::HBU_STATIC_WRITE_ONLY,

                true // use shadow buffer

                );

        // bind new buffer

        bind->setBinding(bindIndex, vbuf);

        const VertexElement *pIdxElem, *pWeightElem;

        // add new vertex elements

        // Note, insert directly after all elements using the same source as

        // position to abide by pre-Dx9 format restrictions

        const VertexElement* firstElem = decl->getElement(0);

        if(firstElem->getSemantic() == VES_POSITION)

        {

            unsigned short insertPoint = 1;

            while (insertPoint < decl->getElementCount() &&

                decl->getElement(insertPoint)->getSource() == firstElem->getSource())

            {

                ++insertPoint;

            }

            const VertexElement& idxElem =

                decl->insertElement(insertPoint, bindIndex, 0, VET_UBYTE4, VES_BLEND_INDICES);

            const VertexElement& wtElem =

                decl->insertElement(insertPoint+1, bindIndex, sizeof(unsigned char)*4, weightsVertexElemType, VES_BLEND_WEIGHTS);

            pIdxElem = &idxElem;

            pWeightElem = &wtElem;

        }

        else

        {

            // Position is not the first semantic, therefore this declaration is

            // not pre-Dx9 compatible anyway, so just tack it on the end

            const VertexElement& idxElem =

                decl->addElement(bindIndex, 0, VET_UBYTE4, VES_BLEND_INDICES);

            const VertexElement& wtElem =

                decl->addElement(bindIndex, sizeof(unsigned char)*4, weightsVertexElemType, VES_BLEND_WEIGHTS );

            pIdxElem = &idxElem;

            pWeightElem = &wtElem;

        }

        unsigned int maxIntWt = 0;

        // keeping a switch out of the loop

        switch ( weightsBaseType )

        {

            default:

              OgreAssert(false, "Invalid BlendWeightsBaseElementType");

              break;

            case VET_FLOAT1:

                break;

            case VET_UBYTE4_NORM:

                maxIntWt = 0xff;

                break;

            case VET_USHORT2_NORM:

                maxIntWt = 0xffff;

                break;

            case VET_SHORT2_NORM:

                maxIntWt = 0x7fff;

                break;

        }

        // Assign data

        size_t v;

        VertexBoneAssignmentList::const_iterator i, iend;

        i = boneAssignments.begin();

        iend = boneAssignments.end();

        HardwareBufferLockGuard vertexLock(vbuf, HardwareBuffer::HBL_DISCARD);

        unsigned char *pBase = static_cast<unsigned char*>(vertexLock.pData);

        // Iterate by vertex

        for (v = 0; v < targetVertexData->vertexCount; ++v)

        {

            // collect the indices/weights in these arrays

            unsigned char indices[ 4 ] = { 0, 0, 0, 0 };

            float weights[ 4 ] = { 1.0f, 0.0f, 0.0f, 0.0f };

            for (unsigned short bone = 0; bone < numBlendWeightsPerVertex; ++bone)

            {

                // Do we still have data for this vertex?

                if (i != iend && i->second.vertexIndex == v)

                {

                    // If so, grab weight and index

                    weights[ bone ] = i->second.weight;

                    indices[ bone ] = static_cast<unsigned char>( boneIndexToBlendIndexMap[ i->second.boneIndex ] );

                    ++i;

                }

            }

            // if weights are integers,

            if ( weightsBaseType != VET_FLOAT1 )

            {

                // pack the float weights into shorts/bytes

                unsigned int intWeights[ 4 ];

                unsigned int sum = 0;

                const unsigned int wtScale = maxIntWt;  // this value corresponds to a weight of 1.0

                for ( int ii = 0; ii < 4; ++ii )

                {

                    unsigned int bw = static_cast<unsigned int>( weights[ ii ] * wtScale );

                    intWeights[ ii ] = bw;

                    sum += bw;

                }

                // if the sum doesn't add up due to roundoff error, we need to adjust the intWeights so that the sum is wtScale

                if ( sum != maxIntWt )

                {

                    // find the largest weight (it isn't necessarily the first one...)

                    int iMaxWeight = 0;

                    unsigned int maxWeight = 0;

                    for ( int ii = 0; ii < 4; ++ii )

                    {

                        unsigned int bw = intWeights[ ii ];

                        if ( bw > maxWeight )

                        {

                            iMaxWeight = ii;

                            maxWeight = bw;

                        }

                    }

                    // Adjust the largest weight to make sure the sum is correct.

                    // The idea is that changing the largest weight will have the smallest effect

                    // on the ratio of weights.  This works best when there is one dominant weight,

                    // and worst when 2 or more weights are similar in magnitude.

                    // A better method could be used to reduce the quantization error, but this is

                    // being done at run-time so it needs to be quick.

                    intWeights[ iMaxWeight ] += maxIntWt - sum;

                }

                // now write the weights

                if ( weightsBaseType == VET_UBYTE4_NORM )

                {

                    // write out the weights as bytes

                    unsigned char* pWeight;

                    pWeightElem->baseVertexPointerToElement( pBase, &pWeight );

                    // NOTE: always writes out 4 regardless of numBlendWeightsPerVertex

                    for (unsigned int intWeight : intWeights)

                    {

                        *pWeight++ = static_cast<unsigned char>( intWeight );

                    }

                }

                else

                {

                    // write out the weights as shorts

                    unsigned short* pWeight;

                    pWeightElem->baseVertexPointerToElement( pBase, &pWeight );

                    for ( int ii = 0; ii < numBlendWeightsPerVertex; ++ii )

                    {

                        *pWeight++ = static_cast<unsigned short>( intWeights[ ii ] );

                    }

                }

            }

            else

            {