_ZNK4Ogre10ConfigFile20getSettingsBySectionEv:
   97|  1.08k|        const SettingsBySection_& getSettingsBySection() const {
   98|  1.08k|            return mSettings;
   99|  1.08k|        }

_ZN4Ogre28DefaultHardwareBufferManagerC2Ev:
   88|      1|        DefaultHardwareBufferManager() : mImpl(new DefaultHardwareBufferManagerBase()) {}
_ZN4Ogre28DefaultHardwareBufferManager18createVertexBufferEmmhb:
   99|  12.3k|        {
  100|  12.3k|            return mImpl->createVertexBuffer(vertexSize, numVerts, usage, useShadowBuffer);
  101|  12.3k|        }
_ZN4Ogre28DefaultHardwareBufferManager17createIndexBufferENS_19HardwareIndexBuffer9IndexTypeEmhb:
  106|  98.0k|        {
  107|  98.0k|            return mImpl->createIndexBuffer(itype, numIndexes, usage, useShadowBuffer);
  108|  98.0k|        }

_ZN4Ogre8EdgeData8TriangleC2Ev:
   71|  26.3k|            Triangle() :indexSet(0), vertexSet(0) {}

_ZN4Ogre8KeyFrameD2Ev:
   62|  5.92k|        virtual ~KeyFrame() {}
_ZNK4Ogre8KeyFrame7getTimeEv:
   65|  38.9k|        Real getTime(void) const { return mTime; }
_ZN4Ogre19VertexMorphKeyFrameD2Ev:
  158|  2.85k|        ~VertexMorphKeyFrame() {}
_ZN4Ogre18VertexPoseKeyFrameD2Ev:
  187|  2.01k|        ~VertexPoseKeyFrame() {}
_ZN4Ogre18VertexPoseKeyFrame7PoseRefC2Etf:
  208|  1.56k|            PoseRef(ushort p, float i) : poseIndex(p), influence(i) {}

_ZNK4Ogre11LodStrategy7getNameEv:
  103|      8|        const String& getName() const { return mName; }

_ZN4Ogre13OptimisedUtilC2Ev:
   64|      2|        OptimisedUtil(void) {}

_ZNK4Ogre9SharedPtrINS_4MeshEEptEv:
   63|  5.79k|        T* operator->() const { return shared_ptr<T>::operator->(); }
_ZN4Ogre9SharedPtrINS_10DataStreamEEC2INS_16MemoryDataStreamEEEPT_:
   50|  8.64k|        explicit SharedPtr(Y* ptr) : shared_ptr<T>(ptr) {}
_ZN4Ogre9SharedPtrINS_8ResourceEEC2INS_4MeshEEERKNS0_IT_EE:
   55|  5.79k|        SharedPtr(const SharedPtr<Y>& r) : shared_ptr<T>(r) {}
_ZNK4Ogre9SharedPtrINS_8SkeletonEEptEv:
   63|  1.32k|        T* operator->() const { return shared_ptr<T>::operator->(); }
_ZN4Ogre9SharedPtrINS_8ResourceEEC2INS_8SkeletonEEERKNS0_IT_EE:
   55|  1.32k|        SharedPtr(const SharedPtr<Y>& r) : shared_ptr<T>(r) {}

_ZN4Ogre16StreamSerialiser5ChunkC2Ev:
  105|  1.67k|            Chunk() : id(0), version(1), length(0), offset(0) {}
_ZN4Ogre16StreamSerialiser4readIjEEvPT_m:
  301|  5.74k|        {
  302|  5.74k|            readData(pT, sizeof(T), count);
  303|  5.74k|        }
_ZN4Ogre16StreamSerialiser4readItEEvPT_m:
  301|  1.51k|        {
  302|  1.51k|            readData(pT, sizeof(T), count);
  303|  1.51k|        }
_ZN4Ogre16StreamSerialiser4readIcEEvPT_m:
  301|    351|        {
  302|    351|            readData(pT, sizeof(T), count);
  303|    351|        }
_ZN4Ogre16StreamSerialiser13readConvertedIfdEEvPT_T0_m:
  372|    642|        {
  373|    642|            std::vector<U> tmp(count);
  374|    642|            readData(tmp.data(), sizeof(U), count);
  375|    642|            for (auto& e : tmp)
  ------------------
  |  Branch (375:26): [True: 1.54k, False: 642]
  ------------------
  376|  1.54k|                *dst++ = static_cast<T>(e);
  377|    642|        }

_ZN4Ogre6VectorILi3EfEC2Ev:
  285|  1.09k|        Vector() {}
_ZN4Ogre10VectorBaseILi3EfEC2Ev:
  130|  1.09k|        VectorBase() {}
_ZN4Ogre6VectorILi4EfEC2Ev:
  285|  1.09k|        Vector() {}
_ZN4Ogre10VectorBaseILi4EfEC2Ev:
  259|  1.09k|        VectorBase() {}

_ZN4Ogre13AlignedMemory8allocateEmm:
   59|   111k|    {
   60|   111k|        assert(0 < alignment && alignment <= 128 && Bitwise::isPO2(alignment));
   61|       |
   62|   111k|        unsigned char* p = new unsigned char[size + alignment];
   63|   111k|        size_t offset = alignment - (size_t(p) & (alignment-1));
   64|       |
   65|   111k|        unsigned char* result = p + offset;
   66|   111k|        result[-1] = (unsigned char)offset;
   67|       |
   68|   111k|        return result;
   69|   111k|    }
_ZN4Ogre13AlignedMemory8allocateEm:
   72|   111k|    {
   73|       |        return allocate(size, OGRE_SIMD_ALIGNMENT);
   74|   111k|    }
_ZN4Ogre13AlignedMemory10deallocateEPv:
   77|   111k|    {
   78|   111k|        if (p)
  ------------------
  |  Branch (78:13): [True: 111k, False: 0]
  ------------------
   79|   111k|        {
   80|   111k|            unsigned char* mem = (unsigned char*)p;
   81|   111k|            mem = mem - mem[-1];
   82|   111k|            delete [] mem;
   83|   111k|        }
   84|   111k|    }

_ZN4Ogre9AnimationC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEf:
   39|  5.46k|        : mName(name)
   40|  5.46k|        , mLength(length)
   41|  5.46k|        , mInterpolationMode(msDefaultInterpolationMode)
   42|  5.46k|        , mRotationInterpolationMode(msDefaultRotationInterpolationMode)
   43|  5.46k|        , mKeyFrameTimesDirty(false)
   44|  5.46k|        , mUseBaseKeyFrame(false)
   45|  5.46k|        , mBaseKeyFrameTime(0.0f)
   46|  5.46k|        , mBaseKeyFrameAnimationName(BLANKSTRING)
   47|  5.46k|        , mContainer(0)
   48|  5.46k|    {
   49|  5.46k|    }
_ZN4Ogre9AnimationD2Ev:
   52|  5.46k|    {
   53|  5.46k|        destroyAllTracks();
   54|  5.46k|    }
_ZN4Ogre9Animation15createNodeTrackEt:
   67|    215|    {
   68|    215|        if (hasNodeTrack(handle))
  ------------------
  |  Branch (68:13): [True: 5, False: 210]
  ------------------
   69|      5|        {
   70|      5|            OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM,
   71|      5|                "Node track with the specified handle " +
   72|      5|                StringConverter::toString(handle) + " already exists",
   73|      5|                "Animation::createNodeTrack");
   74|      5|        }
   75|       |
   76|    210|        NodeAnimationTrack* ret = OGRE_NEW NodeAnimationTrack(this, handle);
   77|       |
   78|    210|        mNodeTrackList[handle] = ret;
   79|    210|        return ret;
   80|    215|    }
_ZN4Ogre9Animation15createNodeTrackEtPNS_4NodeE:
   83|    215|    {
   84|    215|        NodeAnimationTrack* ret = createNodeTrack(handle);
   85|       |
   86|    215|        ret->setAssociatedNode(node);
   87|       |
   88|    215|        return ret;
   89|    215|    }
_ZNK4Ogre9Animation12hasNodeTrackEt:
   97|    215|    {
   98|    215|        return (mNodeTrackList.find(handle) != mNodeTrackList.end());
   99|    215|    }
_ZN4Ogre9Animation20destroyAllNodeTracksEv:
  130|  5.46k|    {
  131|  5.46k|        for (auto& t : mNodeTrackList)
  ------------------
  |  Branch (131:22): [True: 210, False: 5.46k]
  ------------------
  132|    210|        {
  133|       |            OGRE_DELETE t.second;
  134|    210|        }
  135|  5.46k|        mNodeTrackList.clear();
  136|  5.46k|        _keyFrameListChanged();
  137|  5.46k|    }
_ZN4Ogre9Animation23destroyAllNumericTracksEv:
  194|  5.46k|    {
  195|  5.46k|        for (auto& t : mNumericTrackList)
  ------------------
  |  Branch (195:22): [True: 0, False: 5.46k]
  ------------------
  196|      0|        {
  197|       |            OGRE_DELETE t.second;
  198|      0|        }
  199|  5.46k|        mNumericTrackList.clear();
  200|  5.46k|        _keyFrameListChanged();
  201|  5.46k|    }
_ZN4Ogre9Animation17createVertexTrackEtNS_19VertexAnimationTypeE:
  205|  3.63k|    {
  206|  3.63k|        if (hasVertexTrack(handle))
  ------------------
  |  Branch (206:13): [True: 10, False: 3.62k]
  ------------------
  207|     10|        {
  208|     10|            OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM,
  209|     10|                "Vertex track with the specified handle " +
  210|     10|                StringConverter::toString(handle) + " already exists",
  211|     10|                "Animation::createVertexTrack");
  212|     10|        }
  213|       |
  214|  3.62k|        VertexAnimationTrack* ret = OGRE_NEW VertexAnimationTrack(this, handle, animType);
  215|       |
  216|  3.62k|        mVertexTrackList[handle] = ret;
  217|  3.62k|        return ret;
  218|       |
  219|  3.63k|    }
_ZN4Ogre9Animation17createVertexTrackEtPNS_10VertexDataENS_19VertexAnimationTypeE:
  223|  3.63k|    {
  224|  3.63k|        OgreAssert(data, "VertexData must not be null");
  ------------------
  |  Branch (224:9): [True: 0, False: 3.63k]
  ------------------
  225|  3.63k|        VertexAnimationTrack* ret = createVertexTrack(handle, animType);
  226|       |
  227|  3.63k|        ret->setAssociatedVertexData(data);
  228|       |
  229|  3.63k|        return ret;
  230|  3.63k|    }
_ZNK4Ogre9Animation14hasVertexTrackEt:
  238|  3.63k|    {
  239|  3.63k|        return (mVertexTrackList.find(handle) != mVertexTrackList.end());
  240|  3.63k|    }
_ZN4Ogre9Animation22destroyAllVertexTracksEv:
  271|  5.46k|    {
  272|  5.46k|        for (auto& v : mVertexTrackList)
  ------------------
  |  Branch (272:22): [True: 3.62k, False: 5.46k]
  ------------------
  273|  3.62k|        {
  274|       |            OGRE_DELETE  v.second;
  275|  3.62k|        }
  276|  5.46k|        mVertexTrackList.clear();
  277|  5.46k|        _keyFrameListChanged();
  278|  5.46k|    }
_ZN4Ogre9Animation16destroyAllTracksEv:
  281|  5.46k|    {
  282|  5.46k|        destroyAllNodeTracks();
  283|  5.46k|        destroyAllNumericTracks();
  284|  5.46k|        destroyAllVertexTracks();
  285|  5.46k|    }
_ZN4Ogre9Animation18setUseBaseKeyFrameEbfRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  658|    257|    {
  659|    257|        if (useBaseKeyFrame != mUseBaseKeyFrame ||
  ------------------
  |  Branch (659:13): [True: 257, False: 0]
  ------------------
  660|      0|            keyframeTime != mBaseKeyFrameTime ||
  ------------------
  |  Branch (660:13): [True: 0, False: 0]
  ------------------
  661|      0|            baseAnimName != mBaseKeyFrameAnimationName)
  ------------------
  |  Branch (661:13): [True: 0, False: 0]
  ------------------
  662|    257|        {
  663|    257|            mUseBaseKeyFrame = useBaseKeyFrame;
  664|    257|            mBaseKeyFrameTime = keyframeTime;
  665|    257|            mBaseKeyFrameAnimationName = baseAnimName;
  666|    257|        }
  667|    257|    }
_ZN4Ogre9Animation16_notifyContainerEPNS_18AnimationContainerE:
  737|  5.46k|    {
  738|  5.46k|        mContainer = c;
  739|  5.46k|    }

_ZN4Ogre14AnimationTrackC2EPNS_9AnimationEt:
   48|  3.83k|        mParent(parent), mListener(0), mHandle(handle)
   49|  3.83k|    {
   50|  3.83k|    }
_ZN4Ogre14AnimationTrackD2Ev:
   53|  3.83k|    {
   54|  3.83k|        removeAllKeyFrames();
   55|  3.83k|    }
_ZN4Ogre14AnimationTrack14createKeyFrameEf:
  129|  5.92k|    {
  130|  5.92k|        KeyFrame* kf = createKeyFrameImpl(timePos);
  131|       |
  132|       |        // Insert just before upper bound
  133|  5.92k|        KeyFrameList::iterator i =
  134|  5.92k|            std::upper_bound(mKeyFrames.begin(), mKeyFrames.end(), kf, KeyFrameTimeLess());
  135|  5.92k|        mKeyFrames.insert(i, kf);
  136|       |
  137|  5.92k|        _keyFrameDataChanged();
  138|  5.92k|        mParent->_keyFrameListChanged();
  139|       |
  140|  5.92k|        return kf;
  141|       |
  142|  5.92k|    }
_ZN4Ogre14AnimationTrack18removeAllKeyFramesEv:
  164|  3.83k|    {
  165|  3.83k|        for (auto *f : mKeyFrames)
  ------------------
  |  Branch (165:22): [True: 5.92k, False: 3.83k]
  ------------------
  166|  5.92k|            OGRE_DELETE f;
  167|       |
  168|  3.83k|        _keyFrameDataChanged();
  169|  3.83k|        mParent->_keyFrameListChanged();
  170|       |
  171|  3.83k|        mKeyFrames.clear();
  172|       |
  173|  3.83k|    }
_ZN4Ogre18NodeAnimationTrackC2EPNS_9AnimationEt:
  357|    210|        : NodeAnimationTrack(parent, handle, 0)
  358|    210|    {
  359|    210|    }
_ZN4Ogre18NodeAnimationTrackC2EPNS_9AnimationEtPNS_4NodeE:
  362|    210|        : AnimationTrack(parent, handle), mSplineBuildNeeded(false), mUseShortestRotationPath(true),
  363|    210|          mTargetNode(targetNode), mSplines(0)
  364|       |
  365|    210|    {
  366|    210|    }
_ZN4Ogre18NodeAnimationTrackD2Ev:
  369|    210|    {
  370|       |        OGRE_DELETE_T(mSplines, Splines, MEMCATEGORY_ANIMATION);
  371|    210|    }
_ZN4Ogre18NodeAnimationTrack17setAssociatedNodeEPNS_4NodeE:
  469|    210|    {
  470|    210|        mTargetNode = node;
  471|    210|    }
_ZNK4Ogre18NodeAnimationTrack20_keyFrameDataChangedEv:
  564|  3.46k|    {
  565|  3.46k|        mSplineBuildNeeded = true;
  566|  3.46k|    }
_ZN4Ogre18NodeAnimationTrack18createKeyFrameImplEf:
  648|  1.06k|    {
  649|       |        return OGRE_NEW TransformKeyFrame(this, time);
  650|  1.06k|    }
_ZN4Ogre18NodeAnimationTrack18createNodeKeyFrameEf:
  653|  1.06k|    {
  654|  1.06k|        return static_cast<TransformKeyFrame*>(createKeyFrame(timePos));
  655|  1.06k|    }
_ZN4Ogre20VertexAnimationTrackC2EPNS_9AnimationEtNS_19VertexAnimationTypeE:
  687|  3.62k|        : AnimationTrack(parent, handle)
  688|  3.62k|        , mAnimationType(animType)
  689|  3.62k|    {
  690|  3.62k|    }
_ZN4Ogre20VertexAnimationTrack25createVertexMorphKeyFrameEf:
  702|  2.86k|    {
  703|  2.86k|        OgreAssert(mAnimationType == VAT_MORPH, "Type mismatch");
  ------------------
  |  Branch (703:9): [True: 8, False: 2.85k]
  ------------------
  704|  2.85k|        return static_cast<VertexMorphKeyFrame*>(createKeyFrame(timePos));
  705|  2.86k|    }
_ZN4Ogre20VertexAnimationTrack24createVertexPoseKeyFrameEf:
  708|  2.01k|    {
  709|  2.01k|        OgreAssert(mAnimationType == VAT_POSE, "Type mismatch");
  ------------------
  |  Branch (709:9): [True: 5, False: 2.01k]
  ------------------
  710|  2.01k|        return static_cast<VertexPoseKeyFrame*>(createKeyFrame(timePos));
  711|  2.01k|    }
_ZN4Ogre20VertexAnimationTrack18createKeyFrameImplEf:
  960|  4.86k|    {
  961|  4.86k|        switch(mAnimationType)
  962|  4.86k|        {
  963|      0|        default:
  ------------------
  |  Branch (963:9): [True: 0, False: 4.86k]
  ------------------
  964|  2.85k|        case VAT_MORPH:
  ------------------
  |  Branch (964:9): [True: 2.85k, False: 2.01k]
  ------------------
  965|  2.85k|            return OGRE_NEW VertexMorphKeyFrame(this, time);
  966|  2.01k|        case VAT_POSE:
  ------------------
  |  Branch (966:9): [True: 2.01k, False: 2.85k]
  ------------------
  967|  2.01k|            return OGRE_NEW VertexPoseKeyFrame(this, time);
  968|  4.86k|        };
  969|       |
  970|      0|    }
OgreAnimationTrack.cpp:_ZNK4Ogre12_GLOBAL__N_116KeyFrameTimeLessclEPKNS_8KeyFrameES4_:
   40|  19.4k|            {
   41|  19.4k|                return kf->getTime() < kf2->getTime();
   42|  19.4k|            }

_ZN4Ogre4BoneC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEtPNS_8SkeletonE:
   39|    756|        : Node(name), mCreator(creator), mHandle(handle), mManuallyControlled(false)
   40|    756|    {
   41|    756|    }
_ZN4Ogre4BoneD2Ev:
   44|    756|    {
   45|    756|    }
_ZN4Ogre4Bone14setBindingPoseEv:
   68|    650|    {
   69|    650|        setInitialState();
   70|       |
   71|       |        // Save inverse derived position/scale/orientation, used for calculate offset transform later
   72|    650|        mBindDerivedInversePosition = - _getDerivedPosition();
   73|    650|        mBindDerivedInverseScale = Vector3::UNIT_SCALE / _getDerivedScale();
   74|    650|        mBindDerivedInverseOrientation = _getDerivedOrientation().Inverse();
   75|    650|    }
_ZN4Ogre4Bone10needUpdateEb:
  108|  1.55k|    {
  109|  1.55k|        Node::needUpdate(forceParentUpdate);
  110|       |
  111|  1.55k|        if (isManuallyControlled())
  ------------------
  |  Branch (111:13): [True: 0, False: 1.55k]
  ------------------
  112|      0|        {
  113|       |            // Dirty the skeleton if manually controlled so animation can be updated
  114|      0|            mCreator->_notifyManualBonesDirty();
  115|      0|        }
  116|       |
  117|  1.55k|    }

_ZN4Ogre5Codec13registerCodecEPS0_:
   62|      1|    {
   63|      1|        auto ret = msMapCodecs.emplace(pCodec->getType(), pCodec);
   64|      1|        if (!ret.second)
  ------------------
  |  Branch (64:13): [True: 0, False: 1]
  ------------------
   65|       |            OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, pCodec->getType() + " already has a registered codec");
   66|      1|    }

_ZN4Ogre19logMaterialNotFoundERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEES8_S8_S8_NS_15LogMessageLevelE:
   67|   197k|    {
   68|   197k|        LogManager::getSingleton().logMessage(
   69|   197k|            StringUtil::format("Can't assign material to %s '%s'. Material '%s' not found in group '%s'. Have you "
   70|   197k|                               "forgotten to define it in a .material script?",
   71|   197k|                               destType.c_str(), destName.c_str(), name.c_str(), groupName.c_str()),
   72|   197k|            lml);
   73|   197k|    }

_ZN4Ogre10ConfigFileC2Ev:
   38|  1.08k|    {
   39|  1.08k|    }
_ZN4Ogre10ConfigFile5clearEv:
   42|  1.08k|    {
   43|  1.08k|        mSettings.clear();
   44|  1.08k|        mSettingsPtr.clear();
   45|  1.08k|    }
_ZN4Ogre10ConfigFile4loadERKNS_9SharedPtrINS_10DataStreamEEERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEb:
   74|  1.08k|    {
   75|       |        /* Clear current settings map */
   76|  1.08k|        clear();
   77|       |
   78|  1.08k|        String currentSection = BLANKSTRING;
   79|  1.08k|        SettingsMultiMap* currentSettings = &mSettings[currentSection];
   80|  1.08k|        mSettingsPtr[currentSection] = currentSettings;
   81|       |
   82|       |
   83|       |        /* Process the file line for line */
   84|  1.08k|        String line, optName, optVal;
   85|  31.6k|        while (!stream->eof())
  ------------------
  |  Branch (85:16): [True: 30.5k, False: 1.08k]
  ------------------
   86|  30.5k|        {
   87|  30.5k|            line = stream->getLine();
   88|       |            /* Ignore comments & blanks */
   89|  30.5k|            if (line.length() > 0 && line.at(0) != '#' && line.at(0) != '@')
  ------------------
  |  Branch (89:17): [True: 29.4k, False: 1.12k]
  |  Branch (89:38): [True: 29.2k, False: 224]
  |  Branch (89:59): [True: 28.9k, False: 296]
  ------------------
   90|  28.9k|            {
   91|  28.9k|                if (line.at(0) == '[' && line.at(line.length()-1) == ']')
  ------------------
  |  Branch (91:21): [True: 8.22k, False: 20.7k]
  |  Branch (91:42): [True: 7.31k, False: 909]
  ------------------
   92|  7.31k|                {
   93|       |                    // Section
   94|  7.31k|                    currentSection = line.substr(1, line.length() - 2);
   95|  7.31k|                    currentSettings = &mSettings[currentSection];
   96|  7.31k|                    mSettingsPtr[currentSection] = currentSettings;
   97|  7.31k|                }
   98|  21.6k|                else
   99|  21.6k|                {
  100|       |                    /* Find the first separator character and split the string there */
  101|  21.6k|                    Ogre::String::size_type separator_pos = line.find_first_of(separators, 0);
  102|  21.6k|                    if (separator_pos != Ogre::String::npos)
  ------------------
  |  Branch (102:25): [True: 16.0k, False: 5.55k]
  ------------------
  103|  16.0k|                    {
  104|  16.0k|                        optName = line.substr(0, separator_pos);
  105|       |                        /* Find the first non-separator character following the name */
  106|  16.0k|                        Ogre::String::size_type nonseparator_pos = line.find_first_not_of(separators, separator_pos);
  107|       |                        /* ... and extract the value */
  108|       |                        /* Make sure we don't crash on an empty setting (it might be a valid value) */
  109|  16.0k|                        optVal = (nonseparator_pos == Ogre::String::npos) ? "" : line.substr(nonseparator_pos);
  ------------------
  |  Branch (109:34): [True: 13.3k, False: 2.72k]
  ------------------
  110|  16.0k|                        if (trimWhitespace)
  ------------------
  |  Branch (110:29): [True: 16.0k, False: 0]
  ------------------
  111|  16.0k|                        {
  112|  16.0k|                            StringUtil::trim(optVal);
  113|  16.0k|                            StringUtil::trim(optName);
  114|  16.0k|                        }
  115|  16.0k|                        currentSettings->emplace(optName, optVal);
  116|  16.0k|                    }
  117|  21.6k|                }
  118|  28.9k|            }
  119|  30.5k|        }
  120|  1.08k|    }

_ZN4Ogre10DataStream7getLineEb:
   41|   308k|    {
   42|   308k|        char tmpBuf[OGRE_STREAM_TEMP_SIZE];
   43|   308k|        String retString;
   44|   308k|        size_t readCount;
   45|       |        // Keep looping while not hitting delimiter
   46|   890k|        while ((readCount = read(tmpBuf, OGRE_STREAM_TEMP_SIZE-1)) != 0)
  ------------------
  |  Branch (46:16): [True: 887k, False: 2.74k]
  ------------------
   47|   887k|        {
   48|   887k|            const char* p = static_cast<const char*>(memchr(tmpBuf, '\n', readCount));
   49|   887k|            size_t appendCount = readCount;
   50|   887k|            if (p != 0)
  ------------------
  |  Branch (50:17): [True: 306k, False: 581k]
  ------------------
   51|   306k|            {
   52|   306k|                appendCount = static_cast<size_t>(p - tmpBuf);
   53|       |                // Reposition backwards
   54|   306k|                skip(static_cast<long>(appendCount + 1 - readCount));
   55|   306k|            }
   56|       |
   57|   887k|            retString.append(tmpBuf, appendCount);
   58|       |
   59|   887k|            if (p != 0)
  ------------------
  |  Branch (59:17): [True: 306k, False: 581k]
  ------------------
   60|   306k|            {
   61|       |                // Trim off trailing CR if this was a CR/LF entry
   62|   306k|                if (retString.length() && retString[retString.length()-1] == '\r')
  ------------------
  |  Branch (62:21): [True: 262k, False: 43.3k]
  |  Branch (62:43): [True: 926, False: 261k]
  ------------------
   63|    926|                {
   64|    926|                    retString.erase(retString.length()-1, 1);
   65|    926|                }
   66|       |
   67|       |                // Found terminator, break out
   68|   306k|                break;
   69|   306k|            }
   70|   887k|        }
   71|       |
   72|   308k|        if (trimAfter)
  ------------------
  |  Branch (72:13): [True: 30.5k, False: 278k]
  ------------------
   73|  30.5k|        {
   74|  30.5k|            StringUtil::trim(retString);
   75|  30.5k|        }
   76|       |
   77|   308k|        return retString;
   78|   308k|    }
_ZN4Ogre16MemoryDataStreamC2EPvmbb:
  188|  7.55k|        : DataStream(static_cast<uint16>(readOnly ? READ : (READ | WRITE)))
  ------------------
  |  Branch (188:42): [True: 7.55k, False: 0]
  ------------------
  189|  7.55k|    {
  190|  7.55k|        mData = mPos = static_cast<uchar*>(pMem);
  191|  7.55k|        mSize = inSize;
  192|  7.55k|        mEnd = mData + mSize;
  193|  7.55k|        mFreeOnClose = freeOnClose;
  194|       |        assert(mEnd >= mPos);
  195|  7.55k|    }
_ZN4Ogre16MemoryDataStreamC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPvmbb:
  199|  1.08k|        : DataStream(name, static_cast<uint16>(readOnly ? READ : (READ | WRITE)))
  ------------------
  |  Branch (199:48): [True: 1.08k, False: 0]
  ------------------
  200|  1.08k|    {
  201|  1.08k|        mData = mPos = static_cast<uchar*>(pMem);
  202|  1.08k|        mSize = inSize;
  203|  1.08k|        mEnd = mData + mSize;
  204|  1.08k|        mFreeOnClose = freeOnClose;
  205|       |        assert(mEnd >= mPos);
  206|  1.08k|    }
_ZN4Ogre16MemoryDataStreamD2Ev:
  336|  8.64k|    {
  337|  8.64k|        close();
  338|  8.64k|    }
_ZN4Ogre16MemoryDataStream4readEPvm:
  341|  1.21G|    {
  342|       |        // Read over end of memory?
  343|  1.21G|        if (mPos >= mEnd)
  ------------------
  |  Branch (343:13): [True: 1.20G, False: 4.31M]
  ------------------
  344|  1.20G|            return 0;
  345|  4.31M|        size_t cnt = std::min(count, static_cast<size_t>(mEnd - mPos));
  346|  4.31M|        if (cnt == 0)
  ------------------
  |  Branch (346:13): [True: 4.55k, False: 4.31M]
  ------------------
  347|  4.55k|            return 0;
  348|       |
  349|  4.31M|        assert (cnt<=count);
  350|       |
  351|  4.31M|        memcpy(buf, mPos, cnt);
  352|  4.31M|        mPos += cnt;
  353|  4.31M|        return cnt;
  354|  4.31M|    }
_ZN4Ogre16MemoryDataStream4skipEl:
  433|   730k|    {
  434|       |        // will underflow to size_t max if we skip below 0
  435|   730k|        size_t newpos = (size_t)( ( mPos - mData ) + count );
  436|       |
  437|   730k|        if (mData + newpos > mEnd)
  ------------------
  |  Branch (437:13): [True: 329, False: 730k]
  ------------------
  438|    329|            newpos = static_cast<size_t>(mEnd - mData); // will trigger eof
  439|   730k|        mPos = mData + newpos;
  440|   730k|    }
_ZN4Ogre16MemoryDataStream4seekEm:
  443|  5.89k|    {
  444|  5.89k|        if (mData + pos > mEnd)
  ------------------
  |  Branch (444:13): [True: 24, False: 5.86k]
  ------------------
  445|     24|            pos = static_cast<size_t>(mEnd - mData); // will trigger eof
  446|  5.89k|        mPos = mData + pos;
  447|  5.89k|    }
_ZNK4Ogre16MemoryDataStream4tellEv:
  450|   981k|    {
  451|       |        //mData is start, mPos is current location
  452|   981k|        return mPos - mData;
  453|   981k|    }
_ZNK4Ogre16MemoryDataStream3eofEv:
  456|  3.43M|    {
  457|  3.43M|        return mPos >= mEnd;
  458|  3.43M|    }
_ZN4Ogre16MemoryDataStream5closeEv:
  461|  8.64k|    {
  462|  8.64k|        mAccess = 0;
  463|  8.64k|        if (mFreeOnClose && mData)
  ------------------
  |  Branch (463:13): [True: 0, False: 8.64k]
  |  Branch (463:29): [True: 0, False: 0]
  ------------------
  464|      0|        {
  465|       |            OGRE_FREE(mData, MEMCATEGORY_GENERAL);
  466|      0|            mData = 0;
  467|      0|        }
  468|  8.64k|    }

_ZN4Ogre21DefaultHardwareBufferC2Em:
   34|   111k|    : HardwareBuffer(HBU_CPU_ONLY, false) // always software, never shadowed
   35|   111k|    {
   36|   111k|        mSizeInBytes = sizeInBytes;
   37|       |        // Allocate aligned memory for better SIMD processing friendly.
   38|   111k|        mData = (uchar*)AlignedMemory::allocate(mSizeInBytes);
   39|   111k|    }
_ZN4Ogre21DefaultHardwareBufferD2Ev:
   42|   111k|    {
   43|   111k|        AlignedMemory::deallocate(mData);
   44|   111k|    }
_ZN4Ogre21DefaultHardwareBuffer8lockImplEmmNS_14HardwareBuffer11LockOptionsE:
   47|   114k|    {
   48|       |        // Only for use internally, no 'locking' as such
   49|   114k|        return mData + offset;
   50|   114k|    }
_ZN4Ogre21DefaultHardwareBuffer10unlockImplEv:
   53|   114k|    {
   54|       |        // Nothing to do
   55|   114k|    }
_ZN4Ogre32DefaultHardwareBufferManagerBaseC2Ev:
   72|      1|    {
   73|      1|    }
_ZN4Ogre32DefaultHardwareBufferManagerBase18createVertexBufferEmmhb:
   84|  13.6k|    {
   85|  13.6k|        return std::make_shared<HardwareVertexBuffer>(this, vertexSize, numVerts,
   86|  13.6k|                                                      new DefaultHardwareBuffer(vertexSize * numVerts));
   87|  13.6k|    }
_ZN4Ogre32DefaultHardwareBufferManagerBase17createIndexBufferENS_19HardwareIndexBuffer9IndexTypeEmhb:
   92|  98.0k|    {
   93|  98.0k|        return std::make_shared<HardwareIndexBuffer>(
   94|  98.0k|            this, itype, numIndexes,
   95|  98.0k|            new DefaultHardwareBuffer(HardwareIndexBuffer::indexSize(itype) * numIndexes));
   96|  98.0k|    }

_ZN4Ogre23DistanceLodStrategyBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   37|      2|        : LodStrategy(name)
   38|      2|        , mReferenceViewEnabled(false)
   39|      2|        , mReferenceViewValue(-1)
   40|      2|    { }
_ZNK4Ogre23DistanceLodStrategyBase12getBaseValueEv:
   76|  15.9k|    {
   77|  15.9k|        return Real(0);
   78|  15.9k|    }
_ZNK4Ogre23DistanceLodStrategyBase18transformUserValueEf:
   87|  10.2k|    {
   88|       |        // Square user-supplied distance
   89|  10.2k|        return Math::Sqr(userValue);
   90|  10.2k|    }
_ZN4Ogre25DistanceLodSphereStrategyC2Ev:
  161|      1|        : DistanceLodStrategyBase("distance_sphere")
  162|      1|    { }
_ZN4Ogre22DistanceLodBoxStrategyC2Ev:
  193|      1|        : DistanceLodStrategyBase("distance_box")
  194|      1|    { }

_ZN4Ogre8EdgeDataC2Ev:
   44|    453|    EdgeData::EdgeData() : isClosed(false){}

_ZN4Ogre9ExceptionC2EiRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_PKcSB_l:
   43|  26.5k|        line( lin ),
   44|  26.5k|        typeName(typ),
   45|  26.5k|        description( desc ),
   46|  26.5k|        source( src ),
   47|  26.5k|        file( fil )
   48|  26.5k|    {
   49|  26.5k|        StringStream ss;
   50|       |
   51|  26.5k|        ss << typeName << ": "
   52|  26.5k|           << description
   53|  26.5k|           << " in " << source;
   54|       |
   55|  26.5k|        if( line > 0 )
  ------------------
  |  Branch (55:13): [True: 26.5k, False: 0]
  ------------------
   56|  26.5k|        {
   57|  26.5k|            ss << " at " << file << " (line " << line << ")";
   58|  26.5k|        }
   59|       |
   60|  26.5k|        fullDesc = ss.str();
   61|  26.5k|    }

_ZN4Ogre21HardwareBufferManager15getSingletonPtrEv:
   36|   265k|    {
   37|   265k|        return msSingleton;
   38|   265k|    }
_ZN4Ogre21HardwareBufferManagerC2Ev:
   45|      1|    {
   46|      1|    }
_ZN4Ogre25HardwareBufferManagerBaseC2Ev:
   58|      2|        : mUnderUsedFrameCount(0)
   59|      2|    {
   60|      2|    }
_ZN4Ogre25HardwareBufferManagerBase23createVertexDeclarationEv:
   73|   149k|    {
   74|   149k|        VertexDeclaration* decl = createVertexDeclarationImpl();
   75|   149k|        OGRE_LOCK_MUTEX(mVertexDeclarationsMutex);
   76|   149k|        mVertexDeclarations.insert(decl);
   77|   149k|        return decl;
   78|   149k|    }
_ZN4Ogre25HardwareBufferManagerBase24destroyVertexDeclarationEPNS_17VertexDeclarationE:
   81|   149k|    {
   82|   149k|        OGRE_LOCK_MUTEX(mVertexDeclarationsMutex);
   83|   149k|        OgreAssertDbg(mVertexDeclarations.find(decl) != mVertexDeclarations.end(), "unknown decl");
   84|   149k|        mVertexDeclarations.erase(decl);
   85|   149k|        destroyVertexDeclarationImpl(decl);
   86|   149k|    }
_ZN4Ogre25HardwareBufferManagerBase25createVertexBufferBindingEv:
   89|   149k|    {
   90|   149k|        VertexBufferBinding* ret = createVertexBufferBindingImpl();
   91|   149k|        OGRE_LOCK_MUTEX(mVertexBufferBindingsMutex);
   92|   149k|        mVertexBufferBindings.insert(ret);
   93|   149k|        return ret;
   94|   149k|    }
_ZN4Ogre25HardwareBufferManagerBase26destroyVertexBufferBindingEPNS_19VertexBufferBindingE:
   97|   149k|    {
   98|   149k|        OGRE_LOCK_MUTEX(mVertexBufferBindingsMutex);
   99|   149k|        OgreAssertDbg(mVertexBufferBindings.find(binding) != mVertexBufferBindings.end(),
  100|   149k|                      "unknown binding");
  101|   149k|        mVertexBufferBindings.erase(binding);
  102|   149k|        destroyVertexBufferBindingImpl(binding);
  103|   149k|    }
_ZN4Ogre25HardwareBufferManagerBase27createVertexDeclarationImplEv:
  106|   149k|    {
  107|       |        return OGRE_NEW VertexDeclaration();
  108|   149k|    }
_ZN4Ogre25HardwareBufferManagerBase28destroyVertexDeclarationImplEPNS_17VertexDeclarationE:
  111|   149k|    {
  112|       |        OGRE_DELETE decl;
  113|   149k|    }
_ZN4Ogre25HardwareBufferManagerBase29createVertexBufferBindingImplEv:
  116|   149k|    {
  117|       |        return OGRE_NEW VertexBufferBinding();
  118|   149k|    }
_ZN4Ogre25HardwareBufferManagerBase30destroyVertexBufferBindingImplEPNS_19VertexBufferBindingE:
  121|   149k|    {
  122|       |        OGRE_DELETE binding;
  123|   149k|    }
_ZN4Ogre25HardwareBufferManagerBase28_notifyVertexBufferDestroyedEPNS_20HardwareVertexBufferE:
  361|  13.6k|    {
  362|  13.6k|        OGRE_LOCK_MUTEX(mVertexBuffersMutex);
  363|  13.6k|        VertexBufferList::iterator i = mVertexBuffers.find(buf);
  364|  13.6k|        if (i != mVertexBuffers.end())
  ------------------
  |  Branch (364:13): [True: 0, False: 13.6k]
  ------------------
  365|      0|        {
  366|       |            // release vertex buffer copies
  367|      0|            mVertexBuffers.erase(i);
  368|      0|            _forceReleaseBufferCopies(buf);
  369|      0|        }
  370|  13.6k|    }

_ZN4Ogre19HardwareIndexBufferC2EPNS_25HardwareBufferManagerBaseENS0_9IndexTypeEmhb:
   40|  98.0k|        : HardwareBuffer(usage, useShadowBuffer)
   41|  98.0k|        , mIndexType(idxType)
   42|  98.0k|        , mMgr(mgr)
   43|  98.0k|        , mNumIndexes(numIndexes)
   44|  98.0k|    {
   45|       |        // Calculate the size of the indexes
   46|  98.0k|        mIndexSize = indexSize(idxType);
   47|  98.0k|        mSizeInBytes = mIndexSize * mNumIndexes;
   48|       |
   49|  98.0k|        if (idxType == IT_32BIT && Root::getSingletonPtr() && Root::getSingleton().getRenderSystem())
  ------------------
  |  Branch (49:13): [True: 3.30k, False: 94.7k]
  |  Branch (49:36): [True: 0, False: 3.30k]
  |  Branch (49:63): [True: 0, False: 0]
  ------------------
   50|      0|        {
   51|      0|            if (!Root::getSingleton().getRenderSystem()->getCapabilities()->hasCapability(RSC_32BIT_INDEX))
  ------------------
  |  Branch (51:17): [True: 0, False: 0]
  ------------------
   52|      0|            {
   53|      0|                OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "32 bit index buffers are not supported");
   54|      0|            }
   55|      0|        }
   56|       |
   57|       |        // Create a shadow buffer if required
   58|  98.0k|        if (useShadowBuffer)
  ------------------
  |  Branch (58:13): [True: 0, False: 98.0k]
  ------------------
   59|      0|        {
   60|      0|            mShadowBuffer = std::make_unique<DefaultHardwareBuffer>(mSizeInBytes);
   61|      0|        }
   62|  98.0k|    }
_ZN4Ogre19HardwareIndexBufferC2EPNS_25HardwareBufferManagerBaseENS0_9IndexTypeEmPNS_14HardwareBufferE:
   66|  98.0k|        : HardwareIndexBuffer(mgr, idxType, numIndexes, delegate->getUsage(), false)
   67|  98.0k|    {
   68|  98.0k|        mDelegate.reset(delegate);
   69|  98.0k|    }
_ZN4Ogre19HardwareIndexBufferD2Ev:
   73|  98.0k|    {
   74|  98.0k|    }

_ZN4Ogre20HardwareVertexBufferC2EPNS_25HardwareBufferManagerBaseEmmhb:
   39|  13.6k|        : HardwareBuffer(usage, useShadowBuffer),
   40|  13.6k|          mIsInstanceData(false),
   41|  13.6k|          mMgr(mgr),
   42|  13.6k|          mNumVertices(numVertices),
   43|  13.6k|          mVertexSize(vertexSize),
   44|  13.6k|          mInstanceDataStepRate(1)
   45|  13.6k|    {
   46|       |        // Calculate the size of the vertices
   47|  13.6k|        mSizeInBytes = mVertexSize * numVertices;
   48|       |
   49|       |        // Create a shadow buffer if required
   50|  13.6k|        if (useShadowBuffer)
  ------------------
  |  Branch (50:13): [True: 0, False: 13.6k]
  ------------------
   51|      0|        {
   52|      0|            mShadowBuffer = std::make_unique<DefaultHardwareBuffer>(mSizeInBytes);
   53|      0|        }
   54|       |
   55|  13.6k|    }
_ZN4Ogre20HardwareVertexBufferC2EPNS_25HardwareBufferManagerBaseEmmPNS_14HardwareBufferE:
   58|  13.6k|        : HardwareVertexBuffer(mgr, vertexSize, numVertices, delegate->getUsage(), false)
   59|  13.6k|    {
   60|  13.6k|        mDelegate.reset(delegate);
   61|  13.6k|    }
_ZN4Ogre20HardwareVertexBufferD2Ev:
   64|  13.6k|    {
   65|  13.6k|        if (mMgr)
  ------------------
  |  Branch (65:13): [True: 13.6k, False: 0]
  ------------------
   66|  13.6k|        {
   67|  13.6k|            mMgr->_notifyVertexBufferDestroyed(this);
   68|  13.6k|        }
   69|  13.6k|    }
_ZN4Ogre13VertexElementC2EtmNS_17VertexElementTypeENS_21VertexElementSemanticEt:
  104|  33.4k|        : mOffset(offset), mSource(source), mIndex(index), mType(theType), mSemantic(semantic)
  105|  33.4k|    {
  106|  33.4k|    }
_ZNK4Ogre13VertexElement7getSizeEv:
  109|  45.2k|    {
  110|  45.2k|        return getTypeSize(mType);
  111|  45.2k|    }
_ZN4Ogre13VertexElement11getTypeSizeENS_17VertexElementTypeE:
  114|  47.7k|    {
  115|  47.7k|        switch(etype)
  ------------------
  |  Branch (115:16): [True: 46.9k, False: 860]
  ------------------
  116|  47.7k|        {
  117|    405|        case VET_FLOAT1:
  ------------------
  |  Branch (117:9): [True: 405, False: 47.3k]
  ------------------
  118|    405|            return sizeof(float);
  119|  6.81k|        case VET_FLOAT2:
  ------------------
  |  Branch (119:9): [True: 6.81k, False: 40.9k]
  ------------------
  120|  6.81k|            return sizeof(float)*2;
  121|  1.40k|        case VET_FLOAT3:
  ------------------
  |  Branch (121:9): [True: 1.40k, False: 46.3k]
  ------------------
  122|  1.40k|            return sizeof(float)*3;
  123|  1.48k|        case VET_FLOAT4:
  ------------------
  |  Branch (123:9): [True: 1.48k, False: 46.2k]
  ------------------
  124|  1.48k|            return sizeof(float)*4;
  125|     71|        case VET_DOUBLE1:
  ------------------
  |  Branch (125:9): [True: 71, False: 47.7k]
  ------------------
  126|     71|            return sizeof(double);
  127|     15|        case VET_DOUBLE2:
  ------------------
  |  Branch (127:9): [True: 15, False: 47.7k]
  ------------------
  128|     15|            return sizeof(double)*2;
  129|    605|        case VET_DOUBLE3:
  ------------------
  |  Branch (129:9): [True: 605, False: 47.1k]
  ------------------
  130|    605|            return sizeof(double)*3;
  131|    410|        case VET_DOUBLE4:
  ------------------
  |  Branch (131:9): [True: 410, False: 47.3k]
  ------------------
  132|    410|            return sizeof(double)*4;
  133|     23|        case VET_SHORT1:
  ------------------
  |  Branch (133:9): [True: 23, False: 47.7k]
  ------------------
  134|     54|        case VET_USHORT1:
  ------------------
  |  Branch (134:9): [True: 31, False: 47.7k]
  ------------------
  135|    110|        case VET_HALF1:
  ------------------
  |  Branch (135:9): [True: 56, False: 47.7k]
  ------------------
  136|    110|            return sizeof( short );
  137|     55|        case VET_SHORT2:
  ------------------
  |  Branch (137:9): [True: 55, False: 47.7k]
  ------------------
  138|    289|        case VET_SHORT2_NORM:
  ------------------
  |  Branch (138:9): [True: 234, False: 47.5k]
  ------------------
  139|    331|        case VET_USHORT2:
  ------------------
  |  Branch (139:9): [True: 42, False: 47.7k]
  ------------------
  140|    420|        case VET_USHORT2_NORM:
  ------------------
  |  Branch (140:9): [True: 89, False: 47.6k]
  ------------------
  141|    970|        case VET_HALF2:
  ------------------
  |  Branch (141:9): [True: 550, False: 47.2k]
  ------------------
  142|    970|            return sizeof( short ) * 2;
  143|     42|        case VET_SHORT3:
  ------------------
  |  Branch (143:9): [True: 42, False: 47.7k]
  ------------------
  144|     65|        case VET_USHORT3:
  ------------------
  |  Branch (144:9): [True: 23, False: 47.7k]
  ------------------
  145|    112|        case VET_HALF3:
  ------------------
  |  Branch (145:9): [True: 47, False: 47.7k]
  ------------------
  146|    112|            return sizeof( short ) * 3;
  147|    200|        case VET_SHORT4:
  ------------------
  |  Branch (147:9): [True: 200, False: 47.5k]
  ------------------
  148|    816|        case VET_SHORT4_NORM:
  ------------------
  |  Branch (148:9): [True: 616, False: 47.1k]
  ------------------
  149|  1.48k|        case VET_USHORT4:
  ------------------
  |  Branch (149:9): [True: 666, False: 47.1k]
  ------------------
  150|  6.99k|        case VET_USHORT4_NORM:
  ------------------
  |  Branch (150:9): [True: 5.51k, False: 42.2k]
  ------------------
  151|  11.3k|        case VET_HALF4:
  ------------------
  |  Branch (151:9): [True: 4.37k, False: 43.4k]
  ------------------
  152|  11.3k|            return sizeof( short ) * 4;
  153|    427|        case VET_INT1:
  ------------------
  |  Branch (153:9): [True: 427, False: 47.3k]
  ------------------
  154|    473|        case VET_UINT1:
  ------------------
  |  Branch (154:9): [True: 46, False: 47.7k]
  ------------------
  155|    473|            return sizeof( int );
  156|    420|        case VET_INT2:
  ------------------
  |  Branch (156:9): [True: 420, False: 47.3k]
  ------------------
  157|  2.84k|        case VET_UINT2:
  ------------------
  |  Branch (157:9): [True: 2.42k, False: 45.3k]
  ------------------
  158|  2.84k|            return sizeof( int ) * 2;
  159|    366|        case VET_INT3:
  ------------------
  |  Branch (159:9): [True: 366, False: 47.4k]
  ------------------
  160|    441|        case VET_UINT3:
  ------------------
  |  Branch (160:9): [True: 75, False: 47.7k]
  ------------------
  161|    441|            return sizeof( int ) * 3;
  162|     10|        case VET_INT4:
  ------------------
  |  Branch (162:9): [True: 10, False: 47.7k]
  ------------------
  163|     37|        case VET_UINT4:
  ------------------
  |  Branch (163:9): [True: 27, False: 47.7k]
  ------------------
  164|     37|            return sizeof( int ) * 4;
  165|  4.07k|        case VET_BYTE4:
  ------------------
  |  Branch (165:9): [True: 4.07k, False: 43.7k]
  ------------------
  166|  4.65k|        case VET_BYTE4_NORM:
  ------------------
  |  Branch (166:9): [True: 583, False: 47.2k]
  ------------------
  167|  4.79k|        case VET_UBYTE4:
  ------------------
  |  Branch (167:9): [True: 137, False: 47.6k]
  ------------------
  168|  5.15k|        case VET_UBYTE4_NORM:
  ------------------
  |  Branch (168:9): [True: 358, False: 47.4k]
  ------------------
  169|  9.58k|        case _DETAIL_SWAP_RB:
  ------------------
  |  Branch (169:9): [True: 4.43k, False: 43.3k]
  ------------------
  170|  9.58k|            return sizeof(char)*4;
  171|  9.76k|        case VET_INT_10_10_10_2_NORM:
  ------------------
  |  Branch (171:9): [True: 9.76k, False: 38.0k]
  ------------------
  172|  9.76k|            return 4;
  173|  47.7k|        }
  174|    860|        return 0;
  175|  47.7k|    }
_ZN4Ogre13VertexElement12getTypeCountENS_17VertexElementTypeE:
  178|  32.8k|    {
  179|  32.8k|        switch (etype)
  ------------------
  |  Branch (179:17): [True: 32.8k, False: 0]
  ------------------
  180|  32.8k|        {
  181|    596|        case VET_FLOAT1:
  ------------------
  |  Branch (181:9): [True: 596, False: 32.2k]
  ------------------
  182|    614|        case VET_SHORT1:
  ------------------
  |  Branch (182:9): [True: 18, False: 32.8k]
  ------------------
  183|    699|        case VET_USHORT1:
  ------------------
  |  Branch (183:9): [True: 85, False: 32.7k]
  ------------------
  184|  1.19k|        case VET_UINT1:
  ------------------
  |  Branch (184:9): [True: 496, False: 32.3k]
  ------------------
  185|  1.60k|        case VET_INT1:
  ------------------
  |  Branch (185:9): [True: 408, False: 32.4k]
  ------------------
  186|  1.93k|        case VET_DOUBLE1:
  ------------------
  |  Branch (186:9): [True: 331, False: 32.5k]
  ------------------
  187|  2.30k|        case VET_HALF1:
  ------------------
  |  Branch (187:9): [True: 371, False: 32.4k]
  ------------------
  188|  2.30k|            return 1;
  189|  2.37k|        case VET_FLOAT2:
  ------------------
  |  Branch (189:9): [True: 2.37k, False: 30.4k]
  ------------------
  190|  3.35k|        case VET_SHORT2:
  ------------------
  |  Branch (190:9): [True: 978, False: 31.8k]
  ------------------
  191|  3.50k|        case VET_SHORT2_NORM:
  ------------------
  |  Branch (191:9): [True: 147, False: 32.7k]
  ------------------
  192|  3.78k|        case VET_USHORT2:
  ------------------
  |  Branch (192:9): [True: 287, False: 32.5k]
  ------------------
  193|  3.93k|        case VET_USHORT2_NORM:
  ------------------
  |  Branch (193:9): [True: 148, False: 32.7k]
  ------------------
  194|  4.73k|        case VET_UINT2:
  ------------------
  |  Branch (194:9): [True: 798, False: 32.0k]
  ------------------
  195|  4.94k|        case VET_INT2:
  ------------------
  |  Branch (195:9): [True: 214, False: 32.6k]
  ------------------
  196|  4.95k|        case VET_DOUBLE2:
  ------------------
  |  Branch (196:9): [True: 3, False: 32.8k]
  ------------------
  197|  5.03k|        case VET_HALF2:
  ------------------
  |  Branch (197:9): [True: 82, False: 32.7k]
  ------------------
  198|  5.03k|            return 2;
  199|  1.19k|        case VET_FLOAT3:
  ------------------
  |  Branch (199:9): [True: 1.19k, False: 31.6k]
  ------------------
  200|  1.43k|        case VET_SHORT3:
  ------------------
  |  Branch (200:9): [True: 241, False: 32.6k]
  ------------------
  201|  1.53k|        case VET_USHORT3:
  ------------------
  |  Branch (201:9): [True: 99, False: 32.7k]
  ------------------
  202|  1.57k|        case VET_UINT3:
  ------------------
  |  Branch (202:9): [True: 48, False: 32.8k]
  ------------------
  203|  1.69k|        case VET_INT3:
  ------------------
  |  Branch (203:9): [True: 120, False: 32.7k]
  ------------------
  204|  2.29k|        case VET_DOUBLE3:
  ------------------
  |  Branch (204:9): [True: 591, False: 32.2k]
  ------------------
  205|  2.38k|        case VET_HALF3:
  ------------------
  |  Branch (205:9): [True: 90, False: 32.7k]
  ------------------
  206|  2.38k|            return 3;
  207|    120|        case VET_FLOAT4:
  ------------------
  |  Branch (207:9): [True: 120, False: 32.7k]
  ------------------
  208|  1.42k|        case VET_SHORT4:
  ------------------
  |  Branch (208:9): [True: 1.30k, False: 31.5k]
  ------------------
  209|  1.68k|        case VET_SHORT4_NORM:
  ------------------
  |  Branch (209:9): [True: 264, False: 32.5k]
  ------------------
  210|  2.10k|        case VET_USHORT4:
  ------------------
  |  Branch (210:9): [True: 421, False: 32.4k]
  ------------------
  211|  3.94k|        case VET_USHORT4_NORM:
  ------------------
  |  Branch (211:9): [True: 1.83k, False: 31.0k]
  ------------------
  212|  4.20k|        case VET_UINT4:
  ------------------
  |  Branch (212:9): [True: 266, False: 32.5k]
  ------------------
  213|  4.34k|        case VET_INT4:
  ------------------
  |  Branch (213:9): [True: 138, False: 32.7k]
  ------------------
  214|  4.66k|        case VET_DOUBLE4:
  ------------------
  |  Branch (214:9): [True: 316, False: 32.5k]
  ------------------
  215|  5.81k|        case VET_BYTE4:
  ------------------
  |  Branch (215:9): [True: 1.15k, False: 31.6k]
  ------------------
  216|  5.91k|        case VET_UBYTE4:
  ------------------
  |  Branch (216:9): [True: 102, False: 32.7k]
  ------------------
  217|  9.39k|        case VET_BYTE4_NORM:
  ------------------
  |  Branch (217:9): [True: 3.47k, False: 29.3k]
  ------------------
  218|  9.62k|        case VET_UBYTE4_NORM:
  ------------------
  |  Branch (218:9): [True: 231, False: 32.6k]
  ------------------
  219|  14.3k|        case _DETAIL_SWAP_RB:
  ------------------
  |  Branch (219:9): [True: 4.76k, False: 28.0k]
  ------------------
  220|  21.7k|        case VET_INT_10_10_10_2_NORM:
  ------------------
  |  Branch (220:9): [True: 7.36k, False: 25.4k]
  ------------------
  221|  23.1k|        case VET_HALF4:
  ------------------
  |  Branch (221:9): [True: 1.38k, False: 31.4k]
  ------------------
  222|  23.1k|            return 4;
  223|  32.8k|        }
  224|  32.8k|        OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Invalid type", 
  225|  32.8k|            "VertexElement::getTypeCount");
  226|  32.8k|    }
_ZN4Ogre13VertexElement11getBaseTypeENS_17VertexElementTypeE:
  296|  34.7k|    {
  297|  34.7k|        switch (multiType)
  ------------------
  |  Branch (297:17): [True: 34.4k, False: 241]
  ------------------
  298|  34.7k|        {
  299|    603|            case VET_FLOAT1:
  ------------------
  |  Branch (299:13): [True: 603, False: 34.0k]
  ------------------
  300|  2.98k|            case VET_FLOAT2:
  ------------------
  |  Branch (300:13): [True: 2.37k, False: 32.3k]
  ------------------
  301|  4.31k|            case VET_FLOAT3:
  ------------------
  |  Branch (301:13): [True: 1.33k, False: 33.3k]
  ------------------
  302|  4.54k|            case VET_FLOAT4:
  ------------------
  |  Branch (302:13): [True: 225, False: 34.4k]
  ------------------
  303|  4.54k|                return VET_FLOAT1;
  304|    371|            case VET_HALF1:
  ------------------
  |  Branch (304:13): [True: 371, False: 34.3k]
  ------------------
  305|    453|            case VET_HALF2:
  ------------------
  |  Branch (305:13): [True: 82, False: 34.6k]
  ------------------
  306|    544|            case VET_HALF3:
  ------------------
  |  Branch (306:13): [True: 91, False: 34.6k]
  ------------------
  307|  1.93k|            case VET_HALF4:
  ------------------
  |  Branch (307:13): [True: 1.38k, False: 33.3k]
  ------------------
  308|  1.93k|                return VET_HALF1;
  309|    334|            case VET_DOUBLE1:
  ------------------
  |  Branch (309:13): [True: 334, False: 34.3k]
  ------------------
  310|    344|            case VET_DOUBLE2:
  ------------------
  |  Branch (310:13): [True: 10, False: 34.6k]
  ------------------
  311|    937|            case VET_DOUBLE3:
  ------------------
  |  Branch (311:13): [True: 593, False: 34.1k]
  ------------------
  312|  1.25k|            case VET_DOUBLE4:
  ------------------
  |  Branch (312:13): [True: 318, False: 34.3k]
  ------------------
  313|  1.25k|                return VET_DOUBLE1;
  314|    412|            case VET_INT1:
  ------------------
  |  Branch (314:13): [True: 412, False: 34.2k]
  ------------------
  315|    628|            case VET_INT2:
  ------------------
  |  Branch (315:13): [True: 216, False: 34.4k]
  ------------------
  316|    748|            case VET_INT3:
  ------------------
  |  Branch (316:13): [True: 120, False: 34.5k]
  ------------------
  317|    886|            case VET_INT4:
  ------------------
  |  Branch (317:13): [True: 138, False: 34.5k]
  ------------------
  318|    886|                return VET_INT1;
  319|    499|            case VET_UINT1:
  ------------------
  |  Branch (319:13): [True: 499, False: 34.2k]
  ------------------
  320|  1.29k|            case VET_UINT2:
  ------------------
  |  Branch (320:13): [True: 800, False: 33.9k]
  ------------------
  321|  1.35k|            case VET_UINT3:
  ------------------
  |  Branch (321:13): [True: 51, False: 34.6k]
  ------------------
  322|  1.61k|            case VET_UINT4:
  ------------------
  |  Branch (322:13): [True: 267, False: 34.4k]
  ------------------
  323|  1.61k|                return VET_UINT1;
  324|     20|            case VET_SHORT1:
  ------------------
  |  Branch (324:13): [True: 20, False: 34.6k]
  ------------------
  325|  1.00k|            case VET_SHORT2:
  ------------------
  |  Branch (325:13): [True: 981, False: 33.7k]
  ------------------
  326|  1.24k|            case VET_SHORT3:
  ------------------
  |  Branch (326:13): [True: 242, False: 34.4k]
  ------------------
  327|  2.54k|            case VET_SHORT4:
  ------------------
  |  Branch (327:13): [True: 1.30k, False: 33.3k]
  ------------------
  328|  2.54k|                return VET_SHORT1;
  329|     91|            case VET_USHORT1:
  ------------------
  |  Branch (329:13): [True: 91, False: 34.6k]
  ------------------
  330|    378|            case VET_USHORT2:
  ------------------
  |  Branch (330:13): [True: 287, False: 34.4k]
  ------------------
  331|    481|            case VET_USHORT3:
  ------------------
  |  Branch (331:13): [True: 103, False: 34.5k]
  ------------------
  332|    903|            case VET_USHORT4:
  ------------------
  |  Branch (332:13): [True: 422, False: 34.2k]
  ------------------
  333|    903|                return VET_USHORT1;
  334|    148|            case VET_SHORT2_NORM:
  ------------------
  |  Branch (334:13): [True: 148, False: 34.5k]
  ------------------
  335|    414|            case VET_SHORT4_NORM:
  ------------------
  |  Branch (335:13): [True: 266, False: 34.4k]
  ------------------
  336|    414|                return VET_SHORT2_NORM;
  337|    150|            case VET_USHORT2_NORM:
  ------------------
  |  Branch (337:13): [True: 150, False: 34.5k]
  ------------------
  338|  1.98k|            case VET_USHORT4_NORM:
  ------------------
  |  Branch (338:13): [True: 1.83k, False: 32.8k]
  ------------------
  339|  1.98k|                return VET_USHORT2_NORM;
  340|  1.15k|            case VET_BYTE4:
  ------------------
  |  Branch (340:13): [True: 1.15k, False: 33.5k]
  ------------------
  341|  1.15k|                return VET_BYTE4;
  342|  3.48k|            case VET_BYTE4_NORM:
  ------------------
  |  Branch (342:13): [True: 3.48k, False: 31.2k]
  ------------------
  343|  3.48k|                return VET_BYTE4_NORM;
  344|    105|            case VET_UBYTE4:
  ------------------
  |  Branch (344:13): [True: 105, False: 34.5k]
  ------------------
  345|    105|                return VET_UBYTE4;
  346|    246|            case VET_UBYTE4_NORM:
  ------------------
  |  Branch (346:13): [True: 246, False: 34.4k]
  ------------------
  347|  5.00k|            case _DETAIL_SWAP_RB:
  ------------------
  |  Branch (347:13): [True: 4.76k, False: 29.9k]
  ------------------
  348|  5.00k|                return VET_UBYTE4_NORM;
  349|  8.63k|            case VET_INT_10_10_10_2_NORM:
  ------------------
  |  Branch (349:13): [True: 8.63k, False: 26.0k]
  ------------------
  350|  8.63k|                return VET_INT_10_10_10_2_NORM;
  351|  34.7k|        };
  352|       |        // To keep compiler happy
  353|    241|        return VET_FLOAT1;
  354|  34.7k|    }
_ZN4Ogre17VertexDeclarationC2Ev:
  357|   149k|    {
  358|   149k|    }
_ZN4Ogre17VertexDeclarationD2Ev:
  361|   149k|    {
  362|   149k|    }
_ZNK4Ogre17VertexDeclaration11getElementsEv:
  365|  2.37k|    {
  366|  2.37k|        return mElementList;
  367|  2.37k|    }
_ZN4Ogre17VertexDeclaration10addElementEtmNS_17VertexElementTypeENS_21VertexElementSemanticEt:
  372|  27.6k|    {
  373|  27.6k|        mElementList.push_back(VertexElement(source, offset, theType, semantic, index));
  374|  27.6k|        notifyChanged();
  375|  27.6k|        return mElementList.back();
  376|  27.6k|    }
_ZN4Ogre17VertexDeclaration13modifyElementEttmNS_17VertexElementTypeENS_21VertexElementSemanticEt:
  444|  5.84k|    {
  445|       |        assert(elem_index < mElementList.size() && "Index out of bounds");
  446|  5.84k|        VertexElementList::iterator i = mElementList.begin();
  447|  5.84k|        std::advance(i, elem_index);
  448|  5.84k|        (*i) = VertexElement(source, offset, theType, semantic, index);
  449|  5.84k|        notifyChanged();
  450|  5.84k|    }
_ZNK4Ogre17VertexDeclaration21findElementBySemanticENS_21VertexElementSemanticEt:
  454|   131k|    {
  455|   131k|        for (auto& e : mElementList)
  ------------------
  |  Branch (455:22): [True: 11.5k, False: 129k]
  ------------------
  456|  11.5k|        {
  457|  11.5k|            if (e.getSemantic() == sem && e.getIndex() == index)
  ------------------
  |  Branch (457:17): [True: 2.51k, False: 9.01k]
  |  Branch (457:43): [True: 1.60k, False: 910]
  ------------------
  458|  1.60k|            {
  459|  1.60k|                return &e;
  460|  1.60k|            }
  461|  11.5k|        }
  462|       |
  463|   129k|        return NULL;
  464|   131k|    }
_ZNK4Ogre17VertexDeclaration20findElementsBySourceEt:
  468|  17.8k|    {
  469|  17.8k|        VertexElementList retList;
  470|  17.8k|        for (auto& e : mElementList)
  ------------------
  |  Branch (470:22): [True: 56.7k, False: 17.8k]
  ------------------
  471|  56.7k|        {
  472|  56.7k|            if (e.getSource() == source)
  ------------------
  |  Branch (472:17): [True: 25.3k, False: 31.4k]
  ------------------
  473|  25.3k|            {
  474|  25.3k|                retList.push_back(e);
  475|  25.3k|            }
  476|  56.7k|        }
  477|  17.8k|        return retList;
  478|  17.8k|    }
_ZNK4Ogre17VertexDeclaration13getVertexSizeEt:
  482|  10.5k|    {
  483|  10.5k|        size_t sz = 0;
  484|  10.5k|        for (auto& e : mElementList)
  ------------------
  |  Branch (484:22): [True: 31.0k, False: 10.5k]
  ------------------
  485|  31.0k|        {
  486|  31.0k|            if (e.getSource() == source)
  ------------------
  |  Branch (486:17): [True: 15.3k, False: 15.6k]
  ------------------
  487|  15.3k|            {
  488|  15.3k|                sz += e.getSize();
  489|       |
  490|  15.3k|            }
  491|  31.0k|        }
  492|  10.5k|        return sz;
  493|  10.5k|    }
_ZN4Ogre19VertexBufferBindingC2Ev:
  676|   149k|    VertexBufferBinding::VertexBufferBinding() : mHighIndex(0)
  677|   149k|    {
  678|   149k|    }
_ZN4Ogre19VertexBufferBindingD2Ev:
  681|   149k|    {
  682|   149k|        unsetAllBindings();
  683|   149k|    }
_ZN4Ogre19VertexBufferBinding10setBindingEtRKNS_9SharedPtrINS_20HardwareVertexBufferEEE:
  686|  10.0k|    {
  687|       |        // NB will replace any existing buffer ptr at this index, and will thus cause
  688|       |        // reference count to decrement on that buffer (possibly destroying it)
  689|  10.0k|        mBindingMap[index] = buffer;
  690|  10.0k|        mHighIndex = std::max(mHighIndex, (unsigned short)(index+1));
  691|  10.0k|    }
_ZN4Ogre19VertexBufferBinding16unsetAllBindingsEv:
  706|   149k|    {
  707|   149k|        mBindingMap.clear();
  708|   149k|        mHighIndex = 0;
  709|   149k|    }
_ZNK4Ogre19VertexBufferBinding11getBindingsEv:
  713|   144k|    {
  714|   144k|        return mBindingMap;
  715|   144k|    }
_ZNK4Ogre19VertexBufferBinding9getBufferEt:
  718|  1.35k|    {
  719|  1.35k|        VertexBufferBindingMap::const_iterator i = mBindingMap.find(index);
  720|  1.35k|        if (i == mBindingMap.end())
  ------------------
  |  Branch (720:13): [True: 45, False: 1.30k]
  ------------------
  721|     45|        {
  722|     45|            OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "No buffer is bound to that index.",
  723|     45|                "VertexBufferBinding::getBuffer");
  724|     45|        }
  725|  1.30k|        return i->second;
  726|  1.35k|    }
_ZNK4Ogre19VertexBufferBinding13isBufferBoundEt:
  729|  38.9k|    {
  730|  38.9k|        return mBindingMap.find(index) != mBindingMap.end();
  731|  38.9k|    }

_ZN4Ogre8KeyFrameC2EPKNS_14AnimationTrackEf:
   37|  5.92k|        : mTime(time), mParentTrack(parent)
   38|  5.92k|    {
   39|  5.92k|    }
_ZN4Ogre17TransformKeyFrameC2EPKNS_14AnimationTrackEf:
   59|  1.06k|        :KeyFrame(parent, time), mTranslate(Vector3::ZERO), 
   60|  1.06k|        mScale(Vector3::UNIT_SCALE), mRotate(Quaternion::IDENTITY) 
   61|  1.06k|    {
   62|  1.06k|    }
_ZN4Ogre17TransformKeyFrame12setTranslateERKNS_6VectorILi3EfEE:
   65|  1.06k|    {
   66|  1.06k|        mTranslate = trans;
   67|  1.06k|        if (mParentTrack)
  ------------------
  |  Branch (67:13): [True: 1.06k, False: 0]
  ------------------
   68|  1.06k|            mParentTrack->_keyFrameDataChanged();
   69|  1.06k|    }
_ZN4Ogre17TransformKeyFrame8setScaleERKNS_6VectorILi3EfEE:
   77|    267|    {
   78|    267|        mScale = scale;
   79|    267|        if (mParentTrack)
  ------------------
  |  Branch (79:13): [True: 267, False: 0]
  ------------------
   80|    267|            mParentTrack->_keyFrameDataChanged();
   81|    267|    }
_ZN4Ogre17TransformKeyFrame11setRotationERKNS_10QuaternionE:
   89|  1.06k|    {
   90|  1.06k|        mRotate = rot;
   91|  1.06k|        if (mParentTrack)
  ------------------
  |  Branch (91:13): [True: 1.06k, False: 0]
  ------------------
   92|  1.06k|            mParentTrack->_keyFrameDataChanged();
   93|  1.06k|    }
_ZN4Ogre19VertexMorphKeyFrameC2EPKNS_14AnimationTrackEf:
  110|  2.85k|        : KeyFrame(parent, time)
  111|  2.85k|    {
  112|  2.85k|    }
_ZN4Ogre19VertexMorphKeyFrame15setVertexBufferERKNS_9SharedPtrINS_20HardwareVertexBufferEEE:
  115|  2.85k|    {
  116|  2.85k|        mBuffer = buf;
  117|  2.85k|    }
_ZN4Ogre18VertexPoseKeyFrameC2EPKNS_14AnimationTrackEf:
  133|  2.01k|        :KeyFrame(parent, time)
  134|  2.01k|    {
  135|  2.01k|    }
_ZN4Ogre18VertexPoseKeyFrame16addPoseReferenceEtf:
  138|  1.56k|    {
  139|  1.56k|        mPoseRefs.push_back(PoseRef(poseIndex, influence));
  140|  1.56k|    }

_ZN4Ogre11LodStrategyC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   35|      4|        : mName(name)
   36|      4|    { }
_ZNK4Ogre11LodStrategy18transformUserValueEf:
   42|    514|    {
   43|       |        // No transformation by default
   44|    514|        return userValue;
   45|    514|    }

_ZN4Ogre18LodStrategyManager12getSingletonEv:
   43|  17.2k|    {
   44|       |        assert( msSingleton );  return ( *msSingleton );
   45|  17.2k|    }
_ZN4Ogre18LodStrategyManagerC2Ev:
   48|      1|    {
   49|       |        // Add distance strategies for bounding box and bounding sphere
   50|      1|        LodStrategy *strategy = OGRE_NEW DistanceLodBoxStrategy();
   51|      1|        addStrategy(strategy);
   52|      1|        strategy = OGRE_NEW DistanceLodSphereStrategy();
   53|      1|        addStrategy(strategy);
   54|       |
   55|       |        // Set the default strategy to distance_sphere
   56|      1|        setDefaultStrategy(strategy);
   57|       |
   58|       |        // Add pixel-count strategies (internally based on bounding sphere)
   59|      1|        strategy = OGRE_NEW AbsolutePixelCountLodStrategy();
   60|      1|        addStrategy(strategy);
   61|       |        strategy = OGRE_NEW ScreenRatioPixelCountLodStrategy();
   62|      1|        addStrategy(strategy);
   63|      1|    }
_ZN4Ogre18LodStrategyManager11addStrategyEPNS_11LodStrategyE:
   72|      4|    {
   73|       |        // Check for invalid strategy name
   74|      4|        if (strategy->getName() == "default")
  ------------------
  |  Branch (74:13): [True: 0, False: 4]
  ------------------
   75|      4|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Lod strategy name must not be \"default\".", "LodStrategyManager::addStrategy");
   76|       |
   77|       |        // Insert the strategy into the map with its name as the key
   78|      4|        mStrategies.insert(std::make_pair(strategy->getName(), strategy));
   79|      4|    }
_ZN4Ogre18LodStrategyManager11getStrategyERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  110|  9.02k|    {
  111|       |        // If name is "default", return the default strategy instead of performing a lookup
  112|  9.02k|        if (name == "default") {
  ------------------
  |  Branch (112:13): [True: 421, False: 8.60k]
  ------------------
  113|    421|            return getDefaultStrategy();
  114|  8.60k|        } else if (name == "Distance") {
  ------------------
  |  Branch (114:20): [True: 544, False: 8.06k]
  ------------------
  115|    544|            return getStrategy("distance_box"); // Backward compatibility for loading old meshes.
  116|  8.06k|        } else if (name == "PixelCount") {
  ------------------
  |  Branch (116:20): [True: 435, False: 7.62k]
  ------------------
  117|    435|            return getStrategy("pixel_count"); // Backward compatibility for loading old meshes.
  118|    435|        }
  119|       |        // Find strategy with specified name
  120|  7.62k|        StrategyMap::iterator it = mStrategies.find(name);
  121|       |
  122|       |        // If not found, return null
  123|  7.62k|        if (it == mStrategies.end())
  ------------------
  |  Branch (123:13): [True: 6.56k, False: 1.05k]
  ------------------
  124|  6.56k|            return 0;
  125|       |
  126|       |        // Otherwise, return the strategy
  127|  1.05k|        return it->second;
  128|  7.62k|    }
_ZN4Ogre18LodStrategyManager18setDefaultStrategyEPNS_11LodStrategyE:
  131|      1|    {
  132|      1|        mDefaultStrategy = strategy;
  133|      1|    }
_ZN4Ogre18LodStrategyManager18getDefaultStrategyEv:
  142|  9.64k|    {
  143|  9.64k|        return mDefaultStrategy;
  144|  9.64k|    }

_ZN4Ogre3LogC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbb:
   54|      1|        mLogLevel(LML_NORMAL), mDebugOut(debuggerOutput),
   55|      1|        mSuppressFile(suppressFile), mTimeStamp(true), mLogName(name), mTermHasColours(false)
   56|      1|    {
   57|      1|        if (!mSuppressFile)
  ------------------
  |  Branch (57:13): [True: 0, False: 1]
  ------------------
   58|      0|        {
   59|      0|            FileSystemUtil::openOutputFile(mLog, name);
   60|       |
   61|       |#if (OGRE_PLATFORM == OGRE_PLATFORM_WIN32 || OGRE_PLATFORM == OGRE_PLATFORM_WINRT) && _WIN32_WINNT >= _WIN32_WINNT_VISTA
   62|       |            // Register log file to be collected by Windows Error Reporting
   63|       |            const std::wstring wname = FileSystemUtil::toWide(name);
   64|       |            if (!wname.empty())
   65|       |                WerRegisterFile(wname.c_str(), WerRegFileTypeOther, WER_FILE_ANONYMOUS_DATA);
   66|       |#endif
   67|      0|        }
   68|       |
   69|      1|#if OGRE_PLATFORM != OGRE_PLATFORM_WINRT
   70|      1|        char* val = getenv("OGRE_MIN_LOGLEVEL");
   71|      1|        int min_lml;
   72|      1|        if(val && StringConverter::parse(val, min_lml))
  ------------------
  |  Branch (72:12): [True: 0, False: 1]
  |  Branch (72:12): [True: 0, False: 1]
  |  Branch (72:19): [True: 0, False: 0]
  ------------------
   73|      0|            setMinLogLevel(LogMessageLevel(min_lml));
   74|       |
   75|      1|        if(mDebugOut)
  ------------------
  |  Branch (75:12): [True: 0, False: 1]
  ------------------
   76|      0|        {
   77|      0|            val = getenv("TERM");
   78|      0|            mTermHasColours = val && String(val).find("xterm") != String::npos;
  ------------------
  |  Branch (78:31): [True: 0, False: 0]
  |  Branch (78:38): [True: 0, False: 0]
  ------------------
   79|      0|        }
   80|      1|#endif
   81|      1|    }
_ZN4Ogre3Log10logMessageERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_15LogMessageLevelEb:
   94|   290k|    {
   95|   290k|        OGRE_LOCK_AUTO_MUTEX;
   96|   290k|        if (lml >= mLogLevel)
  ------------------
  |  Branch (96:13): [True: 18.6k, False: 271k]
  ------------------
   97|  18.6k|        {
   98|  18.6k|            bool skipThisMessage = false;
   99|  18.6k|            for(auto & l : mListeners)
  ------------------
  |  Branch (99:26): [True: 0, False: 18.6k]
  ------------------
  100|      0|                l->messageLogged( message, lml, maskDebug, mLogName, skipThisMessage);
  101|       |            
  102|  18.6k|            if (!skipThisMessage)
  ------------------
  |  Branch (102:17): [True: 18.6k, False: 0]
  ------------------
  103|  18.6k|            {
  104|  18.6k|                if (mDebugOut && !maskDebug)
  ------------------
  |  Branch (104:21): [True: 0, False: 18.6k]
  |  Branch (104:34): [True: 0, False: 0]
  ------------------
  105|      0|                {
  106|       |#    if (OGRE_PLATFORM == OGRE_PLATFORM_WIN32 || OGRE_PLATFORM == OGRE_PLATFORM_WINRT) && OGRE_DEBUG_MODE
  107|       |                    OutputDebugStringA("Ogre: ");
  108|       |                    OutputDebugStringA(message.c_str());
  109|       |                    OutputDebugStringA("\n");
  110|       |#    endif
  111|       |
  112|      0|                    std::ostream& os = int(lml) >= int(LML_WARNING) ? std::cerr : std::cout;
  ------------------
  |  Branch (112:40): [True: 0, False: 0]
  ------------------
  113|       |
  114|      0|                    if(mTermHasColours) {
  ------------------
  |  Branch (114:24): [True: 0, False: 0]
  ------------------
  115|      0|                        if(lml == LML_WARNING)
  ------------------
  |  Branch (115:28): [True: 0, False: 0]
  ------------------
  116|      0|                            os << YELLOW;
  117|      0|                        if(lml == LML_CRITICAL)
  ------------------
  |  Branch (117:28): [True: 0, False: 0]
  ------------------
  118|      0|                            os << RED;
  119|      0|                    }
  120|       |
  121|      0|                    os << message;
  122|       |
  123|      0|                    if(mTermHasColours) {
  ------------------
  |  Branch (123:24): [True: 0, False: 0]
  ------------------
  124|      0|                        os << RESET;
  125|      0|                    }
  126|       |
  127|      0|                    os << std::endl;
  128|      0|                }
  129|       |
  130|       |                // Write time into log
  131|  18.6k|                if (!mSuppressFile)
  ------------------
  |  Branch (131:21): [True: 0, False: 18.6k]
  ------------------
  132|      0|                {
  133|      0|                    if (mTimeStamp)
  ------------------
  |  Branch (133:25): [True: 0, False: 0]
  ------------------
  134|      0|                    {
  135|      0|                        auto t = std::time(nullptr);
  136|      0|                        auto pTime = std::localtime(&t);
  137|      0|                        mLog << std::put_time(pTime, "%H:%M:%S: ");
  138|      0|                    }
  139|      0|                    mLog << message << std::endl;
  140|       |
  141|       |                    // Flush stcmdream to ensure it is written (incase of a crash, we need log to be up to date)
  142|      0|                    mLog.flush();
  143|      0|                }
  144|  18.6k|            }
  145|  18.6k|        }
  146|   290k|    }
_ZN4Ogre3Log14setMinLogLevelENS_15LogMessageLevelE:
  170|      1|    {
  171|      1|        OGRE_LOCK_AUTO_MUTEX;
  172|      1|        mLogLevel = lml;
  173|      1|    }
_ZN4Ogre3Log6streamENS_15LogMessageLevelEb:
  193|  93.1k|    {
  194|  93.1k|        return Stream(this, lml, maskDebug);
  195|       |
  196|  93.1k|    }

_ZN4Ogre10LogManager12getSingletonEv:
   39|   290k|    {  
   40|       |        assert( msSingleton );  return ( *msSingleton );  
   41|   290k|    }
_ZN4Ogre10LogManagerC2Ev:
   44|      1|    {
   45|       |        mDefaultLog = NULL;
   46|      1|    }
_ZN4Ogre10LogManager9createLogERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbbb:
   61|      1|    {
   62|      1|        OGRE_LOCK_AUTO_MUTEX;
   63|       |
   64|      1|        Log* newLog = OGRE_NEW Log(name, debuggerOutput, suppressFileOutput);
   65|       |
   66|      1|        if( !mDefaultLog || defaultLog )
  ------------------
  |  Branch (66:13): [True: 1, False: 0]
  |  Branch (66:29): [True: 0, False: 0]
  ------------------
   67|      1|        {
   68|      1|            mDefaultLog = newLog;
   69|      1|        }
   70|       |
   71|      1|        mLogs.emplace(name, newLog);
   72|       |
   73|      1|        return newLog;
   74|      1|    }
_ZN4Ogre10LogManager10logMessageERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_15LogMessageLevelEb:
  125|   197k|    {
  126|   197k|        OGRE_LOCK_AUTO_MUTEX;
  127|   197k|        if (mDefaultLog)
  ------------------
  |  Branch (127:13): [True: 197k, False: 0]
  ------------------
  128|   197k|        {
  129|   197k|            mDefaultLog->logMessage(message, lml, maskDebug);
  130|   197k|        }
  131|   197k|    }
_ZN4Ogre10LogManager8logErrorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
  134|  18.6k|    {
  135|  18.6k|        stream(LML_CRITICAL, maskDebug) << "Error: " << message;
  136|  18.6k|    }
_ZN4Ogre10LogManager10logWarningERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
  139|  3.14k|    {
  140|  3.14k|        stream(LML_WARNING, maskDebug) << "Warning: " << message;
  141|  3.14k|    }
_ZN4Ogre10LogManager14setMinLogLevelENS_15LogMessageLevelE:
  155|      1|    {
  156|      1|        OGRE_LOCK_AUTO_MUTEX;
  157|      1|        if (mDefaultLog)
  ------------------
  |  Branch (157:13): [True: 1, False: 0]
  ------------------
  158|      1|        {
  159|      1|            mDefaultLog->setMinLogLevel(lml);
  160|      1|        }
  161|      1|    }
_ZN4Ogre10LogManager6streamENS_15LogMessageLevelEb:
  164|  93.1k|    {
  165|  93.1k|            OGRE_LOCK_AUTO_MUTEX;
  166|  93.1k|        OgreAssert(mDefaultLog, "Default log not found");
  ------------------
  |  Branch (166:9): [True: 0, False: 93.1k]
  ------------------
  167|  93.1k|        return mDefaultLog->stream(lml, maskDebug);
  168|  93.1k|    }

_ZN4Ogre8MaterialC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE:
   39|      3|        :Resource(creator, name, handle, group, false, NULL),
   40|      3|         mReceiveShadows(true),
   41|      3|         mTransparencyCastsShadows(false),
   42|      3|         mCompilationRequired(true)
   43|      3|    {
   44|       |        // Override isManual, not applicable for Material (we always want to call loadImpl)
   45|      3|        if(isManual)
  ------------------
  |  Branch (45:12): [True: 0, False: 3]
  ------------------
   46|      0|        {
   47|      0|            LogManager::getSingleton().logWarning("Material " + name +
   48|      0|                " was requested with isManual=true, but this is not applicable " 
   49|      0|                "for materials; the flag has been reset to false");
   50|      0|        }
   51|       |
   52|       |        // Initialise to default strategy
   53|      3|        mLodStrategy = LodStrategyManager::getSingleton().getDefaultStrategy();
   54|       |
   55|      3|        mLodValues.push_back(0.0f);
   56|       |
   57|      3|        applyDefaults();
   58|       |
   59|       |        /* For consistency with StringInterface, but we don't add any parameters here
   60|       |        That's because the Resource implementation of StringInterface is to
   61|       |        list all the options that need to be set before loading, of which 
   62|       |        we have none as such. Full details can be set through scripts.
   63|       |        */ 
   64|      3|        createParamDictionary("Material");
   65|      3|    }
_ZN4Ogre8MaterialaSERKS0_:
   76|      2|    {
   77|      2|        if (this == &rhs)
  ------------------
  |  Branch (77:13): [True: 0, False: 2]
  ------------------
   78|      0|            return *this;
   79|       |
   80|      2|        Resource::operator=(rhs);
   81|      2|        mReceiveShadows = rhs.mReceiveShadows;
   82|      2|        mTransparencyCastsShadows = rhs.mTransparencyCastsShadows;
   83|       |
   84|       |        // Copy Techniques
   85|      2|        this->removeAllTechniques();
   86|      2|        for(auto *t : rhs.mTechniques)
  ------------------
  |  Branch (86:21): [True: 2, False: 2]
  ------------------
   87|      2|        {
   88|      2|            Technique* tech = this->createTechnique();
   89|      2|            *tech = *t;
   90|      2|            if (t->isSupported())
  ------------------
  |  Branch (90:17): [True: 0, False: 2]
  ------------------
   91|      0|            {
   92|      0|                insertSupportedTechnique(tech);
   93|      0|            }
   94|      2|        }
   95|       |
   96|       |        // Also copy LOD information
   97|      2|        mUserLodValues = rhs.mUserLodValues;
   98|      2|        mLodValues = rhs.mLodValues;
   99|      2|        mLodStrategy = rhs.mLodStrategy;
  100|      2|        mCompilationRequired = rhs.mCompilationRequired;
  101|       |
  102|       |        // creating techniques moves us into unloaded state
  103|       |        // insertSupportedTechnique is equivalent to prepare
  104|      2|        if(rhs.isLoaded())
  ------------------
  |  Branch (104:12): [True: 0, False: 2]
  ------------------
  105|      0|            load();
  106|       |
  107|      2|        return *this;
  108|      2|    }
_ZN4Ogre8Material13applyDefaultsEv:
  217|      3|    {
  218|      3|        MaterialPtr defaults = MaterialManager::getSingleton().getDefaultSettings();
  219|       |
  220|      3|        if (defaults)
  ------------------
  |  Branch (220:13): [True: 2, False: 1]
  ------------------
  221|      2|        {
  222|       |            // save name & handle
  223|      2|            String savedName = mName;
  224|      2|            String savedGroup = mGroup;
  225|      2|            ResourceHandle savedHandle = mHandle;
  226|      2|            *this = *defaults;
  227|       |            // restore name & handle
  228|      2|            mName = savedName;
  229|      2|            mHandle = savedHandle;
  230|      2|            mGroup = savedGroup;
  231|      2|        }
  232|      3|        _notifyNeedsRecompile();
  233|       |
  234|      3|    }
_ZN4Ogre8Material15createTechniqueEv:
  237|      3|    {
  238|       |        Technique *t = OGRE_NEW Technique(this);
  239|      3|        mTechniques.push_back(t);
  240|      3|        _notifyNeedsRecompile();
  241|      3|        return t;
  242|      3|    }
_ZN4Ogre8Material19removeAllTechniquesEv:
  367|      2|    {
  368|      2|        for (auto *t : mTechniques)
  ------------------
  |  Branch (368:22): [True: 0, False: 2]
  ------------------
  369|      0|        {
  370|       |            OGRE_DELETE t;
  371|      0|        }
  372|      2|        mTechniques.clear();
  373|      2|        clearBestTechniqueList();
  374|      2|    }
_ZN4Ogre8Material22clearBestTechniqueListEv:
  437|      2|    {
  438|      2|        mSupportedTechniques.clear();
  439|      2|        mBestTechniquesBySchemeList.clear();
  440|      2|        _notifyNeedsRecompile();
  441|      2|    }
_ZN4Ogre8Material18setLightingEnabledEb:
  493|      1|    void Material::setLightingEnabled(bool enabled) { ALL_TECHNIQUES(setLightingEnabled(enabled)); }
  ------------------
  |  |  443|      1|    #define ALL_TECHNIQUES(fncall) for(auto t : mTechniques) t->fncall
  |  |  ------------------
  |  |  |  Branch (443:47): [True: 1, False: 1]
  |  |  ------------------
  ------------------
_ZN4Ogre8Material21_notifyNeedsRecompileEv:
  534|      8|    {
  535|      8|        mCompilationRequired = true;
  536|       |        // Also need to unload to ensure we loaded any new items
  537|      8|        if (isLoaded()) // needed to stop this being called in 'loading' state
  ------------------
  |  Branch (537:13): [True: 0, False: 8]
  ------------------
  538|      0|            unload();
  539|      8|    }
_ZN4Ogre8Material14setLodStrategyEPNS_11LodStrategyE:
  579|      1|    {
  580|      1|        mLodStrategy = lodStrategy;
  581|       |
  582|      1|        assert(mLodValues.size());
  583|      1|        mLodValues[0] = mLodStrategy->getBaseValue();
  584|       |
  585|       |        // Re-transform all user LOD values (starting at index 1, no need to transform base value)
  586|      1|        for (size_t i = 1; i < mUserLodValues.size(); ++i)
  ------------------
  |  Branch (586:28): [True: 0, False: 1]
  ------------------
  587|      0|            mLodValues[i] = mLodStrategy->transformUserValue(mUserLodValues[i]);
  588|      1|    }

_ZN4Ogre15MaterialManager15getSingletonPtrEv:
   40|      2|    {
   41|      2|        return msSingleton;
   42|      2|    }
_ZN4Ogre15MaterialManager12getSingletonEv:
   44|   197k|    {
   45|       |        assert( msSingleton );  return ( *msSingleton );
   46|   197k|    }
_ZN4Ogre15MaterialManagerC2Ev:
   50|      1|    {
   51|       |        // Loading order
   52|      1|        mLoadOrder = 100.0f;
   53|       |        // Scripting is supported by this manager
   54|       |
   55|       |        // Resource type
   56|      1|        mResourceType = "Material";
   57|       |
   58|       |        // Register with resource group manager
   59|      1|        ResourceGroupManager::getSingleton()._registerResourceManager(mResourceType, this);
   60|       |
   61|       |        // Default scheme
   62|      1|        mActiveSchemeIndex = 0;
   63|      1|        mActiveSchemeName = MSN_DEFAULT;
   64|      1|        mSchemes[mActiveSchemeName] = 0;
   65|       |
   66|      1|    }
_ZN4Ogre15MaterialManager10createImplERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmS9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
   83|      3|    {
   84|       |        return OGRE_NEW Material(this, name, handle, group, isManual, loader);
   85|      3|    }
_ZN4Ogre15MaterialManager6createERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
   90|      3|    {
   91|      3|        return static_pointer_cast<Material>(createResource(name,group,isManual,loader,createParams));
   92|      3|    }
_ZNK4Ogre15MaterialManager9getByNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
   95|   197k|    {
   96|   197k|        return static_pointer_cast<Material>(getResourceByName(name, groupName));
   97|   197k|    }
_ZN4Ogre15MaterialManager10initialiseEv:
  111|      1|    {
  112|       |        // Set up default material - don't use name constructor as we want to avoid applying defaults
  113|      1|        mDefaultSettings = create("DefaultSettings", ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
  114|       |        // Add a single technique and pass, non-programmable
  115|      1|        mDefaultSettings->createTechnique()->createPass();
  116|       |
  117|       |        // Set the default LOD strategy
  118|      1|        mDefaultSettings->setLodStrategy(LodStrategyManager::getSingleton().getDefaultStrategy());
  119|       |
  120|       |        // Set up a lit base white material
  121|      1|        create("BaseWhite", ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
  122|       |        // Set up an unlit base white material
  123|      1|        MaterialPtr baseWhiteNoLighting = create("BaseWhiteNoLighting",
  124|      1|        ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
  125|      1|        baseWhiteNoLighting->setLightingEnabled(false);
  126|       |
  127|      1|    }
_ZN4Ogre15MaterialManager38_notifyBeforeIlluminationPassesClearedEPNS_9TechniqueE:
  273|      2|	{
  274|       |		// First, check the scheme specific listeners
  275|      2|		ListenerMap::iterator it = mListenerMap.find(mActiveSchemeName);
  276|      2|		if(it != mListenerMap.end())
  ------------------
  |  Branch (276:6): [True: 0, False: 2]
  ------------------
  277|      0|		{
  278|      0|			ListenerList& listenerList = it->second;
  279|      0|			for(auto & i : listenerList)
  ------------------
  |  Branch (279:17): [True: 0, False: 0]
  ------------------
  280|      0|			{
  281|      0|				bool handled = i->beforeIlluminationPassesCleared(tech);
  282|      0|				if(handled)
  ------------------
  |  Branch (282:8): [True: 0, False: 0]
  ------------------
  283|      0|					return;
  284|      0|			}
  285|      0|		}
  286|       |
  287|       |		//If no success, check generic listeners
  288|      2|		it = mListenerMap.find(BLANKSTRING);
  289|      2|		if(it != mListenerMap.end())
  ------------------
  |  Branch (289:6): [True: 0, False: 2]
  ------------------
  290|      0|		{
  291|      0|			ListenerList& listenerList = it->second;
  292|      0|			for(auto & i : listenerList)
  ------------------
  |  Branch (292:17): [True: 0, False: 0]
  ------------------
  293|      0|			{
  294|      0|				bool handled = i->beforeIlluminationPassesCleared(tech);
  295|      0|				if(handled)
  ------------------
  |  Branch (295:8): [True: 0, False: 0]
  ------------------
  296|      0|					return;
  297|      0|			}
  298|      0|		}
  299|      2|	}

_ZN4Ogre4Math22boundingRadiusFromAABBERKNS_14AxisAlignedBoxE:
  762|  3.45k|    {
  763|  3.45k|        const Vector3& max = aabb.getMaximum();
  764|  3.45k|        const Vector3& min = aabb.getMinimum();
  765|       |
  766|  3.45k|        Vector3 magnitude = max;
  767|  3.45k|        magnitude.makeCeil(-max);
  768|  3.45k|        magnitude.makeCeil(min);
  769|  3.45k|        magnitude.makeCeil(-min);
  770|       |
  771|  3.45k|        return magnitude.length();
  772|  3.45k|    }

_ZN4Ogre4MeshC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE:
   45|  5.79k|        : Resource(creator, name, handle, group, isManual, loader),
   46|  5.79k|        mBoundRadius(0.0f),
   47|  5.79k|        mBoneBoundingRadius(0.0f),
   48|  5.79k|        mBoneAssignmentsOutOfDate(false),
   49|  5.79k|        mHasManualLodLevel(false),
   50|  5.79k|        mLodStrategy(LodStrategyManager::getSingleton().getDefaultStrategy()),
   51|  5.79k|        mBufferManager(0),
   52|  5.79k|        mVertexBufferUsage(HBU_GPU_ONLY),
   53|  5.79k|        mIndexBufferUsage(HBU_GPU_ONLY),
   54|  5.79k|        mVertexBufferShadowBuffer(false),
   55|  5.79k|        mIndexBufferShadowBuffer(false),
   56|  5.79k|        mPreparedForShadowVolumes(false),
   57|  5.79k|        mEdgeListsBuilt(false),
   58|  5.79k|        mAutoBuildEdgeLists(false), // will be set to true by serializers of 1.20 and below
   59|  5.79k|        mSharedVertexDataAnimationType(VAT_NONE),
   60|  5.79k|        mSharedVertexDataAnimationIncludesNormals(false),
   61|  5.79k|        mAnimationTypesDirty(true),
   62|  5.79k|        mPosesIncludeNormals(false),
   63|  5.79k|        sharedVertexData(0)
   64|  5.79k|    {
   65|       |        // Init first (manual) lod
   66|  5.79k|        MeshLodUsage lod;
   67|  5.79k|        lod.userValue = 0; // User value not used for base LOD level
   68|  5.79k|        lod.value = getLodStrategy()->getBaseValue();
   69|  5.79k|        mMeshLodUsageList.push_back(lod);
   70|  5.79k|    }
_ZN4Ogre4MeshD2Ev:
   73|  5.79k|    {
   74|  5.79k|        if (!HardwareBufferManager::getSingletonPtr()) // LogManager might be also gone already
  ------------------
  |  Branch (74:13): [True: 0, False: 5.79k]
  ------------------
   75|      0|        {
   76|      0|            printf("ERROR: '%s' is being destroyed after HardwareBufferManager. This is a bug in user code.\n", mName.c_str());
   77|      0|            OgreAssertDbg(false,  "Mesh destroyed after HardwareBufferManager"); // assert in debug mode
   78|      0|            return; // try not to crash
   79|      0|        }
   80|       |        // have to call this here reather than in Resource destructor
   81|       |        // since calling virtual methods in base destructors causes crash
   82|  5.79k|        unload();
   83|  5.79k|    }
_ZN4Ogre4Mesh24getHardwareBufferManagerEv:
   86|   110k|    {
   87|   110k|        return mBufferManager ? mBufferManager : HardwareBufferManager::getSingletonPtr();
  ------------------
  |  Branch (87:16): [True: 0, False: 110k]
  ------------------
   88|   110k|    }
_ZN4Ogre4Mesh13createSubMeshEv:
   91|   197k|    {
   92|   197k|        SubMesh* sub = OGRE_NEW SubMesh();
   93|   197k|        sub->parent = this;
   94|       |
   95|   197k|        mSubMeshList.push_back(sub);
   96|       |
   97|   197k|        if (isLoaded())
  ------------------
  |  Branch (97:13): [True: 197k, False: 0]
  ------------------
   98|   197k|            _dirtyState();
   99|       |
  100|   197k|        return sub;
  101|   197k|    }
_ZN4Ogre4Mesh11nameSubMeshERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEt:
  155|  10.0k|    {
  156|  10.0k|        mSubMeshNameMap[name] = index ;
  157|  10.0k|    }
_ZN4Ogre4Mesh12postLoadImplEv:
  174|  5.79k|    {
  175|       |        // Prepare for shadow volumes?
  176|  5.79k|        if (MeshManager::getSingleton().getPrepareAllMeshesForShadowVolumes())
  ------------------
  |  Branch (176:13): [True: 0, False: 5.79k]
  ------------------
  177|      0|        {
  178|      0|            if (mEdgeListsBuilt || mAutoBuildEdgeLists)
  ------------------
  |  Branch (178:17): [True: 0, False: 0]
  |  Branch (178:36): [True: 0, False: 0]
  ------------------
  179|      0|            {
  180|      0|                prepareForShadowVolume();
  181|      0|            }
  182|       |
  183|      0|            if (!mEdgeListsBuilt && mAutoBuildEdgeLists)
  ------------------
  |  Branch (183:17): [True: 0, False: 0]
  |  Branch (183:37): [True: 0, False: 0]
  ------------------
  184|      0|            {
  185|      0|                buildEdgeList();
  186|      0|            }
  187|      0|        }
  188|  5.79k|#if !OGRE_NO_MESHLOD
  189|       |        // The loading process accesses LOD usages directly, so
  190|       |        // transformation of user values must occur after loading is complete.
  191|       |
  192|       |        // Transform user LOD values (starting at index 1, no need to transform base value)
  193|  5.79k|        for (auto& m : mMeshLodUsageList)
  ------------------
  |  Branch (193:22): [True: 5.79k, False: 5.79k]
  ------------------
  194|  5.79k|            m.value = mLodStrategy->transformUserValue(m.userValue);
  195|       |        // Rewrite first value
  196|  5.79k|        mMeshLodUsageList[0].value = mLodStrategy->getBaseValue();
  197|  5.79k|#endif
  198|  5.79k|    }
_ZN4Ogre4Mesh10unloadImplEv:
  241|  5.79k|    {
  242|       |        // Teardown submeshes
  243|  5.79k|        for (auto & i : mSubMeshList)
  ------------------
  |  Branch (243:23): [True: 197k, False: 5.79k]
  ------------------
  244|   197k|        {
  245|   197k|            OGRE_DELETE i;
  246|   197k|        }
  247|  5.79k|        if (sharedVertexData)
  ------------------
  |  Branch (247:13): [True: 1.40k, False: 4.39k]
  ------------------
  248|  1.40k|        {
  249|  1.40k|            resetVertexData();
  250|  1.40k|        }
  251|       |        // Clear SubMesh lists
  252|  5.79k|        mSubMeshList.clear();
  253|  5.79k|        mSubMeshNameMap.clear();
  254|       |
  255|  5.79k|        freeEdgeList();
  256|  5.79k|#if !OGRE_NO_MESHLOD
  257|       |        // Removes all LOD data
  258|  5.79k|        removeLodLevels();
  259|  5.79k|#endif
  260|  5.79k|        mPreparedForShadowVolumes = false;
  261|       |
  262|       |        // remove all poses & animations
  263|  5.79k|        removeAllAnimations();
  264|  5.79k|        removeAllPoses();
  265|       |
  266|       |        // Clear bone assignments
  267|  5.79k|        mBoneAssignments.clear();
  268|  5.79k|        mBoneAssignmentsOutOfDate = false;
  269|       |
  270|       |        // Removes reference to skeleton
  271|  5.79k|        mSkeleton.reset();
  272|  5.79k|    }
_ZN4Ogre4Mesh10_setBoundsERKNS_14AxisAlignedBoxEb:
  388|  3.45k|    {
  389|  3.45k|        mAABB = bounds;
  390|  3.45k|        mBoundRadius = Math::boundingRadiusFromAABB(mAABB);
  391|       |
  392|  3.45k|        if( mAABB.isFinite() )
  ------------------
  |  Branch (392:13): [True: 3.45k, False: 0]
  ------------------
  393|  3.45k|        {
  394|  3.45k|            Vector3 max = mAABB.getMaximum();
  395|  3.45k|            Vector3 min = mAABB.getMinimum();
  396|       |
  397|  3.45k|            if (pad)
  ------------------
  |  Branch (397:17): [True: 0, False: 3.45k]
  ------------------
  398|      0|            {
  399|       |                // Pad out the AABB a little, helps with most bounds tests
  400|      0|                Vector3 scaler = (max - min) * MeshManager::getSingleton().getBoundsPaddingFactor();
  401|      0|                mAABB.setExtents(min  - scaler, max + scaler);
  402|       |                // Pad out the sphere a little too
  403|      0|                mBoundRadius = mBoundRadius + (mBoundRadius * MeshManager::getSingleton().getBoundsPaddingFactor());
  404|      0|            }
  405|  3.45k|        }
  406|  3.45k|    }
_ZN4Ogre4Mesh24_setBoundingSphereRadiusEf:
  409|  3.45k|    {
  410|  3.45k|        mBoundRadius = radius;
  411|  3.45k|    }
_ZN4Ogre4Mesh15setSkeletonNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  480|  18.4k|    {
  481|  18.4k|        if (skelName != getSkeletonName())
  ------------------
  |  Branch (481:13): [True: 17.8k, False: 601]
  ------------------
  482|  17.8k|        {
  483|  17.8k|            if (skelName.empty())
  ------------------
  |  Branch (483:17): [True: 0, False: 17.8k]
  ------------------
  484|      0|            {
  485|       |                // No skeleton
  486|      0|                mSkeleton.reset();
  487|      0|            }
  488|  17.8k|            else
  489|  17.8k|            {
  490|       |                // Load skeleton
  491|  17.8k|                try {
  492|  17.8k|                    mSkeleton = static_pointer_cast<Skeleton>(SkeletonManager::getSingleton().load(skelName, mGroup));
  493|  17.8k|                }
  494|  17.8k|                catch (...)
  495|  17.8k|                {
  496|  17.8k|                    mSkeleton.reset();
  497|       |                    // Log this error
  498|  17.8k|                    String msg = "Unable to load skeleton '";
  499|  17.8k|                    msg += skelName + "' for Mesh '" + mName + "'. This Mesh will not be animated.";
  500|  17.8k|                    LogManager::getSingleton().logError(msg);
  501|       |
  502|  17.8k|                }
  503|       |
  504|       |
  505|  17.8k|            }
  506|  17.8k|            if (isLoaded())
  ------------------
  |  Branch (506:17): [True: 17.8k, False: 0]
  ------------------
  507|  17.8k|                _dirtyState();
  508|  17.8k|        }
  509|  18.4k|    }
_ZN4Ogre4Mesh17addBoneAssignmentERKNS_20VertexBoneAssignmentE:
  512|  1.91k|    {
  513|  1.91k|        mBoneAssignments.emplace(vertBoneAssign.vertexIndex, vertBoneAssign);
  514|  1.91k|        mBoneAssignmentsOutOfDate = true;
  515|  1.91k|    }
_ZNK4Ogre4Mesh15getSkeletonNameEv:
 1078|  18.4k|    {
 1079|  18.4k|        return mSkeleton ? mSkeleton->getName() : BLANKSTRING;
  ------------------
  |  Branch (1079:16): [True: 0, False: 18.4k]
  ------------------
 1080|  18.4k|    }
_ZN4Ogre4Mesh11_setLodInfoEt:
 1144|  3.81k|    {
 1145|  3.81k|        assert(!mEdgeListsBuilt && "Can't modify LOD after edge lists built");
 1146|       |
 1147|       |        // Basic prerequisites
 1148|  3.81k|        OgreAssert(numLevels > 0,  "Must be at least one level (full detail level must exist)");
  ------------------
  |  Branch (1148:9): [True: 0, False: 3.81k]
  ------------------
 1149|       |
 1150|  3.81k|        mMeshLodUsageList.resize(numLevels);
 1151|       |        // Resize submesh face data lists too
 1152|  3.81k|        for (auto & i : mSubMeshList)
  ------------------
  |  Branch (1152:23): [True: 3.01k, False: 3.81k]
  ------------------
 1153|  3.01k|        {
 1154|  3.01k|            i->mLodFaceList.resize(numLevels - 1);
 1155|  3.01k|        }
 1156|  3.81k|    }
_ZN4Ogre4Mesh15removeLodLevelsEv:
 1208|  5.79k|    {
 1209|  5.79k|#if !OGRE_NO_MESHLOD
 1210|       |        // Remove data from SubMeshes
 1211|  5.79k|        for (auto *isub : mSubMeshList)
  ------------------
  |  Branch (1211:25): [True: 0, False: 5.79k]
  ------------------
 1212|      0|        {
 1213|      0|            isub->removeLodLevels();
 1214|      0|        }
 1215|       |
 1216|  5.79k|        bool edgeListWasBuilt = isEdgeListBuilt();
 1217|  5.79k|        freeEdgeList();
 1218|       |
 1219|       |        // Reinitialise
 1220|  5.79k|        mMeshLodUsageList.resize(1);
 1221|  5.79k|        mMeshLodUsageList[0].edgeData = NULL;
 1222|       |
 1223|  5.79k|        if(edgeListWasBuilt)
  ------------------
  |  Branch (1223:12): [True: 0, False: 5.79k]
  ------------------
 1224|      0|            buildEdgeList();
 1225|  5.79k|#endif
 1226|  5.79k|    }
_ZN4Ogre4Mesh12freeEdgeListEv:
 1711|  11.5k|    {
 1712|  11.5k|        if (!mEdgeListsBuilt)
  ------------------
  |  Branch (1712:13): [True: 11.0k, False: 578]
  ------------------
 1713|  11.0k|            return;
 1714|    578|#if !OGRE_NO_MESHLOD
 1715|       |        // Loop over LODs
 1716|    578|        unsigned short index = 0;
 1717|    578|        for (auto& usage : mMeshLodUsageList)
  ------------------
  |  Branch (1717:26): [True: 922, False: 578]
  ------------------
 1718|    922|        {
 1719|    922|            if (usage.manualName.empty() || index == 0)
  ------------------
  |  Branch (1719:17): [True: 831, False: 91]
  |  Branch (1719:45): [True: 0, False: 91]
  ------------------
 1720|    831|            {
 1721|       |                // Only delete if we own this data
 1722|       |                // Manual LODs > 0 own their own
 1723|    831|                OGRE_DELETE usage.edgeData;
 1724|    831|            }
 1725|    922|            usage.edgeData = NULL;
 1726|    922|            ++index;
 1727|    922|        }
 1728|       |#else
 1729|       |        OGRE_DELETE mMeshLodUsageList[0].edgeData;
 1730|       |        mMeshLodUsageList[0].edgeData = NULL;
 1731|       |#endif
 1732|    578|        mEdgeListsBuilt = false;
 1733|    578|    }
_ZNK4Ogre4Mesh13calculateSizeEv:
 2010|  5.79k|    {
 2011|       |        // calculate GPU size
 2012|  5.79k|        size_t ret = 0;
 2013|  5.79k|        unsigned short i;
 2014|       |        // Shared vertices
 2015|  5.79k|        if (sharedVertexData)
  ------------------
  |  Branch (2015:13): [True: 0, False: 5.79k]
  ------------------
 2016|      0|        {
 2017|      0|            for (i = 0;
 2018|      0|                i < sharedVertexData->vertexBufferBinding->getBufferCount();
  ------------------
  |  Branch (2018:17): [True: 0, False: 0]
  ------------------
 2019|      0|                ++i)
 2020|      0|            {
 2021|      0|                ret += sharedVertexData->vertexBufferBinding
 2022|      0|                    ->getBuffer(i)->getSizeInBytes();
 2023|      0|            }
 2024|      0|        }
 2025|       |
 2026|  5.79k|        for (auto *s : mSubMeshList)
  ------------------
  |  Branch (2026:22): [True: 0, False: 5.79k]
  ------------------
 2027|      0|        {
 2028|       |            // Dedicated vertices
 2029|      0|            if (!s->useSharedVertices)
  ------------------
  |  Branch (2029:17): [True: 0, False: 0]
  ------------------
 2030|      0|            {
 2031|      0|                for (i = 0;
 2032|      0|                    i < s->vertexData->vertexBufferBinding->getBufferCount();
  ------------------
  |  Branch (2032:21): [True: 0, False: 0]
  ------------------
 2033|      0|                    ++i)
 2034|      0|                {
 2035|      0|                    ret += s->vertexData->vertexBufferBinding
 2036|      0|                        ->getBuffer(i)->getSizeInBytes();
 2037|      0|                }
 2038|      0|            }
 2039|      0|            if (s->indexData->indexBuffer)
  ------------------
  |  Branch (2039:17): [True: 0, False: 0]
  ------------------
 2040|      0|            {
 2041|       |                // Index data
 2042|      0|                ret += s->indexData->indexBuffer->getSizeInBytes();
 2043|      0|            }
 2044|       |
 2045|      0|        }
 2046|  5.79k|        return ret;
 2047|  5.79k|    }
_ZN4Ogre4Mesh15createAnimationERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEf:
 2143|  2.99k|    {
 2144|       |        // Check name not used
 2145|  2.99k|        if (mAnimationsList.find(name) != mAnimationsList.end())
  ------------------
  |  Branch (2145:13): [True: 2, False: 2.99k]
  ------------------
 2146|      2|        {
 2147|      2|            OGRE_EXCEPT(
 2148|      2|                Exception::ERR_DUPLICATE_ITEM,
 2149|      2|                "An animation with the name " + name + " already exists");
 2150|      2|        }
 2151|       |
 2152|  2.99k|        Animation* ret = OGRE_NEW Animation(name, length);
 2153|  2.99k|        ret->_notifyContainer(this);
 2154|       |
 2155|       |        // Add to list
 2156|  2.99k|        mAnimationsList[name] = ret;
 2157|       |
 2158|       |        // Mark animation types dirty
 2159|  2.99k|        mAnimationTypesDirty = true;
 2160|       |
 2161|  2.99k|        return ret;
 2162|       |
 2163|  2.99k|    }
_ZN4Ogre4Mesh19removeAllAnimationsEv:
 2231|  5.79k|    {
 2232|  5.79k|        for (auto& a : mAnimationsList)
  ------------------
  |  Branch (2232:22): [True: 2.99k, False: 5.79k]
  ------------------
 2233|  2.99k|        {
 2234|       |            OGRE_DELETE a.second;
 2235|  2.99k|        }
 2236|  5.79k|        mAnimationsList.clear();
 2237|  5.79k|        mAnimationTypesDirty = true;
 2238|  5.79k|    }
_ZN4Ogre4Mesh26getVertexDataByTrackHandleEt:
 2241|  3.63k|    {
 2242|  3.63k|        if (handle == 0)
  ------------------
  |  Branch (2242:13): [True: 1.05k, False: 2.57k]
  ------------------
 2243|  1.05k|        {
 2244|  1.05k|            return sharedVertexData;
 2245|  1.05k|        }
 2246|  2.57k|        else
 2247|  2.57k|        {
 2248|  2.57k|            return getSubMesh(handle-1)->vertexData;
 2249|  2.57k|        }
 2250|  3.63k|    }
_ZN4Ogre4Mesh10createPoseEtRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2253|  19.2k|    {
 2254|       |        Pose* retPose = OGRE_NEW Pose(target, name);
 2255|  19.2k|        mPoseList.push_back(retPose);
 2256|  19.2k|        return retPose;
 2257|  19.2k|    }
_ZN4Ogre4Mesh14removeAllPosesEv:
 2318|  5.79k|    {
 2319|  5.79k|        for (auto & i : mPoseList)
  ------------------
  |  Branch (2319:23): [True: 19.2k, False: 5.79k]
  ------------------
 2320|  19.2k|        {
 2321|       |            OGRE_DELETE i;
 2322|  19.2k|        }
 2323|  5.79k|        mPoseList.clear();
 2324|  5.79k|    }
_ZNK4Ogre4Mesh14getLodStrategyEv:
 2342|  5.79k|    {
 2343|  5.79k|        return mLodStrategy;
 2344|  5.79k|    }
_ZN4Ogre4Mesh14setLodStrategyEPNS_11LodStrategyE:
 2348|  4.90k|    {
 2349|  4.90k|        mLodStrategy = lodStrategy;
 2350|       |
 2351|  4.90k|        assert(mMeshLodUsageList.size());
 2352|       |
 2353|       |        // Re-transform user LOD values (starting at index 1, no need to transform base value)
 2354|  4.90k|        for (auto& m : mMeshLodUsageList)
  ------------------
  |  Branch (2354:22): [True: 4.94k, False: 4.90k]
  ------------------
 2355|  4.94k|            m.value = mLodStrategy->transformUserValue(m.userValue);
 2356|       |
 2357|       |        // Rewrite first value
 2358|  4.90k|        mMeshLodUsageList[0].value = mLodStrategy->getBaseValue();
 2359|  4.90k|    }
_ZN4Ogre4Mesh21_convertVertexElementENS_21VertexElementSemanticENS_17VertexElementTypeE:
 2363|  7.73k|    {
 2364|  7.73k|        if (sharedVertexData)
  ------------------
  |  Branch (2364:13): [True: 2.03k, False: 5.69k]
  ------------------
 2365|  2.03k|            sharedVertexData->convertVertexElement(semantic, dstType);
 2366|       |
 2367|  7.73k|        for (auto s : getSubMeshes())
  ------------------
  |  Branch (2367:21): [True: 137k, False: 7.73k]
  ------------------
 2368|   137k|            if (s->vertexData)
  ------------------
  |  Branch (2368:17): [True: 129k, False: 8.08k]
  ------------------
 2369|   129k|                s->vertexData->convertVertexElement(semantic, dstType);
 2370|  7.73k|    }

_ZN4Ogre11MeshManager12getSingletonEv:
   58|  17.3k|    {  
   59|       |        assert( msSingleton );  return ( *msSingleton );  
   60|  17.3k|    }
_ZN4Ogre11MeshManagerC2Ev:
   63|      1|    mBoundsPaddingFactor(0.01), mListener(0)
   64|      1|    {
   65|      1|        mBlendWeightsBaseElementType = VET_FLOAT1;
   66|      1|        mPrepAllMeshesForShadowVolumes = false;
   67|       |
   68|      1|        mLoadOrder = 350.0f;
   69|      1|        mResourceType = "Mesh";
   70|       |
   71|      1|        mMeshCodec = std::make_unique<MeshCodec>();
   72|      1|        Codec::registerCodec(mMeshCodec.get());
   73|       |
   74|      1|        ResourceGroupManager::getSingleton()._registerResourceManager(mResourceType, this);
   75|       |
   76|      1|        mPrefabLoader = std::make_unique<PrefabFactory>();
   77|      1|    }
_ZN4Ogre11MeshManager6createERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
  147|  5.79k|    {
  148|  5.79k|        return static_pointer_cast<Mesh>(createResource(name,group,isManual,loader,createParams));
  149|  5.79k|    }
_ZN4Ogre11MeshManager35getPrepareAllMeshesForShadowVolumesEv:
  326|  5.79k|    {
  327|  5.79k|        return mPrepAllMeshesForShadowVolumes;
  328|  5.79k|    }
_ZN4Ogre11MeshManager10createImplERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmS9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
  363|  5.79k|    {
  364|       |        // no use for createParams here
  365|       |        return OGRE_NEW Mesh(this, name, handle, group, isManual, loader);
  366|  5.79k|    }
_ZNK4Ogre9MeshCodec7getTypeEv:
   39|      1|        String getType() const override { return "mesh"; }

_ZN4Ogre14MeshSerializerC2Ev:
   47|  5.79k|        :mListener(0)
   48|  5.79k|    {
   49|       |        // Init implementations
   50|       |        // String identifiers have not always been 100% unified with OGRE version
   51|       |        
   52|       |        // Note MUST be added in reverse order so latest is first in the list
   53|       |
   54|       |        // This one is a little ugly, 1.10 is used for version 1.1 legacy meshes.
   55|       |        // So bump up to 1.100
   56|  5.79k|        mVersionData.push_back(OGRE_NEW MeshVersionData(
   57|  5.79k|            MESH_VERSION_1_10, "[MeshSerializer_v1.100]", 
   58|  5.79k|            OGRE_NEW MeshSerializerImpl()));
   59|       |
   60|  5.79k|        mVersionData.push_back(OGRE_NEW MeshVersionData(
   61|  5.79k|            MESH_VERSION_1_8, "[MeshSerializer_v1.8]", 
   62|  5.79k|            OGRE_NEW MeshSerializerImpl_v1_8()));
   63|       |
   64|  5.79k|        if(!mSupportLegacyFormats)
  ------------------
  |  Branch (64:12): [True: 5.79k, False: 0]
  ------------------
   65|  5.79k|            return;
   66|       |
   67|      0|        mVersionData.push_back(OGRE_NEW MeshVersionData(
   68|      0|            MESH_VERSION_1_7, "[MeshSerializer_v1.41]", 
   69|      0|            OGRE_NEW MeshSerializerImpl_v1_41()));
   70|       |
   71|      0|        mVersionData.push_back(OGRE_NEW MeshVersionData(
   72|      0|            MESH_VERSION_1_4, "[MeshSerializer_v1.40]", 
   73|      0|            OGRE_NEW MeshSerializerImpl_v1_4()));
   74|       |
   75|      0|        mVersionData.push_back(OGRE_NEW MeshVersionData(
   76|      0|            MESH_VERSION_1_0, "[MeshSerializer_v1.30]", 
   77|      0|            OGRE_NEW MeshSerializerImpl_v1_3()));
   78|      0|        mVersionData.push_back(OGRE_NEW MeshVersionData(
   79|      0|            MESH_VERSION_LEGACY, "[MeshSerializer_v1.20]", 
   80|      0|            OGRE_NEW MeshSerializerImpl_v1_2()));
   81|       |
   82|      0|        mVersionData.push_back(OGRE_NEW MeshVersionData(
   83|      0|            MESH_VERSION_LEGACY, "[MeshSerializer_v1.10]", 
   84|      0|            OGRE_NEW MeshSerializerImpl_v1_1()));
   85|       |        
   86|      0|    }
_ZN4Ogre14MeshSerializerD2Ev:
   89|  5.79k|    {
   90|       |        // delete map
   91|  5.79k|        for (auto & i : mVersionData)
  ------------------
  |  Branch (91:23): [True: 11.5k, False: 5.79k]
  ------------------
   92|  11.5k|        {
   93|  11.5k|            OGRE_DELETE i;
   94|  11.5k|        }
   95|  5.79k|        mVersionData.clear();
   96|       |
   97|  5.79k|    }
_ZN4Ogre14MeshSerializer10importMeshERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshE:
  141|  5.79k|    {
  142|  5.79k|        determineEndianness(stream);
  143|       |
  144|       |        // Read header and determine the version
  145|  5.79k|        unsigned short headerID;
  146|       |        
  147|       |        // Read header ID
  148|  5.79k|        readShorts(stream, &headerID, 1);
  149|       |        
  150|  5.79k|        if (headerID != HEADER_CHUNK_ID)
  ------------------
  |  Branch (150:13): [True: 0, False: 5.79k]
  ------------------
  151|      0|        {
  152|      0|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "File header not found",
  153|      0|                "MeshSerializer::importMesh");
  154|      0|        }
  155|       |        // Read version
  156|  5.79k|        String ver = readString(stream);
  157|       |        // Jump back to start
  158|  5.79k|        stream->seek(0);
  159|       |
  160|       |        // Find the implementation to use
  161|  5.79k|        MeshSerializerImpl* impl = 0;
  162|  5.79k|        for (auto & i : mVersionData)
  ------------------
  |  Branch (162:23): [True: 10.0k, False: 108]
  ------------------
  163|  10.0k|        {
  164|  10.0k|            if (i->versionString == ver)
  ------------------
  |  Branch (164:17): [True: 5.68k, False: 4.40k]
  ------------------
  165|  5.68k|            {
  166|  5.68k|                impl = i->impl.get();
  167|  5.68k|                break;
  168|  5.68k|            }
  169|  10.0k|        }           
  170|  5.79k|        if (!impl)
  ------------------
  |  Branch (170:13): [True: 84, False: 5.71k]
  ------------------
  171|  5.79k|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Cannot find serializer implementation for "
  172|  5.71k|                        "mesh version " + ver, "MeshSerializer::importMesh");
  173|       |        
  174|       |        // Call implementation
  175|  5.71k|        impl->importMesh(stream, pDest, mListener);
  176|       |        // Warn on old version of mesh
  177|  5.71k|        if (ver != mVersionData[0]->versionString)
  ------------------
  |  Branch (177:13): [True: 3.14k, False: 2.56k]
  ------------------
  178|  3.14k|        {
  179|  3.14k|            LogManager::getSingleton().logWarning(pDest->getName() + " uses an old format " + ver +
  180|  3.14k|                                                  "; upgrade with the OgreMeshUpgrader tool");
  181|  3.14k|        }
  182|       |
  183|  5.71k|        if(mListener)
  ------------------
  |  Branch (183:12): [True: 0, False: 5.71k]
  ------------------
  184|      0|            mListener->processMeshCompleted(pDest);
  185|       |
  186|  5.71k|        auto rs = Root::getSingletonPtr() ? Root::getSingleton().getRenderSystem() : NULL;
  ------------------
  |  Branch (186:19): [True: 0, False: 5.71k]
  ------------------
  187|  5.71k|        if (!rs || !rs->getCapabilities()->hasCapability(RSC_VERTEX_FORMAT_INT_10_10_10_2))
  ------------------
  |  Branch (187:13): [True: 5.71k, False: 0]
  |  Branch (187:20): [True: 0, False: 0]
  ------------------
  188|  3.87k|        {
  189|       |            // unpacks to floats, if packed
  190|  3.87k|            pDest->_convertVertexElement(VES_NORMAL, VET_FLOAT3);
  191|  3.87k|            pDest->_convertVertexElement(VES_TANGENT, VET_FLOAT4);
  192|  3.87k|        }
  193|  5.71k|    }
_ZN4Ogre15MeshVersionDataC2ENS_11MeshVersionERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS_18MeshSerializerImplE:
   41|  11.5k|        : version(_ver), versionString(_string), impl(_impl) {}

_ZN4Ogre18MeshSerializerImplC2Ev:
  138|  11.5k|    {
  139|       |        // Version number
  140|  11.5k|        mVersion = "[MeshSerializer_v1.100]";
  141|  11.5k|        exportedLodCount = 0;
  142|  11.5k|    }
_ZN4Ogre18MeshSerializerImplD2Ev:
  145|  11.5k|    {
  146|  11.5k|    }
_ZN4Ogre18MeshSerializerImpl10importMeshERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEPNS_22MeshSerializerListenerE:
  185|  5.68k|    {
  186|       |        // Determine endianness (must be the first thing we do!)
  187|  5.68k|        determineEndianness(stream);
  188|       |
  189|       |#if OGRE_SERIALIZER_VALIDATE_CHUNKSIZE
  190|       |        enableValidation();
  191|       |#endif
  192|       |        // Check header
  193|  5.68k|        readFileHeader(stream);
  194|  5.68k|        pushInnerChunk(stream);
  195|  5.68k|        unsigned short streamID = readChunk(stream);
  196|       |
  197|  36.2k|        while(!stream->eof())
  ------------------
  |  Branch (197:15): [True: 32.2k, False: 3.97k]
  ------------------
  198|  32.2k|        {
  199|  32.2k|            switch (streamID)
  ------------------
  |  Branch (199:21): [True: 18.9k, False: 13.3k]
  ------------------
  200|  32.2k|            {
  201|  18.9k|            case M_MESH:
  ------------------
  |  Branch (201:13): [True: 18.9k, False: 13.3k]
  ------------------
  202|  18.9k|                readMesh(stream, pMesh, listener);
  203|  18.9k|                break;
  204|  32.2k|            }
  205|       |
  206|  30.5k|            streamID = readChunk(stream);
  207|  30.5k|        }
  208|  3.97k|        popInnerChunk(stream);
  209|  3.97k|    }
_ZN4Ogre18MeshSerializerImpl12readGeometryERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEPNS_10VertexDataE:
  681|   149k|    {
  682|       |
  683|   149k|        dest->vertexStart = 0;
  684|       |
  685|   149k|        unsigned int vertexCount = 0;
  686|   149k|        readInts(stream, &vertexCount, 1);
  687|   149k|        if (!checkChunkRemainingSize(mCurrentstreamLen, vertexCount, 1))
  ------------------
  |  Branch (687:13): [True: 1.63k, False: 147k]
  ------------------
  688|   149k|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Vertex count exceeds remaining chunk data");
  689|   147k|        dest->vertexCount = vertexCount;
  690|       |        // Find optional geometry streams
  691|   147k|        if (!stream->eof())
  ------------------
  |  Branch (691:13): [True: 147k, False: 68]
  ------------------
  692|   147k|        {
  693|   147k|            pushInnerChunk(stream);
  694|   147k|            unsigned short streamID = readChunk(stream);
  695|   173k|            while(!stream->eof() &&
  ------------------
  |  Branch (695:19): [True: 172k, False: 961]
  ------------------
  696|   172k|                (streamID == M_GEOMETRY_VERTEX_DECLARATION ||
  ------------------
  |  Branch (696:18): [True: 17.1k, False: 155k]
  ------------------
  697|   155k|                 streamID == M_GEOMETRY_VERTEX_BUFFER ))
  ------------------
  |  Branch (697:18): [True: 11.0k, False: 144k]
  ------------------
  698|  28.1k|            {
  699|  28.1k|                switch (streamID)
  ------------------
  |  Branch (699:25): [True: 28.1k, False: 0]
  ------------------
  700|  28.1k|                {
  701|  17.1k|                case M_GEOMETRY_VERTEX_DECLARATION:
  ------------------
  |  Branch (701:17): [True: 17.1k, False: 11.0k]
  ------------------
  702|  17.1k|                    readGeometryVertexDeclaration(stream, pMesh, dest);
  703|  17.1k|                    break;
  704|  11.0k|                case M_GEOMETRY_VERTEX_BUFFER:
  ------------------
  |  Branch (704:17): [True: 11.0k, False: 17.1k]
  ------------------
  705|  11.0k|                    readGeometryVertexBuffer(stream, pMesh, dest);
  706|  11.0k|                    break;
  707|  28.1k|                }
  708|       |                // Get next stream
  709|  25.6k|                if (!stream->eof())
  ------------------
  |  Branch (709:21): [True: 25.1k, False: 488]
  ------------------
  710|  25.1k|                {
  711|  25.1k|                    streamID = readChunk(stream);
  712|  25.1k|                }
  713|  25.6k|            }
  714|   145k|            if (!stream->eof())
  ------------------
  |  Branch (714:17): [True: 144k, False: 961]
  ------------------
  715|   144k|            {
  716|       |                // Backpedal back to start of non-submesh stream
  717|   144k|                backpedalChunkHeader(stream);
  718|   144k|            }
  719|   145k|            popInnerChunk(stream);
  720|   145k|        }
  721|       |
  722|       |        // Perform any necessary colour conversions from ARGB to ABGR (UBYTE4)
  723|   145k|        dest->convertPackedColour(_DETAIL_SWAP_RB, VET_UBYTE4_NORM);
  724|       |
  725|   145k|        auto rs = Root::getSingletonPtr() ? Root::getSingleton().getRenderSystem() : NULL;
  ------------------
  |  Branch (725:19): [True: 0, False: 145k]
  ------------------
  726|   145k|        if(!rs || rs->getCapabilities()->hasCapability(RSC_VERTEX_FORMAT_16X3))
  ------------------
  |  Branch (726:12): [True: 145k, False: 0]
  |  Branch (726:19): [True: 0, False: 0]
  ------------------
  727|   144k|            return;
  728|       |
  729|    440|        for(auto& elem : dest->vertexDeclaration->getElements())
  ------------------
  |  Branch (729:24): [True: 0, False: 440]
  ------------------
  730|      0|        {
  731|      0|            if (elem.getType() == VET_HALF3 || elem.getType() == VET_SHORT3 || elem.getType() == VET_USHORT3)
  ------------------
  |  Branch (731:17): [True: 0, False: 0]
  |  Branch (731:48): [True: 0, False: 0]
  |  Branch (731:80): [True: 0, False: 0]
  ------------------
  732|      0|            {
  733|      0|                auto dstType = VertexElement::multiplyTypeCount(VertexElement::getBaseType(elem.getType()), 4);
  734|      0|                dest->convertVertexElement(elem.getSemantic(), dstType, elem.getIndex());
  735|      0|            }
  736|      0|        }
  737|    440|    }
_ZN4Ogre18MeshSerializerImpl29readGeometryVertexDeclarationERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEPNS_10VertexDataE:
  741|  17.1k|    {
  742|       |        // Find optional geometry streams
  743|  17.1k|        if (!stream->eof())
  ------------------
  |  Branch (743:13): [True: 17.1k, False: 0]
  ------------------
  744|  17.1k|        {
  745|  17.1k|            pushInnerChunk(stream);
  746|  17.1k|            unsigned short streamID = readChunk(stream);
  747|  44.7k|            while(!stream->eof() &&
  ------------------
  |  Branch (747:19): [True: 44.4k, False: 311]
  ------------------
  748|  44.4k|                (streamID == M_GEOMETRY_VERTEX_ELEMENT ))
  ------------------
  |  Branch (748:17): [True: 27.8k, False: 16.5k]
  ------------------
  749|  27.8k|            {
  750|  27.8k|                switch (streamID)
  ------------------
  |  Branch (750:25): [True: 27.8k, False: 0]
  ------------------
  751|  27.8k|                {
  752|  27.8k|                case M_GEOMETRY_VERTEX_ELEMENT:
  ------------------
  |  Branch (752:17): [True: 27.8k, False: 0]
  ------------------
  753|  27.8k|                    readGeometryVertexElement(stream, pMesh, dest);
  754|  27.8k|                    break;
  755|  27.8k|                }
  756|       |                // Get next stream
  757|  27.6k|                if (!stream->eof())
  ------------------
  |  Branch (757:21): [True: 27.5k, False: 142]
  ------------------
  758|  27.5k|                {
  759|  27.5k|                    streamID = readChunk(stream);
  760|  27.5k|                }
  761|  27.6k|            }
  762|  16.9k|            if (!stream->eof())
  ------------------
  |  Branch (762:17): [True: 16.5k, False: 311]
  ------------------
  763|  16.5k|            {
  764|       |                // Backpedal back to start of non-submesh stream
  765|  16.5k|                backpedalChunkHeader(stream);
  766|  16.5k|            }
  767|  16.9k|            popInnerChunk(stream);
  768|  16.9k|        }
  769|       |
  770|  17.1k|    }
_ZN4Ogre18MeshSerializerImpl25readGeometryVertexElementERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEPNS_10VertexDataE:
  774|  27.8k|    {
  775|  27.8k|        unsigned short source, offset, index, tmp;
  776|  27.8k|        VertexElementType vType;
  777|  27.8k|        VertexElementSemantic vSemantic;
  778|       |        // unsigned short source;   // buffer bind source
  779|  27.8k|        readShorts(stream, &source, 1);
  780|       |        // unsigned short type;     // VertexElementType
  781|  27.8k|        readShorts(stream, &tmp, 1);
  782|  27.8k|        if(tmp == 4 || tmp == 11)
  ------------------
  |  Branch (782:12): [True: 327, False: 27.5k]
  |  Branch (782:24): [True: 1.96k, False: 25.5k]
  ------------------
  783|  2.29k|            vType = VET_UBYTE4_NORM;
  784|  25.5k|        else
  785|  25.5k|            vType = static_cast<VertexElementType>(tmp);
  786|       |        // unsigned short semantic; // VertexElementSemantic
  787|  27.8k|        readShorts(stream, &tmp, 1);
  788|  27.8k|        vSemantic = static_cast<VertexElementSemantic>(tmp);
  789|       |        // unsigned short offset;   // start offset in buffer in bytes
  790|  27.8k|        readShorts(stream, &offset, 1);
  791|       |        // unsigned short index;    // index of the semantic
  792|  27.8k|        readShorts(stream, &index, 1);
  793|       |
  794|  27.8k|        if (dest->vertexBufferBinding->isBufferBound(source))
  ------------------
  |  Branch (794:13): [True: 199, False: 27.6k]
  ------------------
  795|  27.8k|            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "Cannot add vertex element after reading buffer");
  796|       |
  797|  27.6k|        dest->vertexDeclaration->addElement(source, offset, vType, vSemantic, index);
  798|       |
  799|  27.6k|        if (vType == _DETAIL_SWAP_RB)
  ------------------
  |  Branch (799:13): [True: 4.86k, False: 22.7k]
  ------------------
  800|  4.86k|        {
  801|  4.86k|            LogManager::getSingleton().stream(LML_WARNING)
  802|  4.86k|                << "Warning: VET_COLOUR_ARGB element type is deprecated and incurs conversion on load. "
  803|  4.86k|                << "Use OgreMeshUpgrader on '" << pMesh->getName() << "' as soon as possible.";
  804|  4.86k|        }
  805|       |
  806|  27.6k|    }
_ZN4Ogre18MeshSerializerImpl24readGeometryVertexBufferERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEPNS_10VertexDataE:
  810|  11.0k|    {
  811|  11.0k|        unsigned short bindIndex, vertexSize;
  812|       |        // unsigned short bindIndex;    // Index to bind this buffer to
  813|  11.0k|        readShorts(stream, &bindIndex, 1);
  814|       |        // unsigned short vertexSize;   // Per-vertex size, must agree with declaration at this index
  815|  11.0k|        readShorts(stream, &vertexSize, 1);
  816|  11.0k|        if (dest->vertexBufferBinding->isBufferBound(bindIndex))
  ------------------
  |  Branch (816:13): [True: 196, False: 10.8k]
  ------------------
  817|  11.0k|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Duplicate vertex buffer binding");
  818|  10.8k|        pushInnerChunk(stream);
  819|  10.8k|        {
  820|       |        // Check for vertex data header
  821|  10.8k|        unsigned short headerID;
  822|  10.8k|        headerID = readChunk(stream);
  823|  10.8k|        if (headerID != M_GEOMETRY_VERTEX_BUFFER_DATA)
  ------------------
  |  Branch (823:13): [True: 298, False: 10.5k]
  ------------------
  824|    298|        {
  825|    298|            OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Can't find vertex buffer data area",
  826|    298|                "MeshSerializerImpl::readGeometryVertexBuffer");
  827|    298|        }
  828|  10.5k|        size_t declaredVertexSize = dest->vertexDeclaration->getVertexSize(bindIndex);
  829|  10.5k|        if (declaredVertexSize == 0)
  ------------------
  |  Branch (829:13): [True: 378, False: 10.2k]
  ------------------
  830|    378|        {
  831|    378|            OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Missing vertex declaration for buffer bind index");
  832|    378|        }
  833|       |        // Check that vertex size agrees
  834|  10.2k|        if (declaredVertexSize != vertexSize)
  ------------------
  |  Branch (834:13): [True: 274, False: 9.94k]
  ------------------
  835|    274|        {
  836|    274|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Buffer vertex size does not agree with vertex declaration");
  837|    274|        }
  838|       |
  839|       |        // Create / populate vertex buffer
  840|  9.94k|        size_t vbufBytes = dest->vertexCount * (size_t)vertexSize;
  841|  9.94k|        if (!checkChunkRemainingSize(mCurrentstreamLen, vbufBytes, 1))
  ------------------
  |  Branch (841:13): [True: 445, False: 9.49k]
  ------------------
  842|  9.94k|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Vertex buffer size exceeds remaining chunk data");
  843|  9.49k|        HardwareVertexBufferSharedPtr vbuf;
  844|  9.49k|        vbuf = pMesh->getHardwareBufferManager()->createVertexBuffer(
  845|  9.49k|            vertexSize,
  846|  9.49k|            dest->vertexCount,
  847|  9.49k|            pMesh->mVertexBufferUsage,
  848|  9.49k|            pMesh->mVertexBufferShadowBuffer);
  849|  9.49k|        HardwareBufferLockGuard vbufLock(vbuf, HardwareBuffer::HBL_DISCARD);
  850|  9.49k|        stream->read(vbufLock.pData, vbufBytes);
  851|       |
  852|  9.49k|        auto elems = dest->vertexDeclaration->findElementsBySource(bindIndex);
  853|       |        // validate vertex element declarations
  854|  9.49k|        for (auto& elem : elems)
  ------------------
  |  Branch (854:25): [True: 13.1k, False: 8.81k]
  ------------------
  855|  13.1k|        {
  856|  13.1k|            if (elem.getSize() == 0)
  ------------------
  |  Branch (856:17): [True: 302, False: 12.8k]
  ------------------
  857|  13.1k|                    OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Invalid vertex element type");
  858|  12.8k|            if (elem.getOffset() + elem.getSize() > vertexSize)
  ------------------
  |  Branch (858:17): [True: 385, False: 12.4k]
  ------------------
  859|  12.8k|                    OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
  860|  12.8k|                                "Vertex element offset + size exceeds vertex buffer stride");
  861|  12.8k|        }
  862|       |
  863|       |        // endian conversion for OSX
  864|  8.81k|        flipFromLittleEndian(vbufLock.pData, dest->vertexCount, vertexSize, elems);
  865|       |
  866|       |        // Set binding
  867|  8.81k|        dest->vertexBufferBinding->setBinding(bindIndex, vbuf);
  868|  8.81k|        }
  869|      0|        popInnerChunk(stream);
  870|       |
  871|  8.81k|    }
_ZN4Ogre18MeshSerializerImpl20readSubMeshNameTableERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshE:
  874|  3.65k|    {
  875|       |        // The map for
  876|  3.65k|        std::map<unsigned short, String> subMeshNames;
  877|  3.65k|        unsigned short streamID, subMeshIndex;
  878|       |
  879|       |        // Need something to store the index, and the objects name
  880|       |        // This table is a method that imported meshes can retain their naming
  881|       |        // so that the names established in the modelling software can be used
  882|       |        // to get the sub-meshes by name. The exporter must support exporting
  883|       |        // the optional stream M_SUBMESH_NAME_TABLE.
  884|       |
  885|       |        // Read in all the sub-streams. Each sub-stream should contain an index and Ogre::String for the name.
  886|  3.65k|        if (!stream->eof())
  ------------------
  |  Branch (886:13): [True: 3.65k, False: 0]
  ------------------
  887|  3.65k|        {
  888|  3.65k|            pushInnerChunk(stream);
  889|  3.65k|            streamID = readChunk(stream);
  890|  14.4k|            while(!stream->eof() && (streamID == M_SUBMESH_NAME_TABLE_ELEMENT ))
  ------------------
  |  Branch (890:19): [True: 13.9k, False: 525]
  |  Branch (890:37): [True: 10.8k, False: 3.13k]
  ------------------
  891|  10.8k|            {
  892|       |                // Read in the index of the submesh.
  893|  10.8k|                readShorts(stream, &subMeshIndex, 1);
  894|       |                // Read in the String and map it to its index.
  895|  10.8k|                subMeshNames[subMeshIndex] = readString(stream);
  896|       |
  897|       |                // If we're not end of file get the next stream ID
  898|  10.8k|                if (!stream->eof())
  ------------------
  |  Branch (898:21): [True: 10.4k, False: 412]
  ------------------
  899|  10.4k|                    streamID = readChunk(stream);
  900|  10.8k|            }
  901|  3.65k|            if (!stream->eof())
  ------------------
  |  Branch (901:17): [True: 3.13k, False: 525]
  ------------------
  902|  3.13k|            {
  903|       |                // Backpedal back to start of stream
  904|  3.13k|                backpedalChunkHeader(stream);
  905|  3.13k|            }
  906|  3.65k|            popInnerChunk(stream);
  907|  3.65k|        }
  908|       |
  909|       |        // Set all the submeshes names
  910|       |        // ?
  911|       |        // Loop through and save out the index and names.
  912|  3.65k|        for (auto& sn : subMeshNames)
  ------------------
  |  Branch (912:23): [True: 10.0k, False: 3.65k]
  ------------------
  913|  10.0k|        {
  914|       |            // Name this submesh to the stored name.
  915|  10.0k|            pMesh->nameSubMesh(sn.second, sn.first);
  916|  10.0k|        }
  917|  3.65k|    }
_ZN4Ogre18MeshSerializerImpl8readMeshERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEPNS_22MeshSerializerListenerE:
  920|  18.9k|    {
  921|       |        // Never automatically build edge lists for this version
  922|       |        // expect them in the file or not at all
  923|  18.9k|        pMesh->mAutoBuildEdgeLists = false;
  924|       |
  925|       |        // bool skeletallyAnimated
  926|  18.9k|        bool skeletallyAnimated;
  927|  18.9k|        readBools(stream, &skeletallyAnimated, 1);
  928|       |
  929|       |        // Find all substreams
  930|  18.9k|        if (!stream->eof())
  ------------------
  |  Branch (930:13): [True: 18.9k, False: 21]
  ------------------
  931|  18.9k|        {
  932|  18.9k|            pushInnerChunk(stream);
  933|  18.9k|            unsigned short streamID = readChunk(stream);
  934|   281k|            while(!stream->eof() &&
  ------------------
  |  Branch (934:19): [True: 277k, False: 3.54k]
  ------------------
  935|   277k|                (streamID == M_GEOMETRY ||
  ------------------
  |  Branch (935:18): [True: 24.8k, False: 252k]
  ------------------
  936|   252k|                 streamID == M_SUBMESH ||
  ------------------
  |  Branch (936:18): [True: 197k, False: 55.6k]
  ------------------
  937|  55.6k|                 streamID == M_MESH_SKELETON_LINK ||
  ------------------
  |  Branch (937:18): [True: 18.4k, False: 37.2k]
  ------------------
  938|  37.2k|                 streamID == M_MESH_BONE_ASSIGNMENT ||
  ------------------
  |  Branch (938:18): [True: 1.91k, False: 35.3k]
  ------------------
  939|  35.3k|                 streamID == M_MESH_LOD_LEVEL ||
  ------------------
  |  Branch (939:18): [True: 8.04k, False: 27.2k]
  ------------------
  940|  27.2k|                 streamID == M_MESH_BOUNDS ||
  ------------------
  |  Branch (940:18): [True: 3.45k, False: 23.8k]
  ------------------
  941|  23.8k|                 streamID == M_SUBMESH_NAME_TABLE ||
  ------------------
  |  Branch (941:18): [True: 3.65k, False: 20.1k]
  ------------------
  942|  20.1k|                 streamID == M_EDGE_LISTS ||
  ------------------
  |  Branch (942:18): [True: 1.25k, False: 18.8k]
  ------------------
  943|  18.8k|                 streamID == M_POSES ||
  ------------------
  |  Branch (943:18): [True: 1.38k, False: 17.5k]
  ------------------
  944|  17.5k|                 streamID == M_ANIMATIONS ||
  ------------------
  |  Branch (944:18): [True: 1.84k, False: 15.6k]
  ------------------
  945|  15.6k|                 streamID == M_TABLE_EXTREMES))
  ------------------
  |  Branch (945:18): [True: 1.78k, False: 13.8k]
  ------------------
  946|   263k|            {
  947|   263k|                switch(streamID)
  ------------------
  |  Branch (947:24): [True: 263k, False: 0]
  ------------------
  948|   263k|                {
  949|  24.8k|                case M_GEOMETRY:
  ------------------
  |  Branch (949:17): [True: 24.8k, False: 238k]
  ------------------
  950|  24.8k|                    pMesh->createVertexData();
  951|  24.8k|                    try {
  952|  24.8k|                        readGeometry(stream, pMesh, pMesh->sharedVertexData);
  953|  24.8k|                    }
  954|  24.8k|                    catch (Exception&)
  955|  24.8k|                    {
  956|       |                        // duff geometry data entry with 0 vertices
  957|  4.60k|                        pMesh->resetVertexData();
  958|       |                        // Skip this stream (pointer will have been returned to just after header)
  959|  4.60k|                        stream->skip(mCurrentstreamLen - MSTREAM_OVERHEAD_SIZE);
  960|  4.60k|                    }
  961|  24.8k|                    break;
  962|   197k|                case M_SUBMESH:
  ------------------
  |  Branch (962:17): [True: 197k, False: 66.6k]
  ------------------
  963|   197k|                    readSubMesh(stream, pMesh, listener);
  964|   197k|                    break;
  965|  18.4k|                case M_MESH_SKELETON_LINK:
  ------------------
  |  Branch (965:17): [True: 18.4k, False: 245k]
  ------------------
  966|  18.4k|                    readSkeletonLink(stream, pMesh, listener);
  967|  18.4k|                    break;
  968|  1.91k|                case M_MESH_BONE_ASSIGNMENT:
  ------------------
  |  Branch (968:17): [True: 1.91k, False: 261k]
  ------------------
  969|  1.91k|                    readMeshBoneAssignment(stream, pMesh);
  970|  1.91k|                    break;
  971|  8.04k|                case M_MESH_LOD_LEVEL:
  ------------------
  |  Branch (971:17): [True: 8.04k, False: 255k]
  ------------------
  972|  8.04k|                    readMeshLodLevel(stream, pMesh);
  973|  8.04k|                    break;
  974|  3.45k|                case M_MESH_BOUNDS:
  ------------------
  |  Branch (974:17): [True: 3.45k, False: 260k]
  ------------------
  975|  3.45k|                    readBoundsInfo(stream, pMesh);
  976|  3.45k|                    break;
  977|  3.65k|                case M_SUBMESH_NAME_TABLE:
  ------------------
  |  Branch (977:17): [True: 3.65k, False: 260k]
  ------------------
  978|  3.65k|                    readSubMeshNameTable(stream, pMesh);
  979|  3.65k|                    break;
  980|  1.25k|                case M_EDGE_LISTS:
  ------------------
  |  Branch (980:17): [True: 1.25k, False: 262k]
  ------------------
  981|  1.25k|                    readEdgeList(stream, pMesh);
  982|  1.25k|                    break;
  983|  1.38k|                case M_POSES:
  ------------------
  |  Branch (983:17): [True: 1.38k, False: 262k]
  ------------------
  984|  1.38k|                    readPoses(stream, pMesh);
  985|  1.38k|                    break;
  986|  1.84k|                case M_ANIMATIONS:
  ------------------
  |  Branch (986:17): [True: 1.84k, False: 261k]
  ------------------
  987|  1.84k|                    readAnimations(stream, pMesh);
  988|  1.84k|                    break;
  989|  1.78k|                case M_TABLE_EXTREMES:
  ------------------
  |  Branch (989:17): [True: 1.78k, False: 261k]
  ------------------
  990|  1.78k|                    readExtremes(stream, pMesh);
  991|  1.78k|                    break;
  992|   263k|                }
  993|       |
  994|   262k|                if (!stream->eof())
  ------------------
  |  Branch (994:21): [True: 258k, False: 3.23k]
  ------------------
  995|   258k|                {
  996|   258k|                    streamID = readChunk(stream);
  997|   258k|                }
  998|       |
  999|   262k|            }
 1000|  17.4k|            if (!stream->eof())
  ------------------
  |  Branch (1000:17): [True: 13.8k, False: 3.54k]
  ------------------
 1001|  13.8k|            {
 1002|       |                // Backpedal back to start of stream
 1003|  13.8k|                backpedalChunkHeader(stream);
 1004|  13.8k|            }
 1005|  17.4k|            popInnerChunk(stream);
 1006|  17.4k|        }
 1007|       |
 1008|  18.9k|    }
_ZN4Ogre18MeshSerializerImpl11readSubMeshERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEPNS_22MeshSerializerListenerE:
 1011|   197k|    {
 1012|   197k|        unsigned short streamID;
 1013|       |
 1014|   197k|        SubMesh* sm = pMesh->createSubMesh();
 1015|       |
 1016|       |        // char* materialName
 1017|   197k|        String materialName = readString(stream);
 1018|   197k|        if(listener)
  ------------------
  |  Branch (1018:12): [True: 0, False: 197k]
  ------------------
 1019|      0|            listener->processMaterialName(pMesh, &materialName);
 1020|   197k|        if (auto material = MaterialManager::getSingleton().getByName(materialName, pMesh->getGroup()))
  ------------------
  |  Branch (1020:18): [True: 0, False: 197k]
  ------------------
 1021|      0|        {
 1022|      0|            sm->setMaterial(material);
 1023|      0|        }
 1024|   197k|        else
 1025|   197k|        {
 1026|   197k|            logMaterialNotFound(materialName, pMesh->getGroup(), "SubMesh of", pMesh->getName(), LML_WARNING);
 1027|   197k|        }
 1028|       |
 1029|       |        // bool useSharedVertices
 1030|   197k|        readBools(stream,&sm->useSharedVertices, 1);
 1031|       |
 1032|   197k|        sm->indexData->indexStart = 0;
 1033|   197k|        unsigned int indexCount = 0;
 1034|   197k|        readInts(stream, &indexCount, 1);
 1035|   197k|        sm->indexData->indexCount = indexCount;
 1036|       |
 1037|   197k|        HardwareIndexBufferSharedPtr ibuf;
 1038|       |        // bool indexes32Bit
 1039|   197k|        bool idx32bit;
 1040|   197k|        readBools(stream, &idx32bit, 1);
 1041|   197k|        if (indexCount > 0)
  ------------------
  |  Branch (1041:13): [True: 96.7k, False: 100k]
  ------------------
 1042|  96.7k|        {
 1043|  96.7k|            if (!checkChunkRemainingSize(mCurrentstreamLen, indexCount, idx32bit ? sizeof(unsigned int) : sizeof(unsigned short)))
  ------------------
  |  Branch (1043:17): [True: 115, False: 96.6k]
  |  Branch (1043:73): [True: 2.68k, False: 94.0k]
  ------------------
 1044|  96.7k|                OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Index buffer size exceeds chunk size");
 1045|  96.6k|            if (idx32bit)
  ------------------
  |  Branch (1045:17): [True: 2.64k, False: 94.0k]
  ------------------
 1046|  2.64k|            {
 1047|  2.64k|                ibuf = pMesh->getHardwareBufferManager()->createIndexBuffer(
 1048|  2.64k|                        HardwareIndexBuffer::IT_32BIT,
 1049|  2.64k|                        sm->indexData->indexCount,
 1050|  2.64k|                        pMesh->mIndexBufferUsage,
 1051|  2.64k|                        pMesh->mIndexBufferShadowBuffer);
 1052|  2.64k|                HardwareBufferLockGuard ibufLock(ibuf, HardwareBuffer::HBL_DISCARD);
 1053|  2.64k|                readInts(stream, static_cast<unsigned int*>(ibufLock.pData), sm->indexData->indexCount);
 1054|       |
 1055|  2.64k|            }
 1056|  94.0k|            else // 16-bit
 1057|  94.0k|            {
 1058|  94.0k|                ibuf = pMesh->getHardwareBufferManager()->createIndexBuffer(
 1059|  94.0k|                        HardwareIndexBuffer::IT_16BIT,
 1060|  94.0k|                        sm->indexData->indexCount,
 1061|  94.0k|                        pMesh->mIndexBufferUsage,
 1062|  94.0k|                        pMesh->mIndexBufferShadowBuffer);
 1063|  94.0k|                HardwareBufferLockGuard ibufLock(ibuf, HardwareBuffer::HBL_DISCARD);
 1064|  94.0k|                readShorts(stream, static_cast<unsigned short*>(ibufLock.pData), sm->indexData->indexCount);
 1065|  94.0k|            }
 1066|  96.6k|        }
 1067|   196k|        sm->indexData->indexBuffer = ibuf;
 1068|       |
 1069|   196k|        pushInnerChunk(stream);
 1070|   196k|        {
 1071|       |        // M_GEOMETRY stream (Optional: present only if useSharedVertices = false)
 1072|   196k|        if (!sm->useSharedVertices)
  ------------------
  |  Branch (1072:13): [True: 124k, False: 72.3k]
  ------------------
 1073|   124k|        {
 1074|   124k|            streamID = readChunk(stream);
 1075|   124k|            if (streamID != M_GEOMETRY)
  ------------------
  |  Branch (1075:17): [True: 66, False: 124k]
  ------------------
 1076|     66|            {
 1077|     66|                OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Missing geometry data in mesh file",
 1078|     66|                    "MeshSerializerImpl::readSubMesh");
 1079|     66|            }
 1080|   124k|            sm->createVertexData();
 1081|   124k|            readGeometry(stream, pMesh, sm->vertexData);
 1082|   124k|        }
 1083|       |
 1084|       |
 1085|       |        // Find all bone assignments, submesh operation, and texture aliases (if present)
 1086|   196k|        if (!stream->eof())
  ------------------
  |  Branch (1086:13): [True: 196k, False: 314]
  ------------------
 1087|   196k|        {
 1088|   196k|            streamID = readChunk(stream);
 1089|   196k|            bool seenTexAlias = false;
 1090|   199k|            while(!stream->eof() &&
  ------------------
  |  Branch (1090:19): [True: 199k, False: 208]
  ------------------
 1091|   199k|                (streamID == M_SUBMESH_BONE_ASSIGNMENT ||
  ------------------
  |  Branch (1091:18): [True: 1.66k, False: 198k]
  ------------------
 1092|   198k|                 streamID == M_SUBMESH_OPERATION ||
  ------------------
  |  Branch (1092:18): [True: 198, False: 197k]
  ------------------
 1093|   197k|                 streamID == M_SUBMESH_TEXTURE_ALIAS))
  ------------------
  |  Branch (1093:18): [True: 1.46k, False: 196k]
  ------------------
 1094|  3.32k|            {
 1095|  3.32k|                switch(streamID)
  ------------------
  |  Branch (1095:24): [True: 3.32k, False: 0]
  ------------------
 1096|  3.32k|                {
 1097|    198|                case M_SUBMESH_OPERATION:
  ------------------
  |  Branch (1097:17): [True: 198, False: 3.12k]
  ------------------
 1098|    198|                    readSubMeshOperation(stream, pMesh, sm);
 1099|    198|                    break;
 1100|  1.66k|                case M_SUBMESH_BONE_ASSIGNMENT:
  ------------------
  |  Branch (1100:17): [True: 1.66k, False: 1.66k]
  ------------------
 1101|  1.66k|                    readSubMeshBoneAssignment(stream, pMesh, sm);
 1102|  1.66k|                    break;
 1103|  1.46k|                case M_SUBMESH_TEXTURE_ALIAS:
  ------------------
  |  Branch (1103:17): [True: 1.46k, False: 1.86k]
  ------------------
 1104|  1.46k|                    seenTexAlias = true;
 1105|  1.46k|                    String aliasName = readString(stream);
 1106|  1.46k|                    String textureName = readString(stream);
 1107|  1.46k|                    break;
 1108|  3.32k|                }
 1109|       |
 1110|  3.32k|                if (!stream->eof())
  ------------------
  |  Branch (1110:21): [True: 3.22k, False: 101]
  ------------------
 1111|  3.22k|                {
 1112|  3.22k|                    streamID = readChunk(stream);
 1113|  3.22k|                }
 1114|       |
 1115|  3.32k|            }
 1116|       |
 1117|   196k|            if (seenTexAlias)
  ------------------
  |  Branch (1117:17): [True: 826, False: 195k]
  ------------------
 1118|    826|                LogManager::getSingleton().logError("texture aliases for SubMeshes are unsupported - " +
 1119|    826|                                                      stream->getName());
 1120|       |
 1121|   196k|            if (!stream->eof())
  ------------------
  |  Branch (1121:17): [True: 196k, False: 208]
  ------------------
 1122|   196k|            {
 1123|       |                // Backpedal back to start of stream
 1124|   196k|                    backpedalChunkHeader(stream);
 1125|   196k|                }
 1126|   196k|            }
 1127|   196k|        }
 1128|   196k|        popInnerChunk(stream);
 1129|       |
 1130|   196k|    }
_ZN4Ogre18MeshSerializerImpl20readSubMeshOperationERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEPNS_7SubMeshE:
 1134|    198|    {
 1135|       |        // unsigned short operationType
 1136|    198|        unsigned short opType;
 1137|    198|        readShorts(stream, &opType, 1);
 1138|    198|        sm->operationType = static_cast<RenderOperation::OperationType>(opType);
 1139|    198|    }
_ZN4Ogre18MeshSerializerImpl16readSkeletonLinkERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEPNS_22MeshSerializerListenerE:
 1150|  18.4k|    {
 1151|  18.4k|        String skelName = readString(stream);
 1152|       |
 1153|  18.4k|        if(listener)
  ------------------
  |  Branch (1153:12): [True: 0, False: 18.4k]
  ------------------
 1154|      0|            listener->processSkeletonName(pMesh, &skelName);
 1155|       |
 1156|  18.4k|        pMesh->setSkeletonName(skelName);
 1157|  18.4k|    }
_ZN4Ogre18MeshSerializerImpl22readMeshBoneAssignmentERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshE:
 1200|  1.91k|    {
 1201|  1.91k|        VertexBoneAssignment assign;
 1202|       |
 1203|       |        // unsigned int vertexIndex;
 1204|  1.91k|        readInts(stream, &(assign.vertexIndex),1);
 1205|       |        // unsigned short boneIndex;
 1206|  1.91k|        readShorts(stream, &(assign.boneIndex),1);
 1207|       |        // float weight;
 1208|  1.91k|        readFloats(stream, &(assign.weight), 1);
 1209|       |
 1210|  1.91k|        pMesh->addBoneAssignment(assign);
 1211|       |
 1212|  1.91k|    }
_ZN4Ogre18MeshSerializerImpl25readSubMeshBoneAssignmentERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEPNS_7SubMeshE:
 1216|  1.66k|    {
 1217|  1.66k|        VertexBoneAssignment assign;
 1218|       |
 1219|       |        // unsigned int vertexIndex;
 1220|  1.66k|        readInts(stream, &(assign.vertexIndex),1);
 1221|       |        // unsigned short boneIndex;
 1222|  1.66k|        readShorts(stream, &(assign.boneIndex),1);
 1223|       |        // float weight;
 1224|  1.66k|        readFloats(stream, &(assign.weight), 1);
 1225|       |
 1226|  1.66k|        sub->addBoneAssignment(assign);
 1227|       |
 1228|  1.66k|    }
_ZN4Ogre18MeshSerializerImpl14readBoundsInfoERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshE:
 1406|  3.45k|    {
 1407|  3.45k|        Vector3 min, max;
 1408|  3.45k|        readFloats(stream, min.ptr(), 3);
 1409|  3.45k|        readFloats(stream, max.ptr(), 3);
 1410|  3.45k|        AxisAlignedBox box(min, max);
 1411|  3.45k|        pMesh->_setBounds(box, false);
 1412|       |
 1413|  3.45k|        float radius;
 1414|  3.45k|        readFloats(stream, &radius, 1);
 1415|  3.45k|        pMesh->_setBoundingSphereRadius(radius);
 1416|  3.45k|    }
_ZN4Ogre18MeshSerializerImpl16readMeshLodLevelERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshE:
 1426|  3.87k|    {
 1427|       |#if OGRE_NO_MESHLOD
 1428|       |
 1429|       |        /*
 1430|       |        //Since the chunk sizes in old versions are messed up, we can't use this clean solution.
 1431|       |        // We need to walk through the data to not rely on the chunk size!
 1432|       |        stream->skip(mCurrentstreamLen);
 1433|       |
 1434|       |        // Since we got here, we have already read the chunk header.
 1435|       |        backpedalChunkHeader(stream);
 1436|       |        */
 1437|       |        uint16 numSubs = pMesh->getNumSubMeshes();
 1438|       |        String strategyName = readString(stream);
 1439|       |        uint16 numLods;
 1440|       |        readShorts(stream, &numLods, 1);
 1441|       |        if (!checkChunkRemainingSize(mCurrentstreamLen, numLods > 0 ? numLods - 1 : 0, MSTREAM_OVERHEAD_SIZE + sizeof(float)))
 1442|       |            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "LOD level count exceeds chunk size");
 1443|       |        pushInnerChunk(stream);
 1444|       |        for (int lodID = 1; lodID < numLods; lodID++){
 1445|       |            unsigned short streamID = readChunk(stream);
 1446|       |            Real usageValue;
 1447|       |            readFloats(stream, &usageValue, 1);
 1448|       |            switch (streamID){
 1449|       |            case M_MESH_LOD_MANUAL:
 1450|       |            {
 1451|       |                                      String manualName = readString(stream);
 1452|       |                                      break;
 1453|       |            }
 1454|       |            case M_MESH_LOD_GENERATED:
 1455|       |                for (int i = 0; i < numSubs; ++i)
 1456|       |                {
 1457|       |                    unsigned int numIndexes;
 1458|       |                    readInts(stream, &numIndexes, 1);
 1459|       |
 1460|       |                    unsigned int offset;
 1461|       |                    readInts(stream, &offset, 1);
 1462|       |
 1463|       |                    // For merged buffers, you can pass the index of previous Lod.
 1464|       |                    // To create buffer it should be -1.
 1465|       |                    unsigned int bufferIndex;
 1466|       |                    readInts(stream, &bufferIndex, 1);
 1467|       |                    if (bufferIndex == (unsigned int)-1) {
 1468|       |                        // generate buffers
 1469|       |
 1470|       |                        // bool indexes32Bit
 1471|       |                        bool idx32Bit;
 1472|       |                        readBools(stream, &idx32Bit, 1);
 1473|       |
 1474|       |                        unsigned int buffIndexCount;
 1475|       |                        readInts(stream, &buffIndexCount, 1);
 1476|       |
 1477|       |                        size_t buffSize = buffIndexCount * (idx32Bit ? 4 : 2);
 1478|       |                        stream->skip(buffSize);
 1479|       |                    }
 1480|       |                }
 1481|       |                break;
 1482|       |            default:
 1483|       |                OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
 1484|       |                    "Invalid Lod Usage type in " + pMesh->getName(),
 1485|       |                    "MeshSerializerImpl::readMeshLodInfo");
 1486|       |            }
 1487|       |        }
 1488|       |        popInnerChunk(stream);
 1489|       |#else
 1490|       |        // Read the strategy to be used for this mesh
 1491|  3.87k|        String strategyName = readString(stream);
 1492|  3.87k|        LodStrategy *strategy = LodStrategyManager::getSingleton().getStrategy(strategyName);
 1493|       |
 1494|       |        // Check that valid strategy name was given, otherwise use default
 1495|  3.87k|        if (strategy == 0)
  ------------------
  |  Branch (1495:13): [True: 3.42k, False: 451]
  ------------------
 1496|  3.42k|            strategy = LodStrategyManager::getSingleton().getDefaultStrategy();
 1497|       |
 1498|  3.87k|        pMesh->setLodStrategy(strategy);
 1499|       |
 1500|       |        // unsigned short numLevels;
 1501|  3.87k|        uint16 numLods;
 1502|  3.87k|        readShorts(stream, &numLods, 1);
 1503|  3.87k|        numLods = std::max<ushort>(numLods, 1);
 1504|       |
 1505|  3.87k|        if (!checkChunkRemainingSize(mCurrentstreamLen, numLods - 1, MSTREAM_OVERHEAD_SIZE + sizeof(float)))
  ------------------
  |  Branch (1505:13): [True: 64, False: 3.81k]
  ------------------
 1506|  3.87k|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "LOD level count exceeds chunk size");
 1507|       |
 1508|  3.81k|        if(pMesh->getNumLodLevels() > 1)
  ------------------
  |  Branch (1508:12): [True: 2, False: 3.81k]
  ------------------
 1509|  3.81k|            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "LOD levels already exist in mesh");
 1510|       |
 1511|  3.81k|        pMesh->_setLodInfo(numLods);
 1512|  3.81k|        pushInnerChunk(stream);
 1513|       |        // lodID=0 is the original mesh. We need to skip it.
 1514|  4.23k|        for(int lodID = 1; lodID < pMesh->getNumLodLevels(); lodID++){
  ------------------
  |  Branch (1514:28): [True: 692, False: 3.54k]
  ------------------
 1515|       |            // Read depth
 1516|    692|            MeshLodUsage& usage = pMesh->mMeshLodUsageList[lodID];
 1517|    692|            unsigned short streamID = readChunk(stream);
 1518|    692|            readFloats(stream, &(usage.userValue), 1);
 1519|    692|            switch(streamID){
 1520|    342|            case M_MESH_LOD_MANUAL:
  ------------------
  |  Branch (1520:13): [True: 342, False: 350]
  ------------------
 1521|    342|                readMeshLodUsageManual(stream, pMesh, lodID, usage);
 1522|    342|                break;
 1523|    206|            case M_MESH_LOD_GENERATED:
  ------------------
  |  Branch (1523:13): [True: 206, False: 486]
  ------------------
 1524|    206|                readMeshLodUsageGenerated(stream, pMesh, lodID, usage);
 1525|    206|                break;
 1526|     95|            default:
  ------------------
  |  Branch (1526:13): [True: 95, False: 597]
  ------------------
 1527|     95|                OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
 1528|    692|                "Invalid Lod Usage type in " + pMesh->getName(),
 1529|    692|                    "MeshSerializerImpl::readMeshLodInfo");
 1530|    692|            }
 1531|    424|            usage.manualMesh.reset(); // will trigger load later with manual Lod
 1532|    424|            usage.edgeData = NULL;
 1533|    424|        }
 1534|  3.54k|        popInnerChunk(stream);
 1535|  3.54k|#endif
 1536|  3.54k|    }
_ZN4Ogre18MeshSerializerImpl22readMeshLodUsageManualERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEtRNS_12MeshLodUsageE:
 1540|    342|    {
 1541|    342|        pMesh->mHasManualLodLevel = true;
 1542|    342|        usage.manualName = readString(stream);
 1543|       |        
 1544|       |        // Generate for mixed
 1545|    342|        for (auto *s : pMesh->getSubMeshes())
  ------------------
  |  Branch (1545:22): [True: 892, False: 342]
  ------------------
 1546|    892|        {
 1547|       |            s->mLodFaceList[lodNum-1] = OGRE_NEW IndexData();
 1548|    892|        }
 1549|    342|    }
_ZN4Ogre18MeshSerializerImpl25readMeshLodUsageGeneratedERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEtRNS_12MeshLodUsageE:
 1552|    206|    {
 1553|    206|        usage.manualName = "";
 1554|       |
 1555|       |        // Get one set of detail per SubMesh
 1556|    206|        for (auto *s : pMesh->getSubMeshes())
  ------------------
  |  Branch (1556:22): [True: 1.39k, False: 82]
  ------------------
 1557|  1.39k|        {
 1558|  1.39k|            s->mLodFaceList[lodNum - 1] = OGRE_NEW IndexData();
 1559|  1.39k|            IndexData* indexData = s->mLodFaceList[lodNum - 1];
 1560|       |
 1561|  1.39k|            unsigned int numIndexes;
 1562|  1.39k|            readInts(stream, &numIndexes, 1);
 1563|  1.39k|            indexData->indexCount = static_cast<size_t>(numIndexes);
 1564|       |
 1565|  1.39k|            unsigned int offset;
 1566|  1.39k|            readInts(stream, &offset, 1);
 1567|  1.39k|            indexData->indexStart = static_cast<size_t>(offset);
 1568|       |
 1569|       |            // For merged buffers, you can pass the index of previous Lod.
 1570|       |            // To create buffer it should be -1.
 1571|  1.39k|            unsigned int bufferIndex;
 1572|  1.39k|            readInts(stream, &bufferIndex, 1);
 1573|  1.39k|            if(bufferIndex != (unsigned int)-1) {
  ------------------
  |  Branch (1573:16): [True: 76, False: 1.31k]
  ------------------
 1574|     76|                if (bufferIndex - 1 >= (unsigned int)lodNum - 1)
  ------------------
  |  Branch (1574:21): [True: 71, False: 5]
  ------------------
 1575|     76|                    OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Invalid LOD buffer index in mesh LOD data");
 1576|       |                // copy buffer pointer
 1577|      5|                indexData->indexBuffer = s->mLodFaceList.at(bufferIndex - 1)->indexBuffer;
 1578|      5|                if (!indexData->indexBuffer)
  ------------------
  |  Branch (1578:21): [True: 2, False: 3]
  ------------------
 1579|      5|                    OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Referenced LOD index buffer is null");
 1580|  1.31k|            } else {
 1581|       |                // generate buffers
 1582|       |
 1583|       |                // bool indexes32Bit
 1584|  1.31k|                bool idx32Bit;
 1585|  1.31k|                readBools(stream, &idx32Bit, 1);
 1586|       |                
 1587|  1.31k|                unsigned int buffIndexCount;
 1588|  1.31k|                readInts(stream, &buffIndexCount, 1);
 1589|       |
 1590|  1.31k|                if (!checkChunkRemainingSize(mCurrentstreamLen, buffIndexCount, idx32Bit ? 4 : 2))
  ------------------
  |  Branch (1590:21): [True: 51, False: 1.26k]
  |  Branch (1590:81): [True: 680, False: 637]
  ------------------
 1591|  1.31k|                    OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "LOD index data exceeds chunk size");
 1592|       |
 1593|  1.26k|                indexData->indexBuffer = pMesh->getHardwareBufferManager()->createIndexBuffer(
 1594|  1.26k|                    idx32Bit ? HardwareIndexBuffer::IT_32BIT : HardwareIndexBuffer::IT_16BIT,
  ------------------
  |  Branch (1594:21): [True: 636, False: 630]
  ------------------
 1595|  1.26k|                    buffIndexCount, pMesh->mIndexBufferUsage, pMesh->mIndexBufferShadowBuffer);
 1596|  1.26k|                HardwareBufferLockGuard ibufLock(indexData->indexBuffer, HardwareBuffer::HBL_DISCARD);
 1597|       |
 1598|  1.26k|                if (idx32Bit)
  ------------------
  |  Branch (1598:21): [True: 636, False: 630]
  ------------------
 1599|    636|                {
 1600|    636|                    readInts(stream, (uint32*)ibufLock.pData, buffIndexCount);
 1601|    636|                }
 1602|    630|                else
 1603|    630|                {
 1604|    630|                    readShorts(stream, (uint16*)ibufLock.pData, buffIndexCount);
 1605|    630|                }
 1606|  1.26k|            }
 1607|  1.39k|        }
 1608|    206|    }
_ZN4Ogre18MeshSerializerImpl20flipFromLittleEndianEPvmmRKNSt3__14listINS_13VertexElementENS2_9allocatorIS4_EEEE:
 1613|  8.80k|    {
 1614|  8.80k|        if (mFlipEndian)
  ------------------
  |  Branch (1614:13): [True: 8.80k, False: 0]
  ------------------
 1615|  8.80k|        {
 1616|  8.80k|            flipEndian(pData, vertexCount, vertexSize, elems);
 1617|  8.80k|        }
 1618|  8.80k|    }
_ZN4Ogre18MeshSerializerImpl10flipEndianEPvmmRKNSt3__14listINS_13VertexElementENS2_9allocatorIS4_EEEE:
 1631|  8.80k|    {
 1632|  8.80k|        void *pBase = pData;
 1633|  27.9k|        for (size_t v = 0; v < vertexCount; ++v)
  ------------------
  |  Branch (1633:28): [True: 19.1k, False: 8.80k]
  ------------------
 1634|  19.1k|        {
 1635|  19.1k|            for (auto& e : elems)
  ------------------
  |  Branch (1635:26): [True: 32.8k, False: 19.1k]
  ------------------
 1636|  32.8k|            {
 1637|  32.8k|                void *pElem;
 1638|       |                // re-base pointer to the element
 1639|  32.8k|                e.baseVertexPointerToElement(pBase, &pElem);
 1640|       |                // Flip the endian based on the type
 1641|  32.8k|                size_t typeSize = 0;
 1642|  32.8k|                switch (VertexElement::getBaseType(e.getType()))
 1643|  32.8k|                {
 1644|  4.28k|                    case VET_FLOAT1:
  ------------------
  |  Branch (1644:21): [True: 4.28k, False: 28.5k]
  ------------------
 1645|  4.28k|                        typeSize = sizeof(float);
 1646|  4.28k|                        break;
 1647|  1.24k|                    case VET_DOUBLE1:
  ------------------
  |  Branch (1647:21): [True: 1.24k, False: 31.6k]
  ------------------
 1648|  1.24k|                        typeSize = sizeof(double);
 1649|  1.24k|                        break;
 1650|  2.53k|                    case VET_SHORT1:
  ------------------
  |  Branch (1650:21): [True: 2.53k, False: 30.3k]
  ------------------
 1651|  2.53k|                        typeSize = sizeof(short);
 1652|  2.53k|                        break;
 1653|    892|                    case VET_USHORT1:
  ------------------
  |  Branch (1653:21): [True: 892, False: 31.9k]
  ------------------
 1654|    892|                        typeSize = sizeof(unsigned short);
 1655|    892|                        break;
 1656|    880|                    case VET_INT1:
  ------------------
  |  Branch (1656:21): [True: 880, False: 31.9k]
  ------------------
 1657|    880|                        typeSize = sizeof(int);
 1658|    880|                        break;
 1659|  1.60k|                    case VET_UINT1:
  ------------------
  |  Branch (1659:21): [True: 1.60k, False: 31.2k]
  ------------------
 1660|  1.60k|                        typeSize = sizeof(unsigned int);
 1661|  1.60k|                        break;
 1662|  4.99k|                    case VET_UBYTE4_NORM:
  ------------------
  |  Branch (1662:21): [True: 4.99k, False: 27.8k]
  ------------------
 1663|  5.09k|                    case VET_UBYTE4:
  ------------------
  |  Branch (1663:21): [True: 102, False: 32.7k]
  ------------------
 1664|  5.09k|                        typeSize = 0; // NO FLIPPING
 1665|  5.09k|                        break;
 1666|  16.3k|                    default:
  ------------------
  |  Branch (1666:21): [True: 16.3k, False: 16.5k]
  ------------------
 1667|  16.3k|                        assert(false); // Should never happen
 1668|  32.8k|                };
 1669|  32.8k|				Bitwise::bswapChunks(pElem, typeSize,
 1670|  32.8k|                    VertexElement::getTypeCount(e.getType()));
 1671|  32.8k|            }
 1672|       |
 1673|  19.1k|            pBase = static_cast<void*>(
 1674|  19.1k|                static_cast<unsigned char*>(pBase) + vertexSize);
 1675|  19.1k|        }
 1676|  8.80k|    }
_ZN4Ogre18MeshSerializerImpl12readEdgeListERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshE:
 1861|  1.25k|    {
 1862|  1.25k|        pMesh->mEdgeListsBuilt = true; // set this early, so any partial data is freed
 1863|       |
 1864|  1.25k|        if (!stream->eof())
  ------------------
  |  Branch (1864:13): [True: 1.25k, False: 0]
  ------------------
 1865|  1.25k|        {
 1866|  1.25k|            pushInnerChunk(stream);
 1867|  1.25k|            unsigned short streamID = readChunk(stream);
 1868|  2.15k|            while(!stream->eof() &&
  ------------------
  |  Branch (1868:19): [True: 1.67k, False: 481]
  ------------------
 1869|  1.67k|                streamID == M_EDGE_LIST_LOD)
  ------------------
  |  Branch (1869:17): [True: 914, False: 758]
  ------------------
 1870|    914|            {
 1871|       |                // Process single LOD
 1872|       |
 1873|       |                // unsigned short lodIndex
 1874|    914|                unsigned short lodIndex;
 1875|    914|                readShorts(stream, &lodIndex, 1);
 1876|       |
 1877|       |                // bool isManual            // If manual, no edge data here, loaded from manual mesh
 1878|    914|                bool isManual;
 1879|    914|                readBools(stream, &isManual, 1);
 1880|       |                // Only load in non-manual levels; others will be connected up by Mesh on demand
 1881|       |#if OGRE_NO_MESHLOD
 1882|       |                // 
 1883|       |                if (!isManual)
 1884|       |                    if (lodIndex != 0) {
 1885|       |                        readEdgeListLodInfo(stream, NULL);
 1886|       |                    } else {
 1887|       |#else
 1888|    914|                if (!isManual) {
  ------------------
  |  Branch (1888:21): [True: 488, False: 426]
  ------------------
 1889|    488|#endif
 1890|    488|                    MeshLodUsage& usage = pMesh->mMeshLodUsageList.at(lodIndex);
 1891|    488|                    if(!usage.manualName.empty())
  ------------------
  |  Branch (1891:24): [True: 17, False: 471]
  ------------------
 1892|    488|                        OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "LOD is marked as non-manual, but has a manual mesh name");
 1893|       |
 1894|    471|                    if (usage.edgeData)
  ------------------
  |  Branch (1894:25): [True: 1, False: 470]
  ------------------
 1895|    471|                        OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Duplicate edge data for LOD");
 1896|       |
 1897|    470|                    auto edgeData = std::make_unique<EdgeData>(); // in case of exception, will be deleted automatically
 1898|       |
 1899|       |                    // Read detail information of the edge list
 1900|    470|                    readEdgeListLodInfo(stream, edgeData.get());
 1901|       |
 1902|       |                    // Postprocessing edge groups
 1903|    470|                    for (auto& edgeGroup : edgeData->edgeGroups)
  ------------------
  |  Branch (1903:42): [True: 172, False: 470]
  ------------------
 1904|    172|                    {
 1905|       |                        // Populate edgeGroup.vertexData pointers
 1906|       |                        // If there is shared vertex data, vertexSet 0 is that,
 1907|       |                        // otherwise 0 is first dedicated
 1908|    172|                        if (pMesh->sharedVertexData)
  ------------------
  |  Branch (1908:29): [True: 100, False: 72]
  ------------------
 1909|    100|                        {
 1910|    100|                            if (edgeGroup.vertexSet == 0)
  ------------------
  |  Branch (1910:33): [True: 57, False: 43]
  ------------------
 1911|     57|                            {
 1912|     57|                                edgeGroup.vertexData = pMesh->sharedVertexData;
 1913|     57|                            }
 1914|     43|                            else
 1915|     43|                            {
 1916|     43|                                edgeGroup.vertexData = pMesh->getSubMeshes().at(edgeGroup.vertexSet - 1)->vertexData;
 1917|     43|                            }
 1918|    100|                        }
 1919|     72|                        else
 1920|     72|                        {
 1921|     72|                            edgeGroup.vertexData = pMesh->getSubMeshes().at(edgeGroup.vertexSet)->vertexData;
 1922|     72|                        }
 1923|    172|                    }
 1924|       |
 1925|    470|                    usage.edgeData = edgeData.release();
 1926|    470|                }
 1927|       |
 1928|    896|                if (!stream->eof())
  ------------------
  |  Branch (1928:21): [True: 452, False: 444]
  ------------------
 1929|    452|                {
 1930|    452|                    streamID = readChunk(stream);
 1931|    452|                }
 1932|       |
 1933|    896|            }
 1934|  1.23k|            if (!stream->eof())
  ------------------
  |  Branch (1934:17): [True: 758, False: 481]
  ------------------
 1935|    758|            {
 1936|       |                // Backpedal back to start of stream
 1937|    758|                backpedalChunkHeader(stream);
 1938|    758|            }
 1939|  1.23k|            popInnerChunk(stream);
 1940|  1.23k|        }
 1941|  1.25k|    }
_ZN4Ogre18MeshSerializerImpl19readEdgeListLodInfoERKNS_9SharedPtrINS_10DataStreamEEEPNS_8EdgeDataE:
 1945|    453|    {
 1946|       |#if OGRE_NO_MESHLOD
 1947|       |        if (edgeData == NULL) { // skip it!
 1948|       |            bool isClosed;
 1949|       |            readBools(stream, &isClosed, 1);
 1950|       |            // unsigned long numTriangles
 1951|       |            uint32 numTriangles;
 1952|       |            readInts(stream, &numTriangles, 1);
 1953|       |            // unsigned long numEdgeGroups
 1954|       |            uint32 numEdgeGroups;
 1955|       |            readInts(stream, &numEdgeGroups, 1);
 1956|       |            stream->skip(numTriangles * (8 * sizeof(uint32) + 4 * sizeof(float)));
 1957|       |            pushInnerChunk(stream);
 1958|       |            for (uint32 eg = 0; eg < numEdgeGroups; ++eg)
 1959|       |            {
 1960|       |                unsigned short streamID = readChunk(stream);
 1961|       |                if (streamID != M_EDGE_GROUP)
 1962|       |                {
 1963|       |                    OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
 1964|       |                        "Missing M_EDGE_GROUP stream",
 1965|       |                        "MeshSerializerImpl::readEdgeListLodInfo");
 1966|       |                }
 1967|       |                uint32 tmp[3];
 1968|       |                // unsigned long vertexSet
 1969|       |                readInts(stream, &tmp[0], 3);
 1970|       |                uint32 numEdges;
 1971|       |                readInts(stream, &numEdges, 1);
 1972|       |
 1973|       |                stream->skip(numEdges * (6 * sizeof(uint32) + sizeof(bool)));
 1974|       |            }
 1975|       |            popInnerChunk(stream);
 1976|       |            return;
 1977|       |        }
 1978|       |#endif
 1979|       |        // bool isClosed
 1980|    453|        readBools(stream, &edgeData->isClosed, 1);
 1981|       |        // unsigned long numTriangles
 1982|    453|        uint32 numTriangles;
 1983|    453|        readInts(stream, &numTriangles, 1);
 1984|    453|        if(!checkChunkRemainingSize(mCurrentstreamLen, numTriangles, sizeof(EdgeData::Triangle) + sizeof(Vector4f)))
  ------------------
  |  Branch (1984:12): [True: 58, False: 395]
  ------------------
 1985|    453|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Edge list triangle data exceeds chunk size");
 1986|       |
 1987|       |        // Allocate correct amount of memory
 1988|    395|        edgeData->triangles.resize(numTriangles);
 1989|    395|        edgeData->triangleFaceNormals.resize(numTriangles);
 1990|    395|        edgeData->triangleLightFacings.resize(numTriangles);
 1991|       |        // unsigned long numEdgeGroups
 1992|    395|        uint32 numEdgeGroups;
 1993|    395|        readInts(stream, &numEdgeGroups, 1);
 1994|    395|        if(!checkChunkRemainingSize(mCurrentstreamLen, numEdgeGroups, sizeof(uint32) * 4))
  ------------------
  |  Branch (1994:12): [True: 69, False: 326]
  ------------------
 1995|    395|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Edge list group data exceeds chunk size");
 1996|       |
 1997|       |        // Allocate correct amount of memory
 1998|    326|        edgeData->edgeGroups.resize(numEdgeGroups);
 1999|       |        // Triangle* triangleList
 2000|    326|        uint32 tmp[3];
 2001|  13.4k|        for (size_t t = 0; t < numTriangles; ++t)
  ------------------
  |  Branch (2001:28): [True: 13.1k, False: 326]
  ------------------
 2002|  13.1k|        {
 2003|  13.1k|            EdgeData::Triangle& tri = edgeData->triangles[t];
 2004|       |            // unsigned long indexSet
 2005|  13.1k|            readInts(stream, tmp, 1);
 2006|  13.1k|            tri.indexSet = tmp[0];
 2007|       |            // unsigned long vertexSet
 2008|  13.1k|            readInts(stream, tmp, 1);
 2009|  13.1k|            tri.vertexSet = tmp[0];
 2010|       |            // unsigned long vertIndex[3]
 2011|  13.1k|            readInts(stream, tmp, 3);
 2012|       |
 2013|  13.1k|            tri.vertIndex[0] = tmp[0];
 2014|  13.1k|            tri.vertIndex[1] = tmp[1];
 2015|  13.1k|            tri.vertIndex[2] = tmp[2];
 2016|       |            // unsigned long sharedVertIndex[3]
 2017|  13.1k|            readInts(stream, tmp, 3);
 2018|  13.1k|            tri.sharedVertIndex[0] = tmp[0];
 2019|  13.1k|            tri.sharedVertIndex[1] = tmp[1];
 2020|  13.1k|            tri.sharedVertIndex[2] = tmp[2];
 2021|       |            // float normal[4]
 2022|  13.1k|            readFloats(stream, &(edgeData->triangleFaceNormals[t].x), 4);
 2023|       |
 2024|  13.1k|        }
 2025|    326|        pushInnerChunk(stream);
 2026|    630|        for (uint32 eg = 0; eg < numEdgeGroups; ++eg)
  ------------------
  |  Branch (2026:29): [True: 552, False: 78]
  ------------------
 2027|    552|        {
 2028|    552|            unsigned short streamID = readChunk(stream);
 2029|    552|            if (streamID != M_EDGE_GROUP)
  ------------------
  |  Branch (2029:17): [True: 99, False: 453]
  ------------------
 2030|     99|            {
 2031|     99|                OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
 2032|     99|                    "Missing M_EDGE_GROUP stream",
 2033|     99|                    "MeshSerializerImpl::readEdgeListLodInfo");
 2034|     99|            }
 2035|    453|            EdgeData::EdgeGroup& edgeGroup = edgeData->edgeGroups[eg];
 2036|       |
 2037|       |            // unsigned long vertexSet
 2038|    453|            readInts(stream, tmp, 1);
 2039|    453|            edgeGroup.vertexSet = tmp[0];
 2040|       |            // unsigned long triStart
 2041|    453|            readInts(stream, tmp, 1);
 2042|    453|            edgeGroup.triStart = tmp[0];
 2043|       |            // unsigned long triCount
 2044|    453|            readInts(stream, tmp, 1);
 2045|    453|            edgeGroup.triCount = tmp[0];
 2046|       |            // unsigned long numEdges
 2047|    453|            uint32 numEdges;
 2048|    453|            readInts(stream, &numEdges, 1);
 2049|    453|            if(!checkChunkRemainingSize(mCurrentstreamLen, numEdges, sizeof(uint32) * 6 + sizeof(bool)))
  ------------------
  |  Branch (2049:16): [True: 149, False: 304]
  ------------------
 2050|    453|                OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Edge list edge data exceeds chunk size");
 2051|       |
 2052|    304|            edgeGroup.edges.resize(numEdges);
 2053|       |            // Edge* edgeList
 2054|   302M|            for (uint32 e = 0; e < numEdges; ++e)
  ------------------
  |  Branch (2054:32): [True: 302M, False: 304]
  ------------------
 2055|   302M|            {
 2056|   302M|                EdgeData::Edge& edge = edgeGroup.edges[e];
 2057|       |                // unsigned long  triIndex[2]
 2058|   302M|                readInts(stream, tmp, 2);
 2059|   302M|                edge.triIndex[0] = tmp[0];
 2060|   302M|                edge.triIndex[1] = tmp[1];
 2061|       |                // unsigned long  vertIndex[2]
 2062|   302M|                readInts(stream, tmp, 2);
 2063|   302M|                edge.vertIndex[0] = tmp[0];
 2064|   302M|                edge.vertIndex[1] = tmp[1];
 2065|       |                // unsigned long  sharedVertIndex[2]
 2066|   302M|                readInts(stream, tmp, 2);
 2067|   302M|                edge.sharedVertIndex[0] = tmp[0];
 2068|   302M|                edge.sharedVertIndex[1] = tmp[1];
 2069|       |                // bool degenerate
 2070|   302M|                readBools(stream, &(edge.degenerate), 1);
 2071|   302M|            }
 2072|    304|        }
 2073|     78|        popInnerChunk(stream);
 2074|     78|    }
_ZN4Ogre18MeshSerializerImpl9readPosesERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshE:
 2389|  1.38k|    {
 2390|       |        // Find all substreams
 2391|  1.38k|        if (!stream->eof())
  ------------------
  |  Branch (2391:13): [True: 1.38k, False: 0]
  ------------------
 2392|  1.38k|        {
 2393|  1.38k|            pushInnerChunk(stream);
 2394|  1.38k|            unsigned short streamID = readChunk(stream);
 2395|  20.6k|            while(!stream->eof() &&
  ------------------
  |  Branch (2395:19): [True: 20.3k, False: 343]
  ------------------
 2396|  20.3k|                (streamID == M_POSE))
  ------------------
  |  Branch (2396:17): [True: 19.2k, False: 1.03k]
  ------------------
 2397|  19.2k|            {
 2398|  19.2k|                switch(streamID)
  ------------------
  |  Branch (2398:24): [True: 19.2k, False: 0]
  ------------------
 2399|  19.2k|                {
 2400|  19.2k|                case M_POSE:
  ------------------
  |  Branch (2400:17): [True: 19.2k, False: 0]
  ------------------
 2401|  19.2k|                    readPose(stream, pMesh);
 2402|  19.2k|                    break;
 2403|       |
 2404|  19.2k|                }
 2405|       |
 2406|  19.2k|                if (!stream->eof())
  ------------------
  |  Branch (2406:21): [True: 18.9k, False: 317]
  ------------------
 2407|  18.9k|                {
 2408|  18.9k|                    streamID = readChunk(stream);
 2409|  18.9k|                }
 2410|       |
 2411|  19.2k|            }
 2412|  1.38k|            if (!stream->eof())
  ------------------
  |  Branch (2412:17): [True: 1.03k, False: 343]
  ------------------
 2413|  1.03k|            {
 2414|       |                // Backpedal back to start of stream
 2415|  1.03k|                backpedalChunkHeader(stream);
 2416|  1.03k|            }
 2417|  1.38k|            popInnerChunk(stream);
 2418|  1.38k|        }
 2419|  1.38k|    }
_ZN4Ogre18MeshSerializerImpl8readPoseERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshE:
 2422|  19.2k|    {
 2423|       |        // char* name (may be blank)
 2424|  19.2k|        String name = readString(stream);
 2425|       |        // unsigned short target
 2426|  19.2k|        unsigned short target;
 2427|  19.2k|        readShorts(stream, &target, 1);
 2428|       |
 2429|       |        // bool includesNormals
 2430|  19.2k|        bool includesNormals;
 2431|  19.2k|        readBools(stream, &includesNormals, 1);
 2432|       |        
 2433|  19.2k|        Pose* pose = pMesh->createPose(target, name);
 2434|       |
 2435|       |        // Find all substreams
 2436|  19.2k|        if (!stream->eof())
  ------------------
  |  Branch (2436:13): [True: 19.2k, False: 31]
  ------------------
 2437|  19.2k|        {
 2438|  19.2k|            pushInnerChunk(stream);
 2439|  19.2k|            unsigned short streamID = readChunk(stream);
 2440|  24.1k|            while(!stream->eof() &&
  ------------------
  |  Branch (2440:19): [True: 23.8k, False: 289]
  ------------------
 2441|  23.8k|                (streamID == M_POSE_VERTEX))
  ------------------
  |  Branch (2441:17): [True: 4.87k, False: 18.9k]
  ------------------
 2442|  4.87k|            {
 2443|  4.87k|                switch(streamID)
  ------------------
  |  Branch (2443:24): [True: 4.87k, False: 0]
  ------------------
 2444|  4.87k|                {
 2445|  4.87k|                case M_POSE_VERTEX:
  ------------------
  |  Branch (2445:17): [True: 4.87k, False: 0]
  ------------------
 2446|       |                    // create vertex offset
 2447|  4.87k|                    uint32 vertIndex;
 2448|  4.87k|                    Vector3f offset, normal;
 2449|       |                    // unsigned long vertexIndex
 2450|  4.87k|                    readInts(stream, &vertIndex, 1);
 2451|       |                    // float xoffset, yoffset, zoffset
 2452|  4.87k|                    readFloats(stream, offset.ptr(), 3);
 2453|       |                    
 2454|  4.87k|                    if (includesNormals)
  ------------------
  |  Branch (2454:25): [True: 2.58k, False: 2.29k]
  ------------------
 2455|  2.58k|                    {
 2456|  2.58k|                        readFloats(stream, normal.ptr(), 3);
 2457|  2.58k|                        pose->addVertex(vertIndex, offset, normal);                     
 2458|  2.58k|                    }
 2459|  2.29k|                    else 
 2460|  2.29k|                    {
 2461|  2.29k|                        pose->addVertex(vertIndex, offset);
 2462|  2.29k|                    }
 2463|       |
 2464|       |
 2465|  4.87k|                    break;
 2466|       |
 2467|  4.87k|                }
 2468|       |
 2469|  4.87k|                if (!stream->eof())
  ------------------
  |  Branch (2469:21): [True: 4.61k, False: 262]
  ------------------
 2470|  4.61k|                {
 2471|  4.61k|                    streamID = readChunk(stream);
 2472|  4.61k|                }
 2473|       |
 2474|  4.87k|            }
 2475|  19.2k|            if (!stream->eof())
  ------------------
  |  Branch (2475:17): [True: 18.9k, False: 289]
  ------------------
 2476|  18.9k|            {
 2477|       |                // Backpedal back to start of stream
 2478|  18.9k|                backpedalChunkHeader(stream);
 2479|  18.9k|            }
 2480|  19.2k|            popInnerChunk(stream);
 2481|  19.2k|        }
 2482|  19.2k|    }
_ZN4Ogre18MeshSerializerImpl14readAnimationsERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshE:
 2485|  1.84k|    {
 2486|       |        // Find all substreams
 2487|  1.84k|        if (!stream->eof())
  ------------------
  |  Branch (2487:13): [True: 1.84k, False: 0]
  ------------------
 2488|  1.84k|        {
 2489|  1.84k|            pushInnerChunk(stream);
 2490|  1.84k|            unsigned short streamID = readChunk(stream);
 2491|  4.78k|            while(!stream->eof() &&
  ------------------
  |  Branch (2491:19): [True: 4.44k, False: 338]
  ------------------
 2492|  4.44k|                (streamID == M_ANIMATION))
  ------------------
  |  Branch (2492:17): [True: 2.99k, False: 1.45k]
  ------------------
 2493|  2.99k|            {
 2494|  2.99k|                switch(streamID)
  ------------------
  |  Branch (2494:24): [True: 2.99k, False: 0]
  ------------------
 2495|  2.99k|                {
 2496|  2.99k|                case M_ANIMATION:
  ------------------
  |  Branch (2496:17): [True: 2.99k, False: 0]
  ------------------
 2497|  2.99k|                    readAnimation(stream, pMesh);
 2498|  2.99k|                    break;
 2499|       |
 2500|  2.99k|                }
 2501|       |
 2502|  2.94k|                if (!stream->eof())
  ------------------
  |  Branch (2502:21): [True: 2.63k, False: 309]
  ------------------
 2503|  2.63k|                {
 2504|  2.63k|                    streamID = readChunk(stream);
 2505|  2.63k|                }
 2506|       |
 2507|  2.94k|            }
 2508|  1.79k|            if (!stream->eof())
  ------------------
  |  Branch (2508:17): [True: 1.45k, False: 338]
  ------------------
 2509|  1.45k|            {
 2510|       |                // Backpedal back to start of stream
 2511|  1.45k|                backpedalChunkHeader(stream);
 2512|  1.45k|            }
 2513|  1.79k|            popInnerChunk(stream);
 2514|  1.79k|        }
 2515|  1.84k|    }
_ZN4Ogre18MeshSerializerImpl13readAnimationERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshE:
 2518|  2.99k|    {
 2519|       |        // char* name
 2520|  2.99k|        String name = readString(stream);
 2521|       |        // float length
 2522|  2.99k|        float len;
 2523|  2.99k|        readFloats(stream, &len, 1);
 2524|       |
 2525|  2.99k|        Animation* anim = pMesh->createAnimation(name, len);
 2526|       |
 2527|       |        // tracks
 2528|  2.99k|        if (!stream->eof())
  ------------------
  |  Branch (2528:13): [True: 2.91k, False: 76]
  ------------------
 2529|  2.91k|        {
 2530|  2.91k|            pushInnerChunk(stream);
 2531|  2.91k|            unsigned short streamID = readChunk(stream);
 2532|       |            
 2533|       |            // Optional base info is possible
 2534|  2.91k|            if (streamID == M_ANIMATION_BASEINFO)
  ------------------
  |  Branch (2534:17): [True: 138, False: 2.77k]
  ------------------
 2535|    138|            {
 2536|       |                // char baseAnimationName
 2537|    138|                String baseAnimName = readString(stream);
 2538|       |                // float baseKeyFrameTime
 2539|    138|                float baseKeyTime;
 2540|    138|                readFloats(stream, &baseKeyTime, 1);
 2541|       |                
 2542|    138|                anim->setUseBaseKeyFrame(true, baseKeyTime, baseAnimName);
 2543|       |                
 2544|    138|                if (!stream->eof())
  ------------------
  |  Branch (2544:21): [True: 129, False: 9]
  ------------------
 2545|    129|                {
 2546|       |                    // Get next stream
 2547|    129|                    streamID = readChunk(stream);
 2548|    129|                }
 2549|    138|            }
 2550|       |            
 2551|  6.52k|            while(!stream->eof() &&
  ------------------
  |  Branch (2551:19): [True: 6.28k, False: 239]
  ------------------
 2552|  6.28k|                streamID == M_ANIMATION_TRACK)
  ------------------
  |  Branch (2552:17): [True: 3.65k, False: 2.63k]
  ------------------
 2553|  3.65k|            {
 2554|  3.65k|                switch(streamID)
  ------------------
  |  Branch (2554:24): [True: 3.65k, False: 0]
  ------------------
 2555|  3.65k|                {
 2556|  3.65k|                case M_ANIMATION_TRACK:
  ------------------
  |  Branch (2556:17): [True: 3.65k, False: 0]
  ------------------
 2557|  3.65k|                    readAnimationTrack(stream, anim, pMesh);
 2558|  3.65k|                    break;
 2559|  3.65k|                };
 2560|  3.60k|                if (!stream->eof())
  ------------------
  |  Branch (2560:21): [True: 3.40k, False: 205]
  ------------------
 2561|  3.40k|                {
 2562|  3.40k|                    streamID = readChunk(stream);
 2563|  3.40k|                }
 2564|       |
 2565|  3.60k|            }
 2566|  2.87k|            if (!stream->eof())
  ------------------
  |  Branch (2566:17): [True: 2.63k, False: 239]
  ------------------
 2567|  2.63k|            {
 2568|       |                // Backpedal back to start of stream
 2569|  2.63k|                backpedalChunkHeader(stream);
 2570|  2.63k|            }
 2571|  2.87k|            popInnerChunk(stream);
 2572|  2.87k|        }
 2573|  2.99k|    }
_ZN4Ogre18MeshSerializerImpl18readAnimationTrackERKNS_9SharedPtrINS_10DataStreamEEEPNS_9AnimationEPNS_4MeshE:
 2577|  3.65k|    {
 2578|       |        // ushort type
 2579|  3.65k|        uint16 inAnimType;
 2580|  3.65k|        readShorts(stream, &inAnimType, 1);
 2581|  3.65k|        VertexAnimationType animType = (VertexAnimationType)inAnimType;
 2582|       |
 2583|       |        // unsigned short target
 2584|  3.65k|        uint16 target;
 2585|  3.65k|        readShorts(stream, &target, 1);
 2586|       |
 2587|  3.65k|        if (target > pMesh->getNumSubMeshes())
  ------------------
  |  Branch (2587:13): [True: 18, False: 3.63k]
  ------------------
 2588|  3.65k|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Invalid target for vertex animation track");
 2589|       |
 2590|  3.63k|        VertexData* vdata = pMesh->getVertexDataByTrackHandle(target);
 2591|  3.63k|        if (!vdata)
  ------------------
  |  Branch (2591:13): [True: 3, False: 3.63k]
  ------------------
 2592|  3.63k|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Animation track references target with no vertex data");
 2593|  3.63k|        VertexAnimationTrack* track = anim->createVertexTrack(target, vdata, animType);
 2594|       |
 2595|       |        // keyframes
 2596|  3.63k|        if (!stream->eof())
  ------------------
  |  Branch (2596:13): [True: 3.61k, False: 19]
  ------------------
 2597|  3.61k|        {
 2598|  3.61k|            pushInnerChunk(stream);
 2599|  3.61k|            unsigned short streamID = readChunk(stream);
 2600|  8.47k|            while(!stream->eof() &&
  ------------------
  |  Branch (2600:19): [True: 8.27k, False: 199]
  ------------------
 2601|  8.27k|                (streamID == M_ANIMATION_MORPH_KEYFRAME ||
  ------------------
  |  Branch (2601:18): [True: 2.86k, False: 5.41k]
  ------------------
 2602|  5.41k|                 streamID == M_ANIMATION_POSE_KEYFRAME))
  ------------------
  |  Branch (2602:18): [True: 2.01k, False: 3.40k]
  ------------------
 2603|  4.87k|            {
 2604|  4.87k|                switch(streamID)
  ------------------
  |  Branch (2604:24): [True: 4.87k, False: 0]
  ------------------
 2605|  4.87k|                {
 2606|  2.86k|                case M_ANIMATION_MORPH_KEYFRAME:
  ------------------
  |  Branch (2606:17): [True: 2.86k, False: 2.01k]
  ------------------
 2607|  2.86k|                    readMorphKeyFrame(stream, pMesh, track);
 2608|  2.86k|                    break;
 2609|  2.01k|                case M_ANIMATION_POSE_KEYFRAME:
  ------------------
  |  Branch (2609:17): [True: 2.01k, False: 2.86k]
  ------------------
 2610|  2.01k|                    readPoseKeyFrame(stream, track);
 2611|  2.01k|                    break;
 2612|  4.87k|                };
 2613|  4.86k|                if (!stream->eof())
  ------------------
  |  Branch (2613:21): [True: 4.69k, False: 168]
  ------------------
 2614|  4.69k|                {
 2615|  4.69k|                    streamID = readChunk(stream);
 2616|  4.69k|                }
 2617|       |
 2618|  4.86k|            }
 2619|  3.60k|            if (!stream->eof())
  ------------------
  |  Branch (2619:17): [True: 3.40k, False: 199]
  ------------------
 2620|  3.40k|            {
 2621|       |                // Backpedal back to start of stream
 2622|  3.40k|                backpedalChunkHeader(stream);
 2623|  3.40k|            }
 2624|  3.60k|            popInnerChunk(stream);
 2625|  3.60k|        }
 2626|       |
 2627|  3.63k|    }
_ZN4Ogre18MeshSerializerImpl17readMorphKeyFrameERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEPNS_20VertexAnimationTrackE:
 2630|  2.86k|    {
 2631|       |        // float time
 2632|  2.86k|        float timePos;
 2633|  2.86k|        readFloats(stream, &timePos, 1);
 2634|       |        
 2635|       |        // bool includesNormals
 2636|  2.86k|        bool includesNormals;
 2637|  2.86k|        readBools(stream, &includesNormals, 1);
 2638|       |
 2639|  2.86k|        VertexMorphKeyFrame* kf = track->createVertexMorphKeyFrame(timePos);
 2640|       |
 2641|       |        // Create buffer, allow read and use shadow buffer
 2642|  2.86k|        size_t vertexCount = track->getAssociatedVertexData()->vertexCount;
 2643|  2.86k|        size_t vertexSize = sizeof(float) * (includesNormals ? 6 : 3);
  ------------------
  |  Branch (2643:46): [True: 846, False: 2.01k]
  ------------------
 2644|  2.86k|        HardwareVertexBufferSharedPtr vbuf =
 2645|  2.86k|            pMesh->getHardwareBufferManager()->createVertexBuffer(
 2646|  2.86k|                vertexSize, vertexCount,
 2647|  2.86k|                HardwareBuffer::HBU_STATIC, true);
 2648|       |        // float x,y,z          // repeat by number of vertices in original geometry
 2649|  2.86k|        HardwareBufferLockGuard vbufLock(vbuf, HardwareBuffer::HBL_DISCARD);
 2650|  2.86k|        readFloats(stream, static_cast<float*>(vbufLock.pData), vertexCount * (includesNormals ? 6 : 3));
  ------------------
  |  Branch (2650:80): [True: 846, False: 2.01k]
  ------------------
 2651|  2.86k|        kf->setVertexBuffer(vbuf);
 2652|       |
 2653|  2.86k|    }
_ZN4Ogre18MeshSerializerImpl16readPoseKeyFrameERKNS_9SharedPtrINS_10DataStreamEEEPNS_20VertexAnimationTrackE:
 2656|  2.01k|    {
 2657|       |        // float time
 2658|  2.01k|        float timePos;
 2659|  2.01k|        readFloats(stream, &timePos, 1);
 2660|       |
 2661|       |        // Create keyframe
 2662|  2.01k|        VertexPoseKeyFrame* kf = track->createVertexPoseKeyFrame(timePos);
 2663|       |
 2664|  2.01k|        if (!stream->eof())
  ------------------
  |  Branch (2664:13): [True: 1.96k, False: 52]
  ------------------
 2665|  1.96k|        {
 2666|  1.96k|            pushInnerChunk(stream);
 2667|  1.96k|            unsigned short streamID = readChunk(stream);
 2668|  3.53k|            while(!stream->eof() &&
  ------------------
  |  Branch (2668:19): [True: 3.43k, False: 96]
  ------------------
 2669|  3.43k|                streamID == M_ANIMATION_POSE_REF)
  ------------------
  |  Branch (2669:17): [True: 1.56k, False: 1.86k]
  ------------------
 2670|  1.56k|            {
 2671|  1.56k|                switch(streamID)
  ------------------
  |  Branch (2671:24): [True: 1.56k, False: 0]
  ------------------
 2672|  1.56k|                {
 2673|  1.56k|                case M_ANIMATION_POSE_REF:
  ------------------
  |  Branch (2673:17): [True: 1.56k, False: 0]
  ------------------
 2674|  1.56k|                    uint16 poseIndex;
 2675|  1.56k|                    float influence;
 2676|       |                    // unsigned short poseIndex
 2677|  1.56k|                    readShorts(stream, &poseIndex, 1);
 2678|       |                    // float influence
 2679|  1.56k|                    readFloats(stream, &influence, 1);
 2680|       |
 2681|  1.56k|                    kf->addPoseReference(poseIndex, influence);
 2682|       |
 2683|  1.56k|                    break;
 2684|  1.56k|                };
 2685|  1.56k|                if (!stream->eof())
  ------------------
  |  Branch (2685:21): [True: 1.53k, False: 34]
  ------------------
 2686|  1.53k|                {
 2687|  1.53k|                    streamID = readChunk(stream);
 2688|  1.53k|                }
 2689|  1.56k|            }
 2690|  1.96k|            if (!stream->eof())
  ------------------
  |  Branch (2690:17): [True: 1.86k, False: 96]
  ------------------
 2691|  1.86k|            {
 2692|       |                // Backpedal back to start of stream
 2693|  1.86k|                backpedalChunkHeader(stream);
 2694|  1.86k|            }
 2695|  1.96k|            popInnerChunk(stream);
 2696|  1.96k|        }
 2697|  2.01k|    }
_ZN4Ogre18MeshSerializerImpl12readExtremesERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshE:
 2700|  1.78k|    {
 2701|  1.78k|        unsigned short idx;
 2702|  1.78k|        readShorts(stream, &idx, 1);
 2703|       |        
 2704|  1.78k|        SubMesh *sm = pMesh->getSubMeshes().at(idx);
 2705|       |
 2706|  1.78k|        const size_t minChunkSize = MSTREAM_OVERHEAD_SIZE + sizeof(unsigned short);
 2707|  1.78k|        if (mCurrentstreamLen <= minChunkSize)
  ------------------
  |  Branch (2707:13): [True: 0, False: 1.78k]
  ------------------
 2708|  1.78k|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Extremes chunk too small");
 2709|       |
 2710|  1.78k|        size_t n_floats = (mCurrentstreamLen - minChunkSize) / sizeof(float);
 2711|       |
 2712|  1.78k|        if (n_floats == 0 || n_floats % 3 != 0)
  ------------------
  |  Branch (2712:13): [True: 26, False: 1.76k]
  |  Branch (2712:30): [True: 14, False: 1.74k]
  ------------------
 2713|  1.78k|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Invalid extremes data size");
 2714|       |        
 2715|  1.77k|        sm->extremityPoints.resize(n_floats / 3);
 2716|       |
 2717|  1.77k|        readFloats(stream, sm->extremityPoints.front().ptr(), n_floats);
 2718|  1.77k|    }
_ZN4Ogre23MeshSerializerImpl_v1_8C2Ev:
 2732|  5.79k|    {
 2733|       |        // Version number
 2734|  5.79k|        mVersion = "[MeshSerializer_v1.8]";
 2735|       |        // v1.8 and older had broken chunk size bookkeeping (see readMeshLodLevel) and several
 2736|       |        // third party exporters wrote incorrect sizes, too. tolerate them on reading.
 2737|  5.79k|        mReportChunkErrors = false;
 2738|  5.79k|    }
_ZN4Ogre23MeshSerializerImpl_v1_825readMeshLodUsageGeneratedERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEtRNS_12MeshLodUsageE:
 2965|    172|    {
 2966|    172|        usage.manualName = "";
 2967|    172|        usage.manualMesh.reset();
 2968|    172|        pushInnerChunk(stream);
 2969|    172|        {
 2970|       |            // Get one set of detail per SubMesh
 2971|    172|            for (auto *sm : pMesh->getSubMeshes())
  ------------------
  |  Branch (2971:27): [True: 238, False: 89]
  ------------------
 2972|    238|            {
 2973|    238|                unsigned long streamID = readChunk(stream);
 2974|    238|                if (streamID != M_MESH_LOD_GENERATED)
  ------------------
  |  Branch (2974:21): [True: 41, False: 197]
  ------------------
 2975|     41|                {
 2976|     41|                    OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
 2977|     41|                        "Missing M_MESH_LOD_GENERATED stream in " + pMesh->getName(),
 2978|     41|                        "MeshSerializerImpl::readMeshLodUsageGenerated");
 2979|     41|                }
 2980|       |
 2981|    197|                IndexData* indexData = OGRE_NEW IndexData();
 2982|    197|                sm->mLodFaceList[lodNum - 1] = indexData;
 2983|    197|                unsigned int numIndexes;
 2984|    197|                readInts(stream, &numIndexes, 1);
 2985|    197|                bool idx32Bit;
 2986|    197|                readBools(stream, &idx32Bit, 1);
 2987|       |
 2988|    197|                if (!checkChunkRemainingSize(mCurrentstreamLen, numIndexes, idx32Bit ? 4 : 2))
  ------------------
  |  Branch (2988:21): [True: 42, False: 155]
  |  Branch (2988:77): [True: 57, False: 140]
  ------------------
 2989|    197|                    OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "LOD index data exceeds chunk size");
 2990|       |
 2991|    155|                indexData->indexCount = numIndexes;
 2992|       |
 2993|    155|                if (idx32Bit)
  ------------------
  |  Branch (2993:21): [True: 26, False: 129]
  ------------------
 2994|     26|                {
 2995|     26|                    indexData->indexBuffer = pMesh->getHardwareBufferManager()->createIndexBuffer(
 2996|     26|                        HardwareIndexBuffer::IT_32BIT, indexData->indexCount,
 2997|     26|                        pMesh->mIndexBufferUsage, pMesh->mIndexBufferShadowBuffer);
 2998|     26|                    HardwareBufferLockGuard ibufLock(indexData->indexBuffer, HardwareBuffer::HBL_DISCARD);
 2999|     26|                    readInts(stream, static_cast<unsigned int*>(ibufLock.pData), indexData->indexCount);
 3000|     26|                }
 3001|    129|                else
 3002|    129|                {
 3003|    129|                    indexData->indexBuffer = pMesh->getHardwareBufferManager()->createIndexBuffer(
 3004|    129|                        HardwareIndexBuffer::IT_16BIT, indexData->indexCount,
 3005|    129|                        pMesh->mIndexBufferUsage, pMesh->mIndexBufferShadowBuffer);
 3006|    129|                    HardwareBufferLockGuard ibufLock(indexData->indexBuffer, HardwareBuffer::HBL_DISCARD);
 3007|    129|                    readShorts(stream, static_cast<unsigned short*>(ibufLock.pData), indexData->indexCount);
 3008|    129|                }
 3009|    155|            }
 3010|    172|        }
 3011|     89|        popInnerChunk(stream);
 3012|     89|    }
_ZN4Ogre23MeshSerializerImpl_v1_822readMeshLodUsageManualERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEtRNS_12MeshLodUsageE:
 3016|  2.06k|    {
 3017|  2.06k|        pushInnerChunk(stream);
 3018|  2.06k|        unsigned long streamID;
 3019|       |        // Read detail stream
 3020|  2.06k|        streamID = readChunk(stream);
 3021|  2.06k|        if (streamID != M_MESH_LOD_MANUAL)
  ------------------
  |  Branch (3021:13): [True: 32, False: 2.03k]
  ------------------
 3022|     32|        {
 3023|     32|            OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
 3024|     32|                "Missing M_MESH_LOD_MANUAL stream in " + pMesh->getName(),
 3025|     32|                "MeshSerializerImpl::readMeshLodUsageManual");
 3026|     32|        }
 3027|       |
 3028|  2.03k|        usage.manualName = readString(stream);
 3029|  2.03k|        usage.manualMesh.reset(); // will trigger load later
 3030|  2.03k|        popInnerChunk(stream);
 3031|  2.03k|    }
_ZN4Ogre23MeshSerializerImpl_v1_816readMeshLodLevelERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshE:
 3035|  4.17k|    {
 3036|       |#if OGRE_NO_MESHLOD
 3037|       |
 3038|       |        /*
 3039|       |        //Since the chunk sizes in old versions are messed up, we can't use this clean solution.
 3040|       |        // We need to walk through the data to not rely on the chunk size!
 3041|       |        stream->skip(mCurrentstreamLen);
 3042|       |
 3043|       |        // Since we got here, we have already read the chunk header.
 3044|       |        backpedalChunkHeader(stream);
 3045|       |        */
 3046|       |        uint16 numSubs = pMesh->getNumSubMeshes();
 3047|       |        String strategyName = readString(stream);
 3048|       |        uint16 numLods;
 3049|       |        readShorts(stream, &numLods, 1);
 3050|       |        if (!checkLegacyLodCount(stream, numLods))
 3051|       |            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "LOD level count exceeds chunk size");
 3052|       |        bool manual;
 3053|       |        readBools(stream, &manual, 1); // missing in v1_9
 3054|       |        pushInnerChunk(stream);
 3055|       |        for (uint16 i = 1; i < numLods; ++i)
 3056|       |        {
 3057|       |            uint16 streamID = readChunk(stream);
 3058|       |            if (streamID != M_MESH_LOD_USAGE)
 3059|       |            {
 3060|       |                OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
 3061|       |                    "Missing M_MESH_LOD_USAGE stream in " + pMesh->getName(),
 3062|       |                    "MeshSerializerImpl::readMeshLodInfo");
 3063|       |            }
 3064|       |            float usageValue;
 3065|       |            readFloats(stream, &usageValue, 1);
 3066|       |
 3067|       |            if (manual)
 3068|       |            {
 3069|       |                // Read detail stream
 3070|       |                streamID = readChunk(stream);
 3071|       |                if (streamID != M_MESH_LOD_MANUAL)
 3072|       |                {
 3073|       |                    OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
 3074|       |                        "Missing M_MESH_LOD_MANUAL stream in " + pMesh->getName(),
 3075|       |                        "MeshSerializerImpl::readMeshLodUsageManual");
 3076|       |                }
 3077|       |
 3078|       |                String manualName = readString(stream);
 3079|       |            }
 3080|       |            else
 3081|       |            {
 3082|       |                pushInnerChunk(stream);
 3083|       |                for (uint16 n = 0; n < numSubs; ++n)
 3084|       |                {
 3085|       |                    streamID = readChunk(stream);
 3086|       |                    if (streamID != M_MESH_LOD_GENERATED)
 3087|       |                    {
 3088|       |                        OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
 3089|       |                            "Missing M_MESH_LOD_GENERATED stream in " + pMesh->getName(),
 3090|       |                            "MeshSerializerImpl::readMeshLodUsageGenerated");
 3091|       |                    }
 3092|       |
 3093|       |                    unsigned int numIndexes;
 3094|       |                    readInts(stream, &numIndexes, 1);
 3095|       |
 3096|       |                    bool idx32Bit;
 3097|       |                    readBools(stream, &idx32Bit, 1);
 3098|       |
 3099|       |                    size_t buffSize = numIndexes * (idx32Bit ? 4 : 2);
 3100|       |                    stream->skip(buffSize);
 3101|       |                }
 3102|       |                popInnerChunk(stream);
 3103|       |            }
 3104|       |        }
 3105|       |        popInnerChunk(stream);
 3106|       |#else
 3107|  4.17k|        unsigned short streamID, i;
 3108|       |
 3109|       |        // Read the strategy to be used for this mesh
 3110|  4.17k|        String strategyName = readString(stream);
 3111|  4.17k|        LodStrategy *strategy = LodStrategyManager::getSingleton().getStrategy(strategyName);
 3112|       |        
 3113|  4.17k|        if (strategy)
  ------------------
  |  Branch (3113:13): [True: 1.02k, False: 3.14k]
  ------------------
 3114|  1.02k|            pMesh->setLodStrategy(strategy);
 3115|       |
 3116|       |        // unsigned short numLevels;
 3117|  4.17k|        uint16 numLods;
 3118|  4.17k|        readShorts(stream, &numLods, 1);
 3119|  4.17k|        numLods = std::max<ushort>(numLods, 1);
 3120|       |
 3121|  4.17k|        if (!checkLegacyLodCount(stream, numLods))
  ------------------
  |  Branch (3121:13): [True: 59, False: 4.11k]
  ------------------
 3122|  4.17k|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "LOD level count exceeds chunk size");
 3123|       |
 3124|  4.11k|        if(pMesh->getNumLodLevels() > 1)
  ------------------
  |  Branch (3124:12): [True: 3, False: 4.10k]
  ------------------
 3125|  4.11k|            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "LOD levels already exist in mesh");
 3126|       |
 3127|  4.10k|        pMesh->mMeshLodUsageList.resize(numLods);
 3128|       |
 3129|  4.10k|        bool manual; // true for manual alternate meshes, false for generated
 3130|  4.10k|        readBools(stream, &manual, 1);
 3131|  4.10k|        pMesh->mHasManualLodLevel = manual;
 3132|       |
 3133|       |        // Preallocate submesh lod face data if not manual
 3134|  4.10k|        if (!pMesh->hasManualLodLevel())
  ------------------
  |  Branch (3134:13): [True: 2.17k, False: 1.93k]
  ------------------
 3135|  2.17k|        {
 3136|  2.17k|            unsigned short numsubs = pMesh->getNumSubMeshes();
 3137|  50.8k|            for (i = 0; i < numsubs; ++i)
  ------------------
  |  Branch (3137:25): [True: 48.6k, False: 2.17k]
  ------------------
 3138|  48.6k|            {
 3139|  48.6k|                SubMesh* sm = pMesh->getSubMesh(i);
 3140|  48.6k|                assert(sm->mLodFaceList.empty());
 3141|  48.6k|                sm->mLodFaceList.resize(numLods - 1);
 3142|  48.6k|            }
 3143|  2.17k|        }
 3144|       |
 3145|  4.10k|        pushInnerChunk(stream);
 3146|       |        // Loop from 1 rather than 0 (full detail index is not in file)
 3147|  6.35k|        for (i = 1; i < numLods; ++i)
  ------------------
  |  Branch (3147:21): [True: 2.37k, False: 3.98k]
  ------------------
 3148|  2.37k|        {
 3149|  2.37k|            streamID = readChunk(stream);
 3150|  2.37k|            if (streamID != M_MESH_LOD_USAGE)
  ------------------
  |  Branch (3150:17): [True: 124, False: 2.24k]
  ------------------
 3151|    124|            {
 3152|    124|                OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
 3153|    124|                    "Missing M_MESH_LOD_USAGE stream in " + pMesh->getName(),
 3154|    124|                    "MeshSerializerImpl::readMeshLodInfo");
 3155|    124|            }
 3156|       |            // Read depth
 3157|  2.24k|            MeshLodUsage& usage = pMesh->mMeshLodUsageList[i];
 3158|  2.24k|            readFloats(stream, &(usage.userValue), 1);
 3159|       |
 3160|  2.24k|            if (pMesh->hasManualLodLevel())
  ------------------
  |  Branch (3160:17): [True: 2.06k, False: 183]
  ------------------
 3161|  2.06k|            {
 3162|  2.06k|                readMeshLodUsageManual(stream, pMesh, i, usage);
 3163|  2.06k|            }
 3164|    183|            else //(!pMesh->hasManualLodLevel())
 3165|    183|            {
 3166|    183|                readMeshLodUsageGenerated(stream, pMesh, i, usage);
 3167|    183|            }
 3168|  2.24k|            usage.edgeData = NULL;
 3169|  2.24k|        }
 3170|  3.98k|        popInnerChunk(stream);
 3171|  3.98k|#endif
 3172|  3.98k|    }
OgreMeshSerializerImpl.cpp:_ZN4OgreL23checkChunkRemainingSizeEmmm:
   51|   262k|    {
   52|   262k|        if (itemCount == 0)
  ------------------
  |  Branch (52:13): [True: 15.5k, False: 247k]
  ------------------
   53|  15.5k|            return true;
   54|       |
   55|   247k|        if (chunkSize <= MSTREAM_OVERHEAD_SIZE || itemSize == 0)
  ------------------
  |  Branch (55:13): [True: 495, False: 246k]
  |  Branch (55:51): [True: 0, False: 246k]
  ------------------
   56|    495|            return false;
   57|       |
   58|   246k|        size_t remaining = chunkSize - MSTREAM_OVERHEAD_SIZE;
   59|   246k|        return remaining / itemSize >= itemCount;
   60|   247k|    }
OgreMeshSerializerImpl.cpp:_ZN4OgreL19checkLegacyLodCountERKNS_9SharedPtrINS_10DataStreamEEEm:
   65|  4.17k|    {
   66|  4.17k|        if (numLods <= 1)
  ------------------
  |  Branch (66:13): [True: 3.82k, False: 348]
  ------------------
   67|  3.82k|            return true;
   68|    348|        size_t pos = stream->tell(), size = stream->size();
   69|    348|        size_t remaining = pos < size ? size - pos : 0;
  ------------------
  |  Branch (69:28): [True: 320, False: 28]
  ------------------
   70|    348|        return remaining / (MSTREAM_OVERHEAD_SIZE + sizeof(float)) >= numLods - 1;
   71|  4.17k|    }

_ZN4Ogre4NodeC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   35|    756|        :mParent(0),
   36|    756|        mName(name),
   37|    756|        mNeedParentUpdate(false),
   38|    756|        mNeedChildUpdate(false),
   39|    756|        mParentNotified(false),
   40|    756|        mQueuedForUpdate(false),
   41|    756|        mInheritOrientation(true),
   42|    756|        mInheritScale(true),
   43|    756|        mCachedTransformOutOfDate(true),
   44|    756|        mOrientation(Quaternion::IDENTITY),
   45|    756|        mPosition(Vector3::ZERO),
   46|    756|        mScale(Vector3::UNIT_SCALE),
   47|    756|        mDerivedOrientation(Quaternion::IDENTITY),
   48|    756|        mDerivedPosition(Vector3::ZERO),
   49|    756|        mDerivedScale(Vector3::UNIT_SCALE),
   50|    756|        mInitialPosition(Vector3::ZERO),
   51|    756|        mInitialOrientation(Quaternion::IDENTITY),
   52|    756|        mInitialScale(Vector3::UNIT_SCALE),
   53|    756|        mListener(0)
   54|    756|    {
   55|    756|        needUpdate();
   56|    756|    }
_ZN4Ogre4NodeD2Ev:
   60|    756|    {
   61|       |        // Call listener (note, only called if there's something to do)
   62|    756|        if (mListener)
  ------------------
  |  Branch (62:13): [True: 0, False: 756]
  ------------------
   63|      0|        {
   64|      0|            mListener->nodeDestroyed(this);
   65|      0|        }
   66|       |
   67|    756|        removeAllChildren();
   68|    756|        if(mParent)
  ------------------
  |  Branch (68:12): [True: 5, False: 751]
  ------------------
   69|      5|            mParent->removeChild(this);
   70|       |
   71|    756|        if (mQueuedForUpdate)
  ------------------
  |  Branch (71:13): [True: 0, False: 756]
  ------------------
   72|      0|        {
   73|       |            // Erase from queued updates
   74|      0|            QueuedUpdates::iterator it =
   75|      0|                std::find(msQueuedUpdates.begin(), msQueuedUpdates.end(), this);
   76|      0|            assert(it != msQueuedUpdates.end());
   77|      0|            if (it != msQueuedUpdates.end())
  ------------------
  |  Branch (77:17): [True: 0, False: 0]
  ------------------
   78|      0|            {
   79|       |                // Optimised algorithm to erase an element from unordered vector.
   80|      0|                *it = msQueuedUpdates.back();
   81|      0|                msQueuedUpdates.pop_back();
   82|      0|            }
   83|      0|        }
   84|       |
   85|    756|    }
_ZN4Ogre4Node9setParentEPS0_:
   89|     22|    {
   90|     22|        bool different = (parent != mParent);
   91|       |
   92|     22|        mParent = parent;
   93|       |        // Request update from parent
   94|     22|        mParentNotified = false ;
   95|     22|        needUpdate();
   96|       |
   97|       |        // Call listener (note, only called if there's something to do)
   98|     22|        if (mListener && different)
  ------------------
  |  Branch (98:13): [True: 0, False: 22]
  |  Branch (98:26): [True: 0, False: 0]
  ------------------
   99|      0|        {
  100|      0|            if (mParent)
  ------------------
  |  Branch (100:17): [True: 0, False: 0]
  ------------------
  101|      0|                mListener->nodeAttached(this);
  102|      0|            else
  103|      0|                mListener->nodeDetached(this);
  104|      0|        }
  105|       |
  106|     22|    }
_ZNK4Ogre4Node17_updateFromParentEv:
  192|    650|    {
  193|    650|        updateFromParentImpl();
  194|       |
  195|       |        // Call listener (note, this method only called if there's something to do)
  196|    650|        if (mListener)
  ------------------
  |  Branch (196:13): [True: 0, False: 650]
  ------------------
  197|      0|        {
  198|      0|            mListener->nodeUpdated(this);
  199|      0|        }
  200|    650|    }
_ZNK4Ogre4Node20updateFromParentImplEv:
  203|    650|    {
  204|    650|        mCachedTransformOutOfDate = true;
  205|       |
  206|    650|        if (mParent)
  ------------------
  |  Branch (206:13): [True: 2, False: 648]
  ------------------
  207|      2|        {
  208|       |#if OGRE_NODE_INHERIT_TRANSFORM
  209|       |            // Decompose full transform to position, orientation and scale, shear is lost here.
  210|       |            _getFullTransform().decomposition(mDerivedPosition, mDerivedScale, mDerivedOrientation);
  211|       |#else
  212|       |            // Update orientation
  213|      2|            const Quaternion& parentOrientation = mParent->_getDerivedOrientation();
  214|      2|            if (mInheritOrientation)
  ------------------
  |  Branch (214:17): [True: 2, False: 0]
  ------------------
  215|      2|            {
  216|       |                // Combine orientation with that of parent
  217|      2|                mDerivedOrientation = parentOrientation * mOrientation;
  218|      2|            }
  219|      0|            else
  220|      0|            {
  221|       |                // No inheritance
  222|      0|                mDerivedOrientation = mOrientation;
  223|      0|            }
  224|       |
  225|       |            // Update scale
  226|      2|            const Vector3& parentScale = mParent->_getDerivedScale();
  227|      2|            if (mInheritScale)
  ------------------
  |  Branch (227:17): [True: 2, False: 0]
  ------------------
  228|      2|            {
  229|       |                // Scale own position by parent scale, NB just combine
  230|       |                // as equivalent axes, no shearing
  231|      2|                mDerivedScale = parentScale * mScale;
  232|      2|            }
  233|      0|            else
  234|      0|            {
  235|       |                // No inheritance
  236|      0|                mDerivedScale = mScale;
  237|      0|            }
  238|       |
  239|       |            // Change position vector based on parent's orientation & scale
  240|      2|            mDerivedPosition = parentOrientation * (parentScale * mPosition);
  241|       |
  242|       |            // Add altered position vector to parents
  243|      2|            mDerivedPosition += mParent->_getDerivedPosition();
  244|      2|#endif
  245|      2|        }
  246|    648|        else
  247|    648|        {
  248|       |            // Root node, no parent
  249|    648|            mDerivedOrientation = mOrientation;
  250|    648|            mDerivedPosition = mPosition;
  251|    648|            mDerivedScale = mScale;
  252|    648|        }
  253|       |
  254|    650|        mNeedParentUpdate = false;
  255|       |
  256|    650|    }
_ZN4Ogre4Node8addChildEPS0_:
  280|     14|    {
  281|     14|        if (child->mParent)
  ------------------
  |  Branch (281:13): [True: 3, False: 11]
  ------------------
  282|      3|        {
  283|      3|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
  284|      3|                        "Node '" + child->getName() + "' already is a child of '" + child->mParent->getName() + "'");
  285|      3|        }
  286|       |
  287|     11|        mChildren.push_back(child);
  288|     11|        child->setParent(this);
  289|       |
  290|     11|    }
_ZN4Ogre4Node11removeChildEPS0_:
  320|      5|    {
  321|      5|        if (child)
  ------------------
  |  Branch (321:13): [True: 5, False: 0]
  ------------------
  322|      5|        {
  323|      5|            ChildNodeMap::iterator i = std::find(mChildren.begin(), mChildren.end(), child);
  324|      5|            if(i != mChildren.end() && *i == child)
  ------------------
  |  Branch (324:16): [True: 5, False: 0]
  |  Branch (324:16): [True: 5, False: 0]
  |  Branch (324:40): [True: 5, False: 0]
  ------------------
  325|      5|            {
  326|       |                // cancel any pending update
  327|      5|                cancelUpdate(child);
  328|       |
  329|      5|                std::swap(*i, mChildren.back());
  330|      5|                mChildren.pop_back();
  331|       |                child->setParent(NULL);
  332|      5|            }
  333|      5|        }
  334|      5|        return child;
  335|      5|    }
_ZN4Ogre4Node14setOrientationERKNS_10QuaternionE:
  339|    756|    {
  340|    756|#ifndef OGRE_FAST_MATH
  341|    756|        OgreAssertDbg(!q.isNaN(), "Invalid orientation supplied as parameter");
  342|    756|#endif
  343|    756|        mOrientation = q;
  344|    756|        mOrientation.normalise();
  345|    756|        needUpdate();
  346|    756|    }
_ZN4Ogre4Node11setPositionERKNS_6VectorILi3EfEE:
  361|    756|    {
  362|    756|#ifndef OGRE_FAST_MATH
  363|       |        assert(!pos.isNaN() && "Invalid vector supplied as parameter");
  364|    756|#endif
  365|    756|        mPosition = pos;
  366|    756|        needUpdate();
  367|    756|    }
_ZNK4Ogre4Node22_getDerivedOrientationEv:
  452|    652|    {
  453|    652|        if (mNeedParentUpdate)
  ------------------
  |  Branch (453:13): [True: 1, False: 651]
  ------------------
  454|      1|        {
  455|      1|            _updateFromParent();
  456|      1|        }
  457|    652|        return mDerivedOrientation;
  458|    652|    }
_ZNK4Ogre4Node19_getDerivedPositionEv:
  461|    652|    {
  462|    652|        if (mNeedParentUpdate)
  ------------------
  |  Branch (462:13): [True: 649, False: 3]
  ------------------
  463|    649|        {
  464|    649|            _updateFromParent();
  465|    649|        }
  466|    652|        return mDerivedPosition;
  467|    652|    }
_ZNK4Ogre4Node16_getDerivedScaleEv:
  470|    652|    {
  471|    652|        if (mNeedParentUpdate)
  ------------------
  |  Branch (471:13): [True: 0, False: 652]
  ------------------
  472|      0|        {
  473|      0|            _updateFromParent();
  474|      0|        }
  475|    652|        return mDerivedScale;
  476|    652|    }
_ZN4Ogre4Node17removeAllChildrenEv:
  546|    756|    {
  547|    756|        for (auto *c : mChildren)
  ------------------
  |  Branch (547:22): [True: 6, False: 756]
  ------------------
  548|      6|        {
  549|      6|            c->setParent(0);
  550|      6|        }
  551|    756|        mChildren.clear();
  552|    756|        mChildrenToUpdate.clear();
  553|    756|    }
_ZN4Ogre4Node8setScaleERKNS_6VectorILi3EfEE:
  563|     23|    {
  564|     23|#ifndef OGRE_FAST_MATH
  565|       |        assert(!inScale.isNaN() && "Invalid vector supplied as parameter");
  566|     23|#endif
  567|     23|        mScale = inScale;
  568|     23|        needUpdate();
  569|     23|    }
_ZN4Ogre4Node15setInitialStateEv:
  600|    650|    {
  601|    650|        mInitialPosition = mPosition;
  602|    650|        mInitialOrientation = mOrientation;
  603|    650|        mInitialScale = mScale;
  604|    650|    }
_ZN4Ogre4Node10needUpdateEb:
  680|  2.31k|    {
  681|       |
  682|  2.31k|        mNeedParentUpdate = true;
  683|  2.31k|        mNeedChildUpdate = true;
  684|  2.31k|        mCachedTransformOutOfDate = true;
  685|       |
  686|       |        // Make sure we're not root and parent hasn't been notified before
  687|  2.31k|        if (mParent && (!mParentNotified || forceParentUpdate))
  ------------------
  |  Branch (687:13): [True: 11, False: 2.30k]
  |  Branch (687:25): [True: 11, False: 0]
  |  Branch (687:45): [True: 0, False: 0]
  ------------------
  688|     11|        {
  689|     11|            mParent->requestUpdate(this, forceParentUpdate);
  690|     11|            mParentNotified = true ;
  691|     11|        }
  692|       |
  693|       |        // all children will be updated
  694|  2.31k|        mChildrenToUpdate.clear();
  695|  2.31k|    }
_ZN4Ogre4Node13requestUpdateEPS0_b:
  698|     11|    {
  699|       |        // If we're already going to update everything this doesn't matter
  700|     11|        if (mNeedChildUpdate)
  ------------------
  |  Branch (700:13): [True: 11, False: 0]
  ------------------
  701|     11|        {
  702|     11|            return;
  703|     11|        }
  704|       |
  705|      0|        mChildrenToUpdate.push_back(child);
  706|       |        // Request selective update of me, if we didn't do it before
  707|      0|        if (mParent && (!mParentNotified || forceParentUpdate))
  ------------------
  |  Branch (707:13): [True: 0, False: 0]
  |  Branch (707:25): [True: 0, False: 0]
  |  Branch (707:45): [True: 0, False: 0]
  ------------------
  708|      0|        {
  709|      0|            mParent->requestUpdate(this, forceParentUpdate);
  710|      0|            mParentNotified = true ;
  711|      0|        }
  712|       |
  713|      0|    }
_ZN4Ogre4Node12cancelUpdateEPS0_:
  716|      5|    {
  717|      5|        mChildrenToUpdate.erase(std::remove(mChildrenToUpdate.begin(), mChildrenToUpdate.end(), child),
  718|      5|                                mChildrenToUpdate.end());
  719|       |
  720|       |        // Propagate this up if we're done
  721|      5|        if (mChildrenToUpdate.empty() && mParent && !mNeedChildUpdate)
  ------------------
  |  Branch (721:13): [True: 5, False: 0]
  |  Branch (721:42): [True: 0, False: 5]
  |  Branch (721:53): [True: 0, False: 0]
  ------------------
  722|      0|        {
  723|      0|            mParent->cancelUpdate(this);
  724|      0|            mParentNotified = false ;
  725|      0|        }
  726|      5|    }

_ZN4Ogre13OptimisedUtil21_detectImplementationEv:
  326|      2|    {
  327|       |        //
  328|       |        // Some speed test results (averaged number of CPU timestamp (RDTSC) per-function call):
  329|       |        //
  330|       |        //   Dagon SkeletonAnimation sample - softwareVertexSkinning:
  331|       |        //
  332|       |        //                                      Pentium 4 3.0G HT       Athlon XP 2500+     Athlon 64 X2 Dual Core 3800+
  333|       |        //
  334|       |        //      Shared Buffers, General C       763677                  462903              473038
  335|       |        //      Shared Buffers, Unrolled SSE    210030 *best*           369762              228328 *best*
  336|       |        //      Shared Buffers, General SSE     286202                  352412 *best*       302796
  337|       |        //
  338|       |        //      Separated Buffers, General C    762640                  464840              478740
  339|       |        //      Separated Buffers, Unrolled SSE 219222 *best*           287992 *best*       238770 *best*
  340|       |        //      Separated Buffers, General SSE  290129                  341614              307262
  341|       |        //
  342|       |        //      PosOnly, General C              388663                  257350              262831
  343|       |        //      PosOnly, Unrolled SSE           139814 *best*           200323 *best*       168995 *best*
  344|       |        //      PosOnly, General SSE            172693                  213704              175447
  345|       |        //
  346|       |        //   Another my own test scene - softwareVertexSkinning:
  347|       |        //
  348|       |        //                                      Pentium P4 3.0G HT      Athlon XP 2500+
  349|       |        //
  350|       |        //      Shared Buffers, General C       74527                   -
  351|       |        //      Shared Buffers, Unrolled SSE    22743 *best*            -
  352|       |        //      Shared Buffers, General SSE     28527                   -
  353|       |        //
  354|       |        //
  355|       |        // Note that speed test appears unaligned load/store instruction version
  356|       |        // loss performance 5%-10% than aligned load/store version, even if both
  357|       |        // of them access to aligned data. Thus, we should use aligned load/store
  358|       |        // as soon as possible.
  359|       |        //
  360|       |        //
  361|       |        // We are pick up the implementation based on test results above.
  362|       |        //
  363|       |#ifdef __DO_PROFILE__
  364|       |        {
  365|       |            static OptimisedUtilProfiler msOptimisedUtilProfiler;
  366|       |            return &msOptimisedUtilProfiler;
  367|       |        }
  368|       |
  369|       |#else   // !__DO_PROFILE__
  370|       |
  371|      2|#if __OGRE_HAVE_SSE
  372|      2|        if (PlatformInformation::getCpuFeatures() & PlatformInformation::CPU_FEATURE_SSE)
  ------------------
  |  Branch (372:13): [True: 2, False: 0]
  ------------------
  373|      2|        {
  374|      2|            return _getOptimisedUtilSSE();
  375|      2|        }
  376|      0|        else
  377|       |#elif __OGRE_HAVE_NEON
  378|       |        if (PlatformInformation::getCpuFeatures() & PlatformInformation::CPU_FEATURE_NEON)
  379|       |        {
  380|       |            return _getOptimisedUtilSSE();
  381|       |        }
  382|       |        else
  383|       |#endif  // __OGRE_HAVE_SSE
  384|      0|        {
  385|      0|            return _getOptimisedUtilGeneral();
  386|      0|        }
  387|       |
  388|      2|#endif  // __DO_PROFILE__
  389|      2|    }

_ZN4Ogre16OptimisedUtilSSEC2Ev:
  900|      2|        : mPreferGeneralVersionForSharedBuffers(false)
  901|      2|    {
  902|       |        // For AMD Athlon XP (but not that for Althon 64), it's prefer to never use
  903|       |        // unrolled version for shared buffers at all, I guess because that version
  904|       |        // run out of usable CPU registers, or L1/L2 cache related problem, causing
  905|       |        // slight performance loss than general version.
  906|       |        //
  907|      2|#if __OGRE_HAVE_NEON == 0
  908|      2|        if (PlatformInformation::getCpuIdentifier().find("AuthenticAMD") != String::npos)
  ------------------
  |  Branch (908:13): [True: 0, False: 2]
  ------------------
  909|      0|        {
  910|       |            // How can I check it's an Athlon XP but not Althon 64?
  911|       |            // Ok, just test whether supports SSE2/SSE3 or not, if not,
  912|       |            // assume general version faster than unrolled version :)
  913|       |            //
  914|      0|            if (!(PlatformInformation::getCpuFeatures() &
  ------------------
  |  Branch (914:17): [True: 0, False: 0]
  ------------------
  915|      0|                (PlatformInformation::CPU_FEATURE_SSE2 | PlatformInformation::CPU_FEATURE_SSE3)))
  916|      0|            {
  917|      0|                mPreferGeneralVersionForSharedBuffers = true;
  918|      0|            }
  919|      0|        }
  920|      2|#endif
  921|      2|    }
_ZN4Ogre20_getOptimisedUtilSSEEv:
 1993|      2|    {
 1994|      2|        static OptimisedUtilSSE msOptimisedUtilSSE;
 1995|      2|        return &msOptimisedUtilSSE;
 1996|      2|    }

_ZN4Ogre4PassC2EPNS_9TechniqueEt:
  122|      1|        : mParent(parent)
  123|      1|        , mHash(0)
  124|      1|        , mAmbient(ColourValue::White)
  125|      1|        , mDiffuse(ColourValue::White)
  126|      1|        , mSpecular(ColourValue::Black)
  127|      1|        , mEmissive(ColourValue::Black)
  128|      1|        , mShininess(0)
  129|      1|        , mTracking(TVC_NONE)
  130|      1|        , mHashDirtyQueued(false)
  131|      1|        , mDepthCheck(true)
  132|      1|        , mDepthWrite(true)
  133|      1|        , mAlphaToCoverageEnabled(false)
  134|      1|        , mTransparentSorting(true)
  135|      1|        , mTransparentSortingForced(false)
  136|      1|        , mLightingEnabled(true)
  137|      1|        , mIteratePerLight(false)
  138|      1|        , mRunOnlyForOneLightType(false)
  139|      1|        , mPolygonModeOverrideable(true)
  140|      1|        , mFogOverride(false)
  141|      1|        , mQueuedForDeletion(false)
  142|      1|        , mLightScissoring(false)
  143|      1|        , mLightClipPlanes(false)
  144|      1|        , mPointSpritesEnabled(false)
  145|      1|        , mPointAttenuationEnabled(false)
  146|      1|        , mContentTypeLookupBuilt(false)
  147|      1|        , mAlphaRejectVal(0)
  148|      1|        , mDepthBiasConstant(0.0f)
  149|      1|        , mDepthBiasSlopeScale(0.0f)
  150|      1|        , mDepthBiasPerIteration(0.0f)
  151|      1|        , mDepthFunc(CMPF_LESS_EQUAL)
  152|      1|        , mAlphaRejectFunc(CMPF_ALWAYS_PASS)
  153|      1|        , mCullMode(CULL_CLOCKWISE)
  154|      1|        , mManualCullMode(MANUAL_CULL_BACK)
  155|      1|        , mMaxSimultaneousLights(OGRE_MAX_SIMULTANEOUS_LIGHTS)
  156|      1|        , mStartLight(0)
  157|      1|        , mLightsPerIteration(1)
  158|      1|        , mIndex(index)
  159|      1|        , mLightMask(0xFFFFFFFF)
  160|      1|        , mFogColour(ColourValue::White)
  161|      1|        , mFogStart(0.0)
  162|      1|        , mFogEnd(1.0)
  163|      1|        , mFogDensity(0.001)
  164|      1|        , mLineWidth(1.0f)
  165|      1|        , mPassIterationCount(1)
  166|      1|        , mPointMinSize(0.0f)
  167|      1|        , mPointMaxSize(0.0f)
  168|      1|        , mPointAttenution(1.0f, 1.0f, 0.0f, 0.0f)
  169|      1|        , mShadeOptions(SO_GOURAUD)
  170|      1|        , mPolygonMode(PM_SOLID)
  171|      1|        , mIlluminationStage(IS_UNKNOWN)
  172|      1|        , mOnlyLightType(Light::LT_POINT)
  173|      1|        , mFogMode(FOG_NONE)
  174|      1|    {
  175|       |        // init the hash inline
  176|      1|        _recalculateHash();
  177|      1|   }
_ZN4Ogre4PassC2EPNS_9TechniqueEtRKS0_:
  181|      2|        : mParent(parent), mQueuedForDeletion(false), mIndex(index), mPassIterationCount(1)
  182|      2|    {
  183|      2|        *this = oth;
  184|      2|        mParent = parent;
  185|      2|        mIndex = index;
  186|      2|        mQueuedForDeletion = false;
  187|       |
  188|       |        // init the hash inline
  189|      2|        _recalculateHash();
  190|      2|    }
_ZN4Ogre4PassaSERKS0_:
  194|      2|    {
  195|      2|        mName = oth.mName;
  196|      2|        mHash = oth.mHash;
  197|      2|        mAmbient = oth.mAmbient;
  198|      2|        mDiffuse = oth.mDiffuse;
  199|      2|        mSpecular = oth.mSpecular;
  200|      2|        mEmissive = oth.mEmissive;
  201|      2|        mShininess = oth.mShininess;
  202|      2|        mTracking = oth.mTracking;
  203|       |
  204|       |        // Copy fog parameters
  205|      2|        mFogOverride = oth.mFogOverride;
  206|      2|        mFogMode = oth.mFogMode;
  207|      2|        mFogColour = oth.mFogColour;
  208|      2|        mFogStart = oth.mFogStart;
  209|      2|        mFogEnd = oth.mFogEnd;
  210|      2|        mFogDensity = oth.mFogDensity;
  211|       |
  212|       |        // Default blending (overwrite)
  213|      2|        mBlendState = oth.mBlendState;
  214|       |
  215|      2|        mDepthCheck = oth.mDepthCheck;
  216|      2|        mDepthWrite = oth.mDepthWrite;
  217|      2|        mAlphaRejectFunc = oth.mAlphaRejectFunc;
  218|      2|        mAlphaRejectVal = oth.mAlphaRejectVal;
  219|      2|        mAlphaToCoverageEnabled = oth.mAlphaToCoverageEnabled;
  220|      2|        mTransparentSorting = oth.mTransparentSorting;
  221|      2|        mTransparentSortingForced = oth.mTransparentSortingForced;
  222|      2|        mDepthFunc = oth.mDepthFunc;
  223|      2|        mDepthBiasConstant = oth.mDepthBiasConstant;
  224|      2|        mDepthBiasSlopeScale = oth.mDepthBiasSlopeScale;
  225|      2|        mDepthBiasPerIteration = oth.mDepthBiasPerIteration;
  226|      2|        mCullMode = oth.mCullMode;
  227|      2|        mManualCullMode = oth.mManualCullMode;
  228|      2|        mLightingEnabled = oth.mLightingEnabled;
  229|      2|        mMaxSimultaneousLights = oth.mMaxSimultaneousLights;
  230|      2|        mStartLight = oth.mStartLight;
  231|      2|        mIteratePerLight = oth.mIteratePerLight;
  232|      2|        mLightsPerIteration = oth.mLightsPerIteration;
  233|      2|        mRunOnlyForOneLightType = oth.mRunOnlyForOneLightType;
  234|      2|        mOnlyLightType = oth.mOnlyLightType;
  235|      2|        mShadeOptions = oth.mShadeOptions;
  236|      2|        mPolygonMode = oth.mPolygonMode;
  237|      2|        mPolygonModeOverrideable = oth.mPolygonModeOverrideable;
  238|      2|        mPassIterationCount = oth.mPassIterationCount;
  239|      2|        mLineWidth = oth.mLineWidth;
  240|      2|        mPointAttenution = oth.mPointAttenution;
  241|      2|        mPointMinSize = oth.mPointMinSize;
  242|      2|        mPointMaxSize = oth.mPointMaxSize;
  243|      2|        mPointSpritesEnabled = oth.mPointSpritesEnabled;
  244|      2|        mPointAttenuationEnabled = oth.mPointAttenuationEnabled;
  245|      2|        mShadowContentTypeLookup = oth.mShadowContentTypeLookup;
  246|      2|        mContentTypeLookupBuilt = oth.mContentTypeLookupBuilt;
  247|      2|        mLightScissoring = oth.mLightScissoring;
  248|      2|        mLightClipPlanes = oth.mLightClipPlanes;
  249|      2|        mIlluminationStage = oth.mIlluminationStage;
  250|      2|        mLightMask = oth.mLightMask;
  251|       |
  252|     12|        for(int i = 0; i < GPT_PIPELINE_COUNT; i++)
  ------------------
  |  Branch (252:24): [True: 10, False: 2]
  ------------------
  253|     10|        {
  254|     10|            auto& programUsage = mProgramUsage[i];
  255|     10|            auto& othUsage = oth.mProgramUsage[i];
  256|     10|            programUsage = othUsage ? std::make_unique<GpuProgramUsage>(*othUsage, this) : nullptr;
  ------------------
  |  Branch (256:28): [True: 0, False: 10]
  ------------------
  257|     10|        }
  258|       |
  259|       |        // Clear texture units but doesn't notify need recompilation in the case
  260|       |        // we are cloning, The parent material will take care of this.
  261|      2|        for (auto *t : mTextureUnitStates)
  ------------------
  |  Branch (261:22): [True: 0, False: 2]
  ------------------
  262|      0|        {
  263|      0|            OGRE_DELETE t;
  264|      0|        }
  265|       |
  266|      2|        mTextureUnitStates.clear();
  267|       |
  268|       |        // Copy texture units
  269|      2|        for (auto *s : oth.mTextureUnitStates)
  ------------------
  |  Branch (269:22): [True: 0, False: 2]
  ------------------
  270|      0|        {
  271|      0|            TextureUnitState* t = OGRE_NEW TextureUnitState(this, *s);
  272|      0|            mTextureUnitStates.push_back(t);
  273|      0|        }
  274|       |
  275|      2|        _dirtyHash();
  276|       |
  277|      2|        return *this;
  278|      2|    }
_ZNK4Ogre4Pass15getProgramUsageENS_14GpuProgramTypeE:
  825|     24|    {
  826|     24|        static std::unique_ptr<GpuProgramUsage> nullUsage;
  827|     24|        auto& ret = mProgramUsage[programType % GPT_PIPELINE_COUNT];
  828|     24|        return ret && ret->getType() == programType ? ret : nullUsage;
  ------------------
  |  Branch (828:16): [True: 0, False: 24]
  |  Branch (828:23): [True: 0, False: 0]
  ------------------
  829|     24|    }
_ZNK4Ogre4Pass17getGpuProgramNameENS_14GpuProgramTypeE:
  843|     24|    {
  844|     24|        OGRE_LOCK_MUTEX(mGpuProgramChangeMutex);
  845|       |
  846|     24|        const std::unique_ptr<GpuProgramUsage>& programUsage = getProgramUsage(type);
  847|     24|        if (!programUsage)
  ------------------
  |  Branch (847:13): [True: 24, False: 0]
  ------------------
  848|     24|            return BLANKSTRING;
  849|      0|        else
  850|      0|            return programUsage->getProgramName();
  851|     24|    }
_ZN4Ogre4Pass16_recalculateHashEv:
  859|      3|    {
  860|       |        /* Hash format is 32-bit, divided as follows (high to low bits)
  861|       |           bits   purpose
  862|       |            4     Pass index (i.e. max 16 passes!)
  863|       |           28     Pass contents
  864|       |       */
  865|      3|        mHash = (*msHashFunc)(this);
  866|       |
  867|       |        // overwrite the 4 upper bits with pass index
  868|      3|        mHash = (uint32(mIndex) << 28) | (mHash >> 4);
  869|      3|    }
_ZN4Ogre4Pass10_dirtyHashEv:
  872|      2|    {
  873|      2|        if (mQueuedForDeletion)
  ------------------
  |  Branch (873:13): [True: 0, False: 2]
  ------------------
  874|      0|            return;
  875|       |
  876|      2|        Material* mat = mParent->getParent();
  877|      2|        if (mat->isLoading() || mat->isLoaded())
  ------------------
  |  Branch (877:13): [True: 0, False: 2]
  |  Branch (877:33): [True: 0, False: 2]
  ------------------
  878|      0|        {
  879|      0|            OGRE_LOCK_MUTEX(msDirtyHashListMutex);
  880|       |            // Mark this hash as for follow up
  881|      0|            msDirtyHashList.insert(this);
  882|      0|            mHashDirtyQueued = false;
  883|      0|        }
  884|      2|        else
  885|      2|        {
  886|      2|            mHashDirtyQueued = true;
  887|      2|        }
  888|      2|    }
_ZNK4Ogre27MinGpuProgramChangeHashFuncclEPKNS_4PassE:
   67|      3|        {
   68|      3|            OGRE_LOCK_MUTEX(p->mGpuProgramChangeMutex);
   69|      3|            uint32 hash = 0;
   70|       |
   71|     27|            for(int i = 0; i < GPT_COUNT; i++)
  ------------------
  |  Branch (71:28): [True: 24, False: 3]
  ------------------
   72|     24|            {
   73|     24|                const String& name = p->getGpuProgramName(GpuProgramType(i));
   74|     24|                if(!name.empty()) {
  ------------------
  |  Branch (74:20): [True: 0, False: 24]
  ------------------
   75|      0|                    hash = FastHash(name.c_str(), name.size(), hash);
   76|      0|                }
   77|     24|            }
   78|       |
   79|      3|            return hash;
   80|      3|        }

_ZN4Ogre25PixelCountLodStrategyBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   37|      2|        : LodStrategy(name)
   38|      2|    { }
_ZNK4Ogre25PixelCountLodStrategyBase12getBaseValueEv:
   41|    514|    {
   42|       |        // Use the maximum possible value as base
   43|    514|        return std::numeric_limits<Real>::max();
   44|    514|    }
_ZN4Ogre29AbsolutePixelCountLodStrategyC2Ev:
   92|      1|        : PixelCountLodStrategyBase("pixel_count")
   93|      1|    { }
_ZN4Ogre32ScreenRatioPixelCountLodStrategyC2Ev:
  172|      1|        : PixelCountLodStrategyBase("screen_ratio_pixel_count")
  173|      1|    { }

_ZN4Ogre19PlatformInformation16getCpuIdentifierEv:
  655|      2|    {
  656|      2|        static const String sIdentifier = _detectCpuIdentifier();
  657|      2|        return sIdentifier;
  658|      2|    }
_ZN4Ogre19PlatformInformation14getCpuFeaturesEv:
  661|      2|    {
  662|      2|        static const uint sFeatures = _detectCpuFeatures();
  663|      2|        return sFeatures;
  664|      2|    }
OgrePlatformInformation.cpp:_ZN4OgreL20_detectCpuIdentifierEv:
  427|      2|    {
  428|       |        // Supports CPUID instruction ?
  429|      2|        if (_isSupportCpuid())
  ------------------
  |  Branch (429:13): [True: 2, False: 0]
  ------------------
  430|      2|        {
  431|      2|            CpuidResult result;
  432|      2|            uint nExIds;
  433|      2|            char CPUString[0x20];
  434|      2|            char CPUBrandString[0x40];
  435|       |
  436|      2|            StringStream detailedIdentStr;
  437|       |
  438|       |
  439|       |            // Has standard feature ?
  440|      2|            if (_performCpuid(0, result))
  ------------------
  |  Branch (440:17): [True: 2, False: 0]
  ------------------
  441|      2|            {
  442|      2|                memset(CPUString, 0, sizeof(CPUString));
  443|      2|                memset(CPUBrandString, 0, sizeof(CPUBrandString));
  444|       |
  445|       |                //*((int*)CPUString) = result._ebx;
  446|       |                //*((int*)(CPUString+4)) = result._edx;
  447|       |                //*((int*)(CPUString+8)) = result._ecx;
  448|      2|                memcpy(CPUString, &result._ebx, sizeof(int));
  449|      2|                memcpy(CPUString+4, &result._edx, sizeof(int));
  450|      2|                memcpy(CPUString+8, &result._ecx, sizeof(int));
  451|       |
  452|      2|                detailedIdentStr << CPUString;
  453|       |
  454|       |                // Calling _performCpuid with 0x80000000 as the query argument
  455|       |                // gets the number of valid extended IDs.
  456|      2|                nExIds = _performCpuid(0x80000000, result);
  457|       |
  458|     20|                for (uint i=0x80000000; i<=nExIds; ++i)
  ------------------
  |  Branch (458:41): [True: 18, False: 2]
  ------------------
  459|     18|                {
  460|     18|                    _performCpuid(i, result);
  461|       |
  462|       |                    // Interpret CPU brand string and cache information.
  463|     18|                    if  (i == 0x80000002)
  ------------------
  |  Branch (463:26): [True: 2, False: 16]
  ------------------
  464|      2|                    {
  465|      2|                        memcpy(CPUBrandString + 0, &result._eax, sizeof(result._eax));
  466|      2|                        memcpy(CPUBrandString + 4, &result._ebx, sizeof(result._ebx));
  467|      2|                        memcpy(CPUBrandString + 8, &result._ecx, sizeof(result._ecx));
  468|      2|                        memcpy(CPUBrandString + 12, &result._edx, sizeof(result._edx));
  469|      2|                    }
  470|     16|                    else if  (i == 0x80000003)
  ------------------
  |  Branch (470:31): [True: 2, False: 14]
  ------------------
  471|      2|                    {
  472|      2|                        memcpy(CPUBrandString + 16 + 0, &result._eax, sizeof(result._eax));
  473|      2|                        memcpy(CPUBrandString + 16 + 4, &result._ebx, sizeof(result._ebx));
  474|      2|                        memcpy(CPUBrandString + 16 + 8, &result._ecx, sizeof(result._ecx));
  475|      2|                        memcpy(CPUBrandString + 16 + 12, &result._edx, sizeof(result._edx));
  476|      2|                    }
  477|     14|                    else if  (i == 0x80000004)
  ------------------
  |  Branch (477:31): [True: 2, False: 12]
  ------------------
  478|      2|                    {
  479|      2|                        memcpy(CPUBrandString + 32 + 0, &result._eax, sizeof(result._eax));
  480|      2|                        memcpy(CPUBrandString + 32 + 4, &result._ebx, sizeof(result._ebx));
  481|      2|                        memcpy(CPUBrandString + 32 + 8, &result._ecx, sizeof(result._ecx));
  482|      2|                        memcpy(CPUBrandString + 32 + 12, &result._edx, sizeof(result._edx));
  483|      2|                    }
  484|     18|                }
  485|       |
  486|      2|                String brand(CPUBrandString);
  487|      2|                StringUtil::trim(brand);
  488|      2|                if (!brand.empty())
  ------------------
  |  Branch (488:21): [True: 2, False: 0]
  ------------------
  489|      2|                    detailedIdentStr << ": " << brand;
  490|       |
  491|      2|                return detailedIdentStr.str();
  492|      2|            }
  493|      2|        }
  494|       |
  495|      0|        return "X86";
  496|      2|    }
OgrePlatformInformation.cpp:_ZN4OgreL13_performCpuidEiRNS_11CpuidResultE:
  151|     30|    {
  152|       |#if OGRE_COMPILER == OGRE_COMPILER_MSVC
  153|       |        int CPUInfo[4];
  154|       |        __cpuid(CPUInfo, query);
  155|       |        result._eax = CPUInfo[0];
  156|       |        result._ebx = CPUInfo[1];
  157|       |        result._ecx = CPUInfo[2];
  158|       |        result._edx = CPUInfo[3];
  159|       |        return result._eax;
  160|       |#elif (OGRE_COMPILER == OGRE_COMPILER_GNUC || OGRE_COMPILER == OGRE_COMPILER_CLANG) && OGRE_PLATFORM != OGRE_PLATFORM_EMSCRIPTEN
  161|       |        #if OGRE_ARCH_TYPE == OGRE_ARCHITECTURE_64
  162|     30|        __asm__
  163|     30|        (
  164|     30|            "cpuid": "=a" (result._eax), "=b" (result._ebx), "=c" (result._ecx), "=d" (result._edx) : "a" (query)
  165|     30|        );
  166|       |        #else
  167|       |        __asm__
  168|       |        (
  169|       |            "pushl  %%ebx           \n\t"
  170|       |            "cpuid                  \n\t"
  171|       |            "movl   %%ebx, %%edi    \n\t"
  172|       |            "popl   %%ebx           \n\t"
  173|       |            : "=a" (result._eax), "=D" (result._ebx), "=c" (result._ecx), "=d" (result._edx)
  174|       |            : "a" (query)
  175|       |        );
  176|       |       #endif // OGRE_ARCHITECTURE_64
  177|     30|        return result._eax;
  178|       |
  179|       |#else
  180|       |        // TODO: Supports other compiler
  181|       |        return 0;
  182|       |#endif
  183|     30|    }
OgrePlatformInformation.cpp:_ZN4OgreL18_detectCpuFeaturesEv:
  408|      2|    {
  409|      2|        uint features = queryCpuFeatures();
  410|       |
  411|      2|        const uint sse_features = 0
  412|      2|            | PlatformInformation::CPU_FEATURE_SSE
  413|      2|            | PlatformInformation::CPU_FEATURE_SSE2
  414|      2|            | PlatformInformation::CPU_FEATURE_SSE3
  415|      2|            | PlatformInformation::CPU_FEATURE_SSE41
  416|      2|            | PlatformInformation::CPU_FEATURE_SSE42;
  417|       |
  418|      2|        if ((features & sse_features) && !_checkOperatingSystemSupportSSE())
  ------------------
  |  Branch (418:13): [True: 2, False: 0]
  |  Branch (418:42): [True: 0, False: 2]
  ------------------
  419|      0|        {
  420|      0|            features &= ~sse_features;
  421|      0|        }
  422|       |
  423|      2|        return features;
  424|      2|    }
OgrePlatformInformation.cpp:_ZN4OgreL16queryCpuFeaturesEv:
  266|      2|    {
  267|       |
  268|      2|#define CPUID_FUNC_VENDOR_ID                 0x0
  269|      2|#define CPUID_FUNC_STANDARD_FEATURES         0x1
  270|      2|#define CPUID_FUNC_EXTENSION_QUERY           0x80000000
  271|      2|#define CPUID_FUNC_EXTENDED_FEATURES         0x80000001
  272|      2|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007
  273|       |
  274|      2|#define CPUID_STD_FPU               (1<<0)
  275|      2|#define CPUID_STD_TSC               (1<<4)
  276|      2|#define CPUID_STD_CMOV              (1<<15)
  277|      2|#define CPUID_STD_MMX               (1<<23)
  278|      2|#define CPUID_STD_SSE               (1<<25)
  279|      2|#define CPUID_STD_SSE2              (1<<26)
  280|      2|#define CPUID_STD_HTT               (1<<28)     // EDX[28] - Bit 28 set indicates  Hyper-Threading Technology is supported in hardware.
  281|       |
  282|      2|#define CPUID_STD_SSE3              (1<<0)      // ECX[0]  - Bit 0 of standard function 1 indicate SSE3 supported
  283|      2|#define CPUID_STD_SSE41             (1<<19)     // ECX[19] - Bit 0 of standard function 1 indicate SSE41 supported
  284|      2|#define CPUID_STD_SSE42             (1<<20)     // ECX[20] - Bit 0 of standard function 1 indicate SSE42 supported
  285|       |
  286|      2|#define CPUID_FAMILY_ID_MASK        0x0F00      // EAX[11:8] - Bit 11 thru 8 contains family  processor id
  287|      2|#define CPUID_EXT_FAMILY_ID_MASK    0x0F00000   // EAX[23:20] - Bit 23 thru 20 contains extended family processor id
  288|      2|#define CPUID_PENTIUM4_ID           0x0F00      // Pentium 4 family processor id
  289|       |
  290|      2|#define CPUID_EXT_3DNOW             (1<<31)
  291|      2|#define CPUID_EXT_AMD_3DNOWEXT      (1<<30)
  292|      2|#define CPUID_EXT_AMD_MMXEXT        (1<<22)
  293|       |
  294|       |
  295|      2|#define CPUID_APM_INVARIANT_TSC     (1<<8)      // EDX[8] - Bit 8 of function 0x80000007 indicates support for invariant TSC.
  296|       |
  297|      2|        uint features = 0;
  298|       |
  299|       |        // Supports CPUID instruction ?
  300|      2|        if (_isSupportCpuid())
  ------------------
  |  Branch (300:13): [True: 2, False: 0]
  ------------------
  301|      2|        {
  302|      2|            CpuidResult result;
  303|       |
  304|       |            // Has standard feature ?
  305|      2|            if (_performCpuid(CPUID_FUNC_VENDOR_ID, result))
  ------------------
  |  |  268|      2|#define CPUID_FUNC_VENDOR_ID                 0x0
  ------------------
  |  Branch (305:17): [True: 2, False: 0]
  ------------------
  306|      2|            {
  307|       |                // Check vendor strings
  308|      2|                if (memcmp(&result._ebx, "GenuineIntel", 12) == 0)
  ------------------
  |  Branch (308:21): [True: 2, False: 0]
  ------------------
  309|      2|                {
  310|      2|                    if (result._eax > 2)
  ------------------
  |  Branch (310:25): [True: 2, False: 0]
  ------------------
  311|      2|                        features |= PlatformInformation::CPU_FEATURE_PRO;
  312|       |
  313|       |                    // Check standard feature
  314|      2|                    _performCpuid(CPUID_FUNC_STANDARD_FEATURES, result);
  ------------------
  |  |  269|      2|#define CPUID_FUNC_STANDARD_FEATURES         0x1
  ------------------
  315|       |
  316|      2|                    if (result._edx & CPUID_STD_FPU)
  ------------------
  |  |  274|      2|#define CPUID_STD_FPU               (1<<0)
  ------------------
  |  Branch (316:25): [True: 2, False: 0]
  ------------------
  317|      2|                        features |= PlatformInformation::CPU_FEATURE_FPU;
  318|      2|                    if (result._edx & CPUID_STD_TSC)
  ------------------
  |  |  275|      2|#define CPUID_STD_TSC               (1<<4)
  ------------------
  |  Branch (318:25): [True: 2, False: 0]
  ------------------
  319|      2|                        features |= PlatformInformation::CPU_FEATURE_TSC;
  320|      2|                    if (result._edx & CPUID_STD_CMOV)
  ------------------
  |  |  276|      2|#define CPUID_STD_CMOV              (1<<15)
  ------------------
  |  Branch (320:25): [True: 2, False: 0]
  ------------------
  321|      2|                        features |= PlatformInformation::CPU_FEATURE_CMOV;
  322|      2|                    if (result._edx & CPUID_STD_MMX)
  ------------------
  |  |  277|      2|#define CPUID_STD_MMX               (1<<23)
  ------------------
  |  Branch (322:25): [True: 2, False: 0]
  ------------------
  323|      2|                        features |= PlatformInformation::CPU_FEATURE_MMX;
  324|      2|                    if (result._edx & CPUID_STD_SSE)
  ------------------
  |  |  278|      2|#define CPUID_STD_SSE               (1<<25)
  ------------------
  |  Branch (324:25): [True: 2, False: 0]
  ------------------
  325|      2|                        features |= PlatformInformation::CPU_FEATURE_MMXEXT | PlatformInformation::CPU_FEATURE_SSE;
  326|      2|                    if (result._edx & CPUID_STD_SSE2)
  ------------------
  |  |  279|      2|#define CPUID_STD_SSE2              (1<<26)
  ------------------
  |  Branch (326:25): [True: 2, False: 0]
  ------------------
  327|      2|                        features |= PlatformInformation::CPU_FEATURE_SSE2;
  328|      2|                    if (result._ecx & CPUID_STD_SSE3)
  ------------------
  |  |  282|      2|#define CPUID_STD_SSE3              (1<<0)      // ECX[0]  - Bit 0 of standard function 1 indicate SSE3 supported
  ------------------
  |  Branch (328:25): [True: 2, False: 0]
  ------------------
  329|      2|                        features |= PlatformInformation::CPU_FEATURE_SSE3;
  330|      2|                    if (result._ecx & CPUID_STD_SSE41)
  ------------------
  |  |  283|      2|#define CPUID_STD_SSE41             (1<<19)     // ECX[19] - Bit 0 of standard function 1 indicate SSE41 supported
  ------------------
  |  Branch (330:25): [True: 2, False: 0]
  ------------------
  331|      2|                        features |= PlatformInformation::CPU_FEATURE_SSE41;
  332|      2|                    if (result._ecx & CPUID_STD_SSE42)
  ------------------
  |  |  284|      2|#define CPUID_STD_SSE42             (1<<20)     // ECX[20] - Bit 0 of standard function 1 indicate SSE42 supported
  ------------------
  |  Branch (332:25): [True: 2, False: 0]
  ------------------
  333|      2|                        features |= PlatformInformation::CPU_FEATURE_SSE42;
  334|       |
  335|       |                    // Check to see if this is a Pentium 4 or later processor
  336|      2|                    if ((result._eax & CPUID_EXT_FAMILY_ID_MASK) ||
  ------------------
  |  |  287|      2|#define CPUID_EXT_FAMILY_ID_MASK    0x0F00000   // EAX[23:20] - Bit 23 thru 20 contains extended family processor id
  ------------------
  |  Branch (336:25): [True: 0, False: 2]
  ------------------
  337|      2|                        (result._eax & CPUID_FAMILY_ID_MASK) == CPUID_PENTIUM4_ID)
  ------------------
  |  |  286|      2|#define CPUID_FAMILY_ID_MASK        0x0F00      // EAX[11:8] - Bit 11 thru 8 contains family  processor id
  ------------------
                                      (result._eax & CPUID_FAMILY_ID_MASK) == CPUID_PENTIUM4_ID)
  ------------------
  |  |  288|      2|#define CPUID_PENTIUM4_ID           0x0F00      // Pentium 4 family processor id
  ------------------
  |  Branch (337:25): [True: 0, False: 2]
  ------------------
  338|      0|                    {
  339|       |                        // Check hyper-threading technology
  340|      0|                        if (result._edx & CPUID_STD_HTT)
  ------------------
  |  |  280|      0|#define CPUID_STD_HTT               (1<<28)     // EDX[28] - Bit 28 set indicates  Hyper-Threading Technology is supported in hardware.
  ------------------
  |  Branch (340:29): [True: 0, False: 0]
  ------------------
  341|      0|                            features |= PlatformInformation::CPU_FEATURE_HTT;
  342|      0|                    }
  343|       |
  344|       |
  345|      2|                    const uint maxExtensionFunctionSupport = _performCpuid(CPUID_FUNC_EXTENSION_QUERY, result);
  ------------------
  |  |  270|      2|#define CPUID_FUNC_EXTENSION_QUERY           0x80000000
  ------------------
  346|      2|                    if (maxExtensionFunctionSupport >= CPUID_FUNC_ADVANCED_POWER_MANAGEMENT)
  ------------------
  |  |  272|      2|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007
  ------------------
  |  Branch (346:25): [True: 2, False: 0]
  ------------------
  347|      2|                    {
  348|      2|                        _performCpuid(CPUID_FUNC_ADVANCED_POWER_MANAGEMENT, result);
  ------------------
  |  |  272|      2|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007
  ------------------
  349|       |
  350|      2|                        if (result._edx & CPUID_APM_INVARIANT_TSC)
  ------------------
  |  |  295|      2|#define CPUID_APM_INVARIANT_TSC     (1<<8)      // EDX[8] - Bit 8 of function 0x80000007 indicates support for invariant TSC.
  ------------------
  |  Branch (350:29): [True: 2, False: 0]
  ------------------
  351|      2|                            features |= PlatformInformation::CPU_FEATURE_INVARIANT_TSC;
  352|      2|                    }
  353|      2|                }
  354|      0|                else if (memcmp(&result._ebx, "AuthenticAMD", 12) == 0)
  ------------------
  |  Branch (354:26): [True: 0, False: 0]
  ------------------
  355|      0|                {
  356|      0|                    features |= PlatformInformation::CPU_FEATURE_PRO;
  357|       |
  358|       |                    // Check standard feature
  359|      0|                    _performCpuid(CPUID_FUNC_STANDARD_FEATURES, result);
  ------------------
  |  |  269|      0|#define CPUID_FUNC_STANDARD_FEATURES         0x1
  ------------------
  360|       |
  361|      0|                    if (result._edx & CPUID_STD_FPU)
  ------------------
  |  |  274|      0|#define CPUID_STD_FPU               (1<<0)
  ------------------
  |  Branch (361:25): [True: 0, False: 0]
  ------------------
  362|      0|                        features |= PlatformInformation::CPU_FEATURE_FPU;
  363|      0|                    if (result._edx & CPUID_STD_TSC)
  ------------------
  |  |  275|      0|#define CPUID_STD_TSC               (1<<4)
  ------------------
  |  Branch (363:25): [True: 0, False: 0]
  ------------------
  364|      0|                        features |= PlatformInformation::CPU_FEATURE_TSC;
  365|      0|                    if (result._edx & CPUID_STD_CMOV)
  ------------------
  |  |  276|      0|#define CPUID_STD_CMOV              (1<<15)
  ------------------
  |  Branch (365:25): [True: 0, False: 0]
  ------------------
  366|      0|                        features |= PlatformInformation::CPU_FEATURE_CMOV;
  367|      0|                    if (result._edx & CPUID_STD_MMX)
  ------------------
  |  |  277|      0|#define CPUID_STD_MMX               (1<<23)
  ------------------
  |  Branch (367:25): [True: 0, False: 0]
  ------------------
  368|      0|                        features |= PlatformInformation::CPU_FEATURE_MMX;
  369|      0|                    if (result._edx & CPUID_STD_SSE)
  ------------------
  |  |  278|      0|#define CPUID_STD_SSE               (1<<25)
  ------------------
  |  Branch (369:25): [True: 0, False: 0]
  ------------------
  370|      0|                        features |= PlatformInformation::CPU_FEATURE_SSE;
  371|      0|                    if (result._edx & CPUID_STD_SSE2)
  ------------------
  |  |  279|      0|#define CPUID_STD_SSE2              (1<<26)
  ------------------
  |  Branch (371:25): [True: 0, False: 0]
  ------------------
  372|      0|                        features |= PlatformInformation::CPU_FEATURE_SSE2;
  373|       |
  374|      0|                    if (result._ecx & CPUID_STD_SSE3)
  ------------------
  |  |  282|      0|#define CPUID_STD_SSE3              (1<<0)      // ECX[0]  - Bit 0 of standard function 1 indicate SSE3 supported
  ------------------
  |  Branch (374:25): [True: 0, False: 0]
  ------------------
  375|      0|                        features |= PlatformInformation::CPU_FEATURE_SSE3;
  376|       |
  377|       |                    // Has extended feature ?
  378|      0|                    const uint maxExtensionFunctionSupport = _performCpuid(CPUID_FUNC_EXTENSION_QUERY, result);
  ------------------
  |  |  270|      0|#define CPUID_FUNC_EXTENSION_QUERY           0x80000000
  ------------------
  379|      0|                    if (maxExtensionFunctionSupport >= CPUID_FUNC_EXTENDED_FEATURES)
  ------------------
  |  |  271|      0|#define CPUID_FUNC_EXTENDED_FEATURES         0x80000001
  ------------------
  |  Branch (379:25): [True: 0, False: 0]
  ------------------
  380|      0|                    {
  381|       |                        // Check extended feature
  382|      0|                        _performCpuid(CPUID_FUNC_EXTENDED_FEATURES, result);
  ------------------
  |  |  271|      0|#define CPUID_FUNC_EXTENDED_FEATURES         0x80000001
  ------------------
  383|       |
  384|      0|                        if (result._edx & CPUID_EXT_3DNOW)
  ------------------
  |  |  290|      0|#define CPUID_EXT_3DNOW             (1<<31)
  ------------------
  |  Branch (384:29): [True: 0, False: 0]
  ------------------
  385|      0|                            features |= PlatformInformation::CPU_FEATURE_3DNOW;
  386|      0|                        if (result._edx & CPUID_EXT_AMD_3DNOWEXT)
  ------------------
  |  |  291|      0|#define CPUID_EXT_AMD_3DNOWEXT      (1<<30)
  ------------------
  |  Branch (386:29): [True: 0, False: 0]
  ------------------
  387|      0|                            features |= PlatformInformation::CPU_FEATURE_3DNOWEXT;
  388|      0|                        if (result._edx & CPUID_EXT_AMD_MMXEXT)
  ------------------
  |  |  292|      0|#define CPUID_EXT_AMD_MMXEXT        (1<<22)
  ------------------
  |  Branch (388:29): [True: 0, False: 0]
  ------------------
  389|      0|                            features |= PlatformInformation::CPU_FEATURE_MMXEXT;
  390|      0|                    }
  391|       |
  392|       |
  393|      0|                    if (maxExtensionFunctionSupport >= CPUID_FUNC_ADVANCED_POWER_MANAGEMENT)
  ------------------
  |  |  272|      0|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007
  ------------------
  |  Branch (393:25): [True: 0, False: 0]
  ------------------
  394|      0|                    {
  395|      0|                        _performCpuid(CPUID_FUNC_ADVANCED_POWER_MANAGEMENT, result);
  ------------------
  |  |  272|      0|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007
  ------------------
  396|       |
  397|      0|                        if (result._edx & CPUID_APM_INVARIANT_TSC)
  ------------------
  |  |  295|      0|#define CPUID_APM_INVARIANT_TSC     (1<<8)      // EDX[8] - Bit 8 of function 0x80000007 indicates support for invariant TSC.
  ------------------
  |  Branch (397:29): [True: 0, False: 0]
  ------------------
  398|      0|                            features |= PlatformInformation::CPU_FEATURE_INVARIANT_TSC;
  399|      0|                    }
  400|      0|                }
  401|      2|            }
  402|      2|        }
  403|       |
  404|      2|        return features;
  405|      2|    }
OgrePlatformInformation.cpp:_ZN4OgreL31_checkOperatingSystemSupportSSEEv:
  202|      2|    {
  203|       |#if OGRE_COMPILER == OGRE_COMPILER_MSVC
  204|       |        /*
  205|       |            The FP part of SSE introduces a new architectural state and therefore
  206|       |            requires support from the operating system. So even if CPUID indicates
  207|       |            support for SSE FP, the application might not be able to use it. If
  208|       |            CPUID indicates support for SSE FP, check here whether it is also
  209|       |            supported by the OS, and turn off the SSE FP feature bit if there
  210|       |            is no OS support for SSE FP.
  211|       |
  212|       |            Operating systems that do not support SSE FP return an illegal
  213|       |            instruction exception if execution of an SSE FP instruction is performed.
  214|       |            Here, a sample SSE FP instruction is executed, and is checked for an
  215|       |            exception using the (non-standard) __try/__except mechanism
  216|       |            of Microsoft Visual C/C++.
  217|       |        */
  218|       |        // Visual Studio 2005, Both AMD and Intel x64 support SSE
  219|       |        // note that even though this is a build rather than runtime setting, all
  220|       |        // 64-bit CPUs support this so since binary is 64-bit only we're ok
  221|       |    #if _MSC_VER >= 1400 && defined(_M_X64)
  222|       |            return true;
  223|       |    #else
  224|       |        __try
  225|       |        {
  226|       |            __asm orps  xmm0, xmm0
  227|       |            return true;
  228|       |        }
  229|       |        __except(EXCEPTION_EXECUTE_HANDLER)
  230|       |        {
  231|       |            return false;
  232|       |        }
  233|       |    #endif
  234|       |#elif (OGRE_COMPILER == OGRE_COMPILER_GNUC || OGRE_COMPILER == OGRE_COMPILER_CLANG) && OGRE_PLATFORM != OGRE_PLATFORM_EMSCRIPTEN
  235|       |        #if OGRE_ARCH_TYPE == OGRE_ARCHITECTURE_64 
  236|      2|            return true;
  237|       |        #else
  238|       |        // Does gcc have __try/__except similar mechanism?
  239|       |        // Use signal, setjmp/longjmp instead.
  240|       |        void (*oldHandler)(int);
  241|       |        oldHandler = signal(SIGILL, _illegalHandler);
  242|       |
  243|       |        if (setjmp(sIllegalJmpBuf))
  244|       |        {
  245|       |            signal(SIGILL, oldHandler);
  246|       |            return false;
  247|       |        }
  248|       |        else
  249|       |        {
  250|       |            __asm__ __volatile__ ("orps %xmm0, %xmm0");
  251|       |            signal(SIGILL, oldHandler);
  252|       |            return true;
  253|       |        }
  254|       |       #endif
  255|       |#else
  256|       |        // TODO: Supports other compiler, assumed is supported by default
  257|       |        return true;
  258|       |#endif
  259|      2|    }
OgrePlatformInformation.cpp:_ZN4OgreL15_isSupportCpuidEv:
   83|      4|    {
   84|       |#if OGRE_COMPILER == OGRE_COMPILER_MSVC
   85|       |        // Visual Studio 2005 & 64-bit compilers always supports __cpuid intrinsic
   86|       |        // note that even though this is a build rather than runtime setting, all
   87|       |        // 64-bit CPUs support this so since binary is 64-bit only we're ok
   88|       |    #if _MSC_VER >= 1400 && defined(_M_X64)
   89|       |        return true;
   90|       |    #else
   91|       |        // If we can modify flag register bit 21, the cpu is supports CPUID instruction
   92|       |        __asm
   93|       |        {
   94|       |            // Read EFLAG
   95|       |            pushfd
   96|       |            pop     eax
   97|       |            mov     ecx, eax
   98|       |
   99|       |            // Modify bit 21
  100|       |            xor     eax, 0x200000
  101|       |            push    eax
  102|       |            popfd
  103|       |
  104|       |            // Read back EFLAG
  105|       |            pushfd
  106|       |            pop     eax
  107|       |
  108|       |            // Restore EFLAG
  109|       |            push    ecx
  110|       |            popfd
  111|       |
  112|       |            // Check bit 21 modifiable
  113|       |            xor     eax, ecx
  114|       |            neg     eax
  115|       |            sbb     eax, eax
  116|       |
  117|       |            // Return values in eax, no return statement requirement here for VC.
  118|       |        }
  119|       |    #endif
  120|       |#elif (OGRE_COMPILER == OGRE_COMPILER_GNUC || OGRE_COMPILER == OGRE_COMPILER_CLANG) && OGRE_PLATFORM != OGRE_PLATFORM_EMSCRIPTEN
  121|       |        #if OGRE_ARCH_TYPE == OGRE_ARCHITECTURE_64
  122|      4|           return true;
  123|       |       #else
  124|       |        unsigned oldFlags, newFlags;
  125|       |        __asm__
  126|       |        (
  127|       |            "pushfl         \n\t"
  128|       |            "pop    %0      \n\t"
  129|       |            "mov    %0, %1  \n\t"
  130|       |            "xor    %2, %0  \n\t"
  131|       |            "push   %0      \n\t"
  132|       |            "popfl          \n\t"
  133|       |            "pushfl         \n\t"
  134|       |            "pop    %0      \n\t"
  135|       |            "push   %1      \n\t"
  136|       |            "popfl          \n\t"
  137|       |            : "=r" (oldFlags), "=r" (newFlags)
  138|       |            : "n" (0x200000)
  139|       |        );
  140|       |        return oldFlags != newFlags;
  141|       |       #endif // 64
  142|       |#else
  143|       |        // TODO: Supports other compiler
  144|       |        return false;
  145|       |#endif
  146|      4|    }

_ZN4Ogre4PoseC2EtRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   34|  19.2k|        : mTarget(target), mName(name)
   35|  19.2k|    {
   36|  19.2k|    }
_ZN4Ogre4Pose9addVertexEjRKNS_6VectorILi3EfEE:
   39|  2.29k|    {
   40|  2.29k|        OgreAssert(mNormalsMap.empty(),
  ------------------
  |  Branch (40:9): [True: 0, False: 2.29k]
  ------------------
   41|  2.29k|                   "Inconsistent calls to addVertex, must include normals always or never");
   42|       |
   43|  2.29k|        if(offset.squaredLength() < 1e-6f)
  ------------------
  |  Branch (43:12): [True: 215, False: 2.08k]
  ------------------
   44|    215|        {
   45|    215|            return;
   46|    215|        }
   47|       |
   48|  2.08k|        mVertexOffsetMap[index] = offset;
   49|  2.08k|        mBuffer.reset();
   50|  2.08k|    }
_ZN4Ogre4Pose9addVertexEjRKNS_6VectorILi3EfEES4_:
   53|  2.58k|    {
   54|  2.58k|        OgreAssert(mVertexOffsetMap.empty() || !mNormalsMap.empty(),
  ------------------
  |  Branch (54:9): [True: 821, False: 1.76k]
  |  Branch (54:9): [True: 1.76k, False: 0]
  ------------------
   55|  2.58k|                   "Inconsistent calls to addVertex, must include normals always or never");
   56|       |
   57|  2.58k|        if(offset.squaredLength() < 1e-6f && normal.squaredLength() < 1e-6f)
  ------------------
  |  Branch (57:12): [True: 926, False: 1.65k]
  |  Branch (57:46): [True: 224, False: 702]
  ------------------
   58|    224|        {
   59|    224|            return;
   60|    224|        }
   61|       |
   62|  2.35k|        mVertexOffsetMap[index] = offset;
   63|  2.35k|        mNormalsMap[index] = normal;
   64|  2.35k|        mBuffer.reset();
   65|  2.35k|    }

_ZNK4Ogre10QuaternionmlERKS0_:
  261|      2|    {
  262|       |        // NOTE:  Multiplication is not generally commutative, so in most
  263|       |        // cases p*q != q*p.
  264|       |
  265|      2|        return Quaternion
  266|      2|        (
  267|      2|            w * rkQ.w - x * rkQ.x - y * rkQ.y - z * rkQ.z,
  268|      2|            w * rkQ.x + x * rkQ.w + y * rkQ.z - z * rkQ.y,
  269|      2|            w * rkQ.y + y * rkQ.w + z * rkQ.x - x * rkQ.z,
  270|      2|            w * rkQ.z + z * rkQ.w + x * rkQ.y - y * rkQ.x
  271|      2|        );
  272|      2|    }
_ZNK4Ogre10Quaternion7InverseEv:
  275|    650|    {
  276|    650|        Real fNorm = w*w+x*x+y*y+z*z;
  277|    650|        if ( fNorm > 0.0 )
  ------------------
  |  Branch (277:14): [True: 420, False: 230]
  ------------------
  278|    420|        {
  279|    420|            Real fInvNorm = 1.0f/fNorm;
  280|    420|            return Quaternion(w*fInvNorm,-x*fInvNorm,-y*fInvNorm,-z*fInvNorm);
  281|    420|        }
  282|    230|        else
  283|    230|        {
  284|       |            // return an invalid result to flag the error
  285|    230|            return ZERO;
  286|    230|        }
  287|    650|    }
_ZNK4Ogre10QuaternionmlERKNS_6VectorILi3EfEE:
  360|      2|    {
  361|       |		// nVidia SDK implementation
  362|      2|		Vector3 uv, uuv;
  363|      2|		Vector3 qvec(x, y, z);
  364|      2|		uv = qvec.crossProduct(v);
  365|      2|		uuv = qvec.crossProduct(uv);
  366|      2|		uv *= (2.0f * w);
  367|      2|		uuv *= 2.0f;
  368|       |
  369|      2|		return v + uv + uuv;
  370|       |
  371|      2|    }

_ZN4Ogre8ResourceC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE:
   36|  10.0k|        : mCreator(creator), mName(name), mGroup(group), mHandle(handle), 
   37|  10.0k|        mLoadingState(LOADSTATE_UNLOADED), mIsBackgroundLoaded(false),
   38|  10.0k|        mIsManual(isManual), mSize(0),  mLoader(loader), mStateCount(0)
   39|  10.0k|    {
   40|  10.0k|    }
_ZN4Ogre8ResourceD2Ev:
   43|  7.11k|    { 
   44|  7.11k|    }
_ZN4Ogre8ResourceaSERKS0_:
   46|      2|    {
   47|      2|        mName = rhs.mName;
   48|      2|        mGroup = rhs.mGroup;
   49|      2|        mCreator = rhs.mCreator;
   50|      2|        mIsManual = rhs.mIsManual;
   51|      2|        mLoader = rhs.mLoader;
   52|      2|        mHandle = rhs.mHandle;
   53|      2|        mSize = rhs.mSize;
   54|       |
   55|      2|        mLoadingState.store(rhs.mLoadingState.load());
   56|      2|        mIsBackgroundLoaded = rhs.mIsBackgroundLoaded;
   57|       |
   58|      2|        return *this;
   59|      2|    }
_ZN4Ogre8Resource7prepareEb:
   70|  1.51k|    {
   71|       |        // quick check that avoids any synchronisation
   72|  1.51k|        LoadingState old = mLoadingState.load();
   73|  1.51k|        if (old != LOADSTATE_UNLOADED && old != LOADSTATE_PREPARING) return;
  ------------------
  |  Branch (73:13): [True: 0, False: 1.51k]
  |  Branch (73:42): [True: 0, False: 0]
  ------------------
   74|       |
   75|       |        // atomically do slower check to make absolutely sure,
   76|       |        // and set the load state to PREPARING
   77|  1.51k|        old = LOADSTATE_UNLOADED;
   78|  1.51k|        if (!mLoadingState.compare_exchange_strong(old,LOADSTATE_PREPARING))
  ------------------
  |  Branch (78:13): [True: 0, False: 1.51k]
  ------------------
   79|      0|        {
   80|      0|            while( mLoadingState.load() == LOADSTATE_PREPARING )
  ------------------
  |  Branch (80:20): [True: 0, False: 0]
  ------------------
   81|      0|            {
   82|      0|                            OGRE_LOCK_AUTO_MUTEX;
   83|      0|            }
   84|       |
   85|      0|            LoadingState state = mLoadingState.load();
   86|      0|            if( state != LOADSTATE_PREPARED && state != LOADSTATE_LOADING && state != LOADSTATE_LOADED )
  ------------------
  |  Branch (86:17): [True: 0, False: 0]
  |  Branch (86:48): [True: 0, False: 0]
  |  Branch (86:78): [True: 0, False: 0]
  ------------------
   87|      0|            {
   88|      0|                OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Another thread failed in resource operation",
   89|      0|                    "Resource::prepare");
   90|      0|            }
   91|      0|            return;
   92|      0|        }
   93|       |
   94|       |        // Scope lock for actual loading
   95|  1.51k|        try
   96|  1.51k|        {
   97|       |
   98|  1.51k|                    OGRE_LOCK_AUTO_MUTEX;
   99|       |
  100|  1.51k|            if (mIsManual)
  ------------------
  |  Branch (100:17): [True: 1.32k, False: 190]
  ------------------
  101|  1.32k|            {
  102|  1.32k|                if (mLoader)
  ------------------
  |  Branch (102:21): [True: 0, False: 1.32k]
  ------------------
  103|      0|                {
  104|      0|                    mLoader->prepareResource(this);
  105|      0|                }
  106|  1.32k|                else
  107|  1.32k|                {
  108|       |                    // Warn that this resource is not reloadable
  109|  1.32k|                    LogManager::getSingleton().stream(LML_TRIVIAL) 
  110|  1.32k|                        << "Note: " << mCreator->getResourceType()
  111|  1.32k|                        << " instance '" << mName << "' was defined as manually "
  112|  1.32k|                        << "loaded, but no manual loader was provided. This Resource "
  113|  1.32k|                        << "will be lost if it has to be reloaded.";
  114|  1.32k|                }
  115|  1.32k|            }
  116|    190|            else
  117|    190|            {
  118|    190|                if (mGroup == ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME)
  ------------------
  |  Branch (118:21): [True: 0, False: 190]
  ------------------
  119|      0|                {
  120|       |                    // Derive resource group
  121|      0|                    changeGroupOwnership(
  122|      0|                        ResourceGroupManager::getSingleton()
  123|      0|                        .findGroupContainingResource(mName));
  124|      0|                }
  125|    190|                prepareImpl();
  126|    190|            }
  127|  1.51k|        }
  128|  1.51k|        catch (...)
  129|  1.51k|        {
  130|    190|            mLoadingState.store(LOADSTATE_UNLOADED);
  131|       |
  132|    190|            OGRE_LOCK_AUTO_MUTEX;
  133|    190|            unloadImpl();
  134|       |
  135|    190|            throw;
  136|    190|        }
  137|       |
  138|  1.32k|        mLoadingState.store(LOADSTATE_PREPARED);
  139|       |
  140|       |        // Since we don't distinguish between GPU and CPU RAM, this
  141|       |        // seems pointless
  142|       |        //if(mCreator)
  143|       |        //  mCreator->_notifyResourcePrepared(this);
  144|       |
  145|       |        // Fire events (if not background)
  146|  1.32k|        if (!background)
  ------------------
  |  Branch (146:13): [True: 1.32k, False: 0]
  ------------------
  147|  1.32k|            _firePreparingComplete();
  148|       |
  149|       |
  150|  1.32k|    }
_ZN4Ogre8Resource4loadEb:
  153|  23.6k|    {
  154|       |        // Early-out without lock (mitigate perf cost of ensuring loaded)
  155|       |        // Don't load if:
  156|       |        // 1. We're already loaded
  157|       |        // 2. Another thread is loading right now
  158|       |        // 3. We're marked for background loading and this is not the background
  159|       |        //    loading thread we're being called by
  160|       |
  161|  23.6k|        if (mIsBackgroundLoaded && !background) return;
  ------------------
  |  Branch (161:13): [True: 0, False: 23.6k]
  |  Branch (161:36): [True: 0, False: 0]
  ------------------
  162|       |
  163|       |        // This next section is to deal with cases where 2 threads are fighting over
  164|       |        // who gets to prepare / load - this will only usually happen if loading is escalated
  165|  23.6k|        bool keepChecking = true;
  166|  23.6k|        LoadingState old = LOADSTATE_UNLOADED;
  167|  47.2k|        while (keepChecking)
  ------------------
  |  Branch (167:16): [True: 23.6k, False: 23.6k]
  ------------------
  168|  23.6k|        {
  169|       |            // quick check that avoids any synchronisation
  170|  23.6k|            old = mLoadingState.load();
  171|       |
  172|  23.6k|            if ( old == LOADSTATE_PREPARING )
  ------------------
  |  Branch (172:18): [True: 0, False: 23.6k]
  ------------------
  173|      0|            {
  174|      0|                while( mLoadingState.load() == LOADSTATE_PREPARING )
  ------------------
  |  Branch (174:24): [True: 0, False: 0]
  ------------------
  175|      0|                {
  176|      0|                                    OGRE_LOCK_AUTO_MUTEX;
  177|      0|                }
  178|      0|                old = mLoadingState.load();
  179|      0|            }
  180|       |
  181|  23.6k|            if (old!=LOADSTATE_UNLOADED && old!=LOADSTATE_PREPARED && old!=LOADSTATE_LOADING) return;
  ------------------
  |  Branch (181:17): [True: 0, False: 23.6k]
  |  Branch (181:44): [True: 0, False: 0]
  |  Branch (181:71): [True: 0, False: 0]
  ------------------
  182|       |
  183|       |            // atomically do slower check to make absolutely sure,
  184|       |            // and set the load state to LOADING
  185|  23.6k|            if (old==LOADSTATE_LOADING || !mLoadingState.compare_exchange_strong(old,LOADSTATE_LOADING))
  ------------------
  |  Branch (185:17): [True: 0, False: 23.6k]
  |  Branch (185:43): [True: 0, False: 23.6k]
  ------------------
  186|      0|            {
  187|      0|                while( mLoadingState.load() == LOADSTATE_LOADING )
  ------------------
  |  Branch (187:24): [True: 0, False: 0]
  ------------------
  188|      0|                {
  189|      0|                                    OGRE_LOCK_AUTO_MUTEX;
  190|      0|                }
  191|       |
  192|      0|                LoadingState state = mLoadingState.load();
  193|      0|                if( state == LOADSTATE_PREPARED || state == LOADSTATE_PREPARING )
  ------------------
  |  Branch (193:21): [True: 0, False: 0]
  |  Branch (193:52): [True: 0, False: 0]
  ------------------
  194|      0|                {
  195|       |                    // another thread is preparing, loop around
  196|      0|                    continue;
  197|      0|                }
  198|      0|                else if( state != LOADSTATE_LOADED )
  ------------------
  |  Branch (198:26): [True: 0, False: 0]
  ------------------
  199|      0|                {
  200|      0|                    OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Another thread failed in resource operation",
  201|      0|                        "Resource::load");
  202|      0|                }
  203|      0|                return;
  204|      0|            }
  205|  23.6k|            keepChecking = false;
  206|  23.6k|        }
  207|       |
  208|       |        // Scope lock for actual loading
  209|  23.6k|        try
  210|  23.6k|        {
  211|       |
  212|  23.6k|                    OGRE_LOCK_AUTO_MUTEX;
  213|       |
  214|       |
  215|       |
  216|  23.6k|            if (mIsManual)
  ------------------
  |  Branch (216:17): [True: 5.79k, False: 17.8k]
  ------------------
  217|  5.79k|            {
  218|  5.79k|                if (old==LOADSTATE_UNLOADED && mLoader)
  ------------------
  |  Branch (218:21): [True: 5.79k, False: 0]
  |  Branch (218:48): [True: 0, False: 5.79k]
  ------------------
  219|      0|                {
  220|      0|                    mLoader->prepareResource(this);
  221|       |
  222|      0|                    if (!background)
  ------------------
  |  Branch (222:25): [True: 0, False: 0]
  ------------------
  223|      0|                        _firePreparingComplete();
  224|      0|                }
  225|       |
  226|  5.79k|                preLoadImpl();
  227|       |
  228|       |                // Load from manual loader
  229|  5.79k|                if (mLoader)
  ------------------
  |  Branch (229:21): [True: 0, False: 5.79k]
  ------------------
  230|      0|                {
  231|      0|                    mLoader->loadResource(this);
  232|      0|                }
  233|  5.79k|                else
  234|  5.79k|                {
  235|       |                    // Warn that this resource is not reloadable
  236|  5.79k|                    LogManager::getSingleton().stream(LML_TRIVIAL) 
  237|  5.79k|                        << "Note: " << mCreator->getResourceType()
  238|  5.79k|                        << " instance '" << mName << "' was defined as manually "
  239|  5.79k|                        << "loaded, but no manual loader was provided. This Resource "
  240|  5.79k|                        << "will be lost if it has to be reloaded.";
  241|  5.79k|                }
  242|  5.79k|                postLoadImpl();
  243|  5.79k|            }
  244|  17.8k|            else
  245|  17.8k|            {
  246|       |
  247|  17.8k|                if (old==LOADSTATE_UNLOADED)
  ------------------
  |  Branch (247:21): [True: 17.8k, False: 0]
  ------------------
  248|  17.8k|                {
  249|  17.8k|                    prepareImpl();
  250|       |
  251|  17.8k|                    if (!background)
  ------------------
  |  Branch (251:25): [True: 0, False: 17.8k]
  ------------------
  252|      0|                        _firePreparingComplete();
  253|  17.8k|                }
  254|       |
  255|  17.8k|                preLoadImpl();
  256|       |
  257|  17.8k|                if (mGroup == ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME)
  ------------------
  |  Branch (257:21): [True: 0, False: 17.8k]
  ------------------
  258|      0|                {
  259|       |                    // Derive resource group
  260|      0|                    changeGroupOwnership(
  261|      0|                        ResourceGroupManager::getSingleton()
  262|      0|                        .findGroupContainingResource(mName));
  263|      0|                }
  264|       |
  265|  17.8k|                loadImpl();
  266|       |
  267|  17.8k|                postLoadImpl();
  268|  17.8k|            }
  269|       |
  270|       |            // Calculate resource size
  271|  23.6k|            mSize = calculateSize();
  272|       |
  273|  23.6k|        }
  274|  23.6k|        catch (...)
  275|  23.6k|        {
  276|       |            // Reset loading in-progress flag, in case failed for some reason.
  277|       |            // We reset it to UNLOADED because the only other case is when
  278|       |            // old == PREPARED in which case the loadImpl should wipe out
  279|       |            // any prepared data since it might be invalid.
  280|  17.8k|            mLoadingState.store(LOADSTATE_UNLOADED);
  281|       |
  282|  17.8k|            OGRE_LOCK_AUTO_MUTEX;
  283|  17.8k|            unloadImpl();
  284|       |
  285|       |            // Re-throw
  286|  17.8k|            throw;
  287|  17.8k|        }
  288|       |
  289|  5.79k|        mLoadingState.store(LOADSTATE_LOADED);
  290|  5.79k|        _dirtyState();
  291|       |
  292|       |        // Notify manager
  293|  5.79k|        if(mCreator)
  ------------------
  |  Branch (293:12): [True: 5.79k, False: 0]
  ------------------
  294|  5.79k|            mCreator->_notifyResourceLoaded(this);
  295|       |
  296|       |        // Fire events, if not background
  297|  5.79k|        if (!background)
  ------------------
  |  Branch (297:13): [True: 5.79k, False: 0]
  ------------------
  298|  5.79k|            _fireLoadingComplete();
  299|       |
  300|       |
  301|  5.79k|    }
_ZN4Ogre8Resource11_dirtyStateEv:
  315|   220k|    {
  316|       |        // don't worry about threading here, count only ever increases so 
  317|       |        // doesn't matter if we get a lost increment (one is enough)
  318|   220k|        ++mStateCount;  
  319|   220k|    }
_ZN4Ogre8Resource6unloadEv:
  333|  7.11k|    { 
  334|       |        // Early-out without lock (mitigate perf cost of ensuring unloaded)
  335|  7.11k|        LoadingState old = mLoadingState.load();
  336|  7.11k|        if (old!=LOADSTATE_LOADED && old!=LOADSTATE_PREPARED) return;
  ------------------
  |  Branch (336:13): [True: 1.32k, False: 5.79k]
  |  Branch (336:38): [True: 0, False: 1.32k]
  ------------------
  337|       |
  338|       |
  339|  7.11k|        if (!mLoadingState.compare_exchange_strong(old,LOADSTATE_UNLOADING)) return;
  ------------------
  |  Branch (339:13): [True: 0, False: 7.11k]
  ------------------
  340|       |
  341|       |        // Scope lock for actual unload
  342|  7.11k|        {
  343|  7.11k|                    OGRE_LOCK_AUTO_MUTEX;
  344|  7.11k|            if (old==LOADSTATE_PREPARED) {
  ------------------
  |  Branch (344:17): [True: 1.32k, False: 5.79k]
  ------------------
  345|  1.32k|                unprepareImpl();
  346|  5.79k|            } else {
  347|  5.79k|                preUnloadImpl();
  348|  5.79k|                unloadImpl();
  349|  5.79k|                postUnloadImpl();
  350|  5.79k|            }
  351|  7.11k|        }
  352|       |
  353|  7.11k|        mLoadingState.store(LOADSTATE_UNLOADED);
  354|       |
  355|       |        // Notify manager
  356|       |        // Note if we have gone from PREPARED to UNLOADED, then we haven't actually
  357|       |        // unloaded, i.e. there is no memory freed on the GPU.
  358|  7.11k|        if(old==LOADSTATE_LOADED && mCreator)
  ------------------
  |  Branch (358:12): [True: 5.79k, False: 1.32k]
  |  Branch (358:37): [True: 5.79k, False: 0]
  ------------------
  359|  5.79k|            mCreator->_notifyResourceUnloaded(this);
  360|       |
  361|  7.11k|        _fireUnloadingComplete();
  362|       |
  363|       |
  364|  7.11k|    }
_ZN4Ogre8Resource20_fireLoadingCompleteEb:
  399|  5.79k|    {
  400|  5.79k|        ListenerList listenerList;
  401|  5.79k|        {
  402|       |            // Lock the listener list and make a copy of it
  403|  5.79k|            OGRE_LOCK_MUTEX(mListenerListMutex);
  404|  5.79k|            listenerList = mListenerList;
  405|  5.79k|        }
  406|  5.79k|        for (auto& l : listenerList)
  ------------------
  |  Branch (406:22): [True: 0, False: 5.79k]
  ------------------
  407|      0|        {
  408|      0|            l->loadingComplete(this);
  409|      0|        }
  410|  5.79k|    }
_ZN4Ogre8Resource22_firePreparingCompleteEb:
  413|  1.32k|    {
  414|  1.32k|        ListenerList listenerList;
  415|  1.32k|        {
  416|       |            // Lock the listener list and make a copy of it
  417|  1.32k|            OGRE_LOCK_MUTEX(mListenerListMutex);
  418|  1.32k|            listenerList = mListenerList;
  419|  1.32k|        }
  420|  1.32k|        for (auto& l : listenerList)
  ------------------
  |  Branch (420:22): [True: 0, False: 1.32k]
  ------------------
  421|      0|        {
  422|      0|            l->preparingComplete(this);
  423|      0|        }
  424|  1.32k|    }
_ZN4Ogre8Resource22_fireUnloadingCompleteEv:
  427|  7.11k|    {
  428|  7.11k|        ListenerList listenerList;
  429|  7.11k|        {
  430|       |            // Lock the listener list and make a copy of it
  431|  7.11k|            OGRE_LOCK_MUTEX(mListenerListMutex);
  432|  7.11k|            listenerList = mListenerList;
  433|  7.11k|        }
  434|  7.11k|        for (auto& l : listenerList)
  ------------------
  |  Branch (434:22): [True: 0, False: 7.11k]
  ------------------
  435|      0|        {
  436|      0|            l->unloadingComplete(this);
  437|      0|        }
  438|  7.11k|    }

_ZN4Ogre20ResourceGroupManager12getSingletonEv:
   40|   277k|    {  
   41|       |        assert( msSingleton );  return ( *msSingleton );  
   42|   277k|    }
_ZN4Ogre20ResourceGroupManagerC2Ev:
   58|      1|        : mLoadingListener(0), mCurrentGroup(0)
   59|      1|    {
   60|       |        // Create the 'General' group
   61|      1|        createResourceGroup(DEFAULT_RESOURCE_GROUP_NAME, true); // the "General" group is synonymous to global pool
   62|       |        // Create the 'Internal' group
   63|      1|        createResourceGroup(INTERNAL_RESOURCE_GROUP_NAME, true);
   64|       |        // Create the 'Autodetect' group (only used for temp storage)
   65|      1|        createResourceGroup(AUTODETECT_RESOURCE_GROUP_NAME, true); // autodetect includes the global pool
   66|       |        // default world group to the default group
   67|      1|        mWorldGroupName = DEFAULT_RESOURCE_GROUP_NAME;
   68|      1|    }
_ZN4Ogre20ResourceGroupManager19createResourceGroupERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
   83|      3|    {
   84|      3|        LogManager::getSingleton().logMessage("Creating resource group " + name);
   85|      3|        if (getResourceGroup(name))
  ------------------
  |  Branch (85:13): [True: 0, False: 3]
  ------------------
   86|      0|        {
   87|      0|            OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, 
   88|      0|                "Resource group with name '" + name + "' already exists!", 
   89|      0|                "ResourceGroupManager::createResourceGroup");
   90|      0|        }
   91|      3|        ResourceGroup* grp = OGRE_NEW_T(ResourceGroup, MEMCATEGORY_RESOURCE)();
   92|      3|        grp->groupStatus = ResourceGroup::UNINITIALSED;
   93|      3|        grp->name = name;
   94|      3|        grp->inGlobalPool = inGlobalPool;
   95|      3|        grp->customStageCount = 0;
   96|       |
   97|      3|        OGRE_LOCK_AUTO_MUTEX;
   98|      3|        mResourceGroupMap.emplace(name, grp);
   99|      3|    }
_ZNK4Ogre20ResourceGroupManager16openResourceImplERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_8ResourceEb:
  515|  18.0k|    {
  516|  18.0k|        OgreAssert(!resourceName.empty(), "resourceName is empty string");
  ------------------
  |  Branch (516:9): [True: 0, False: 18.0k]
  ------------------
  517|  18.0k|        if(mLoadingListener)
  ------------------
  |  Branch (517:12): [True: 0, False: 18.0k]
  ------------------
  518|      0|        {
  519|      0|            DataStreamPtr stream = mLoadingListener->resourceLoading(resourceName, groupName, resourceBeingLoaded);
  520|      0|            if(stream)
  ------------------
  |  Branch (520:16): [True: 0, False: 0]
  ------------------
  521|      0|                return stream;
  522|      0|        }
  523|       |
  524|       |        // Try to find in resource index first
  525|  18.0k|        ResourceGroup* grp = getResourceGroup(groupName, throwOnFailure);
  526|  18.0k|        if (!grp)
  ------------------
  |  Branch (526:13): [True: 0, False: 18.0k]
  ------------------
  527|      0|        {
  528|       |            // we only get here if throwOnFailure is false
  529|      0|            return DataStreamPtr();
  530|      0|        }
  531|       |
  532|  18.0k|        Archive* pArch = resourceExists(grp, resourceName);
  533|       |
  534|  18.0k|        if (pArch == NULL && (searchGroupsIfNotFound ||
  ------------------
  |  Branch (534:13): [True: 18.0k, False: 0]
  |  Branch (534:31): [True: 0, False: 18.0k]
  ------------------
  535|  18.0k|            groupName == AUTODETECT_RESOURCE_GROUP_NAME || grp->inGlobalPool ||
  ------------------
  |  Branch (535:13): [True: 0, False: 18.0k]
  |  Branch (535:60): [True: 18.0k, False: 0]
  ------------------
  536|      0|            (!OGRE_RESOURCEMANAGER_STRICT && (groupName == DEFAULT_RESOURCE_GROUP_NAME))))
  ------------------
  |  Branch (536:14): [Folded, False: 0]
  |  Branch (536:46): [True: 0, False: 0]
  ------------------
  537|  18.0k|        {
  538|  18.0k|            std::pair<Archive*, ResourceGroup*> ret = resourceExistsInAnyGroupImpl(resourceName);
  539|       |
  540|  18.0k|            if(ret.second && resourceBeingLoaded && !ret.second->inGlobalPool) {
  ------------------
  |  Branch (540:16): [True: 0, False: 18.0k]
  |  Branch (540:30): [True: 0, False: 0]
  |  Branch (540:53): [True: 0, False: 0]
  ------------------
  541|      0|                resourceBeingLoaded->changeGroupOwnership(ret.second->name);
  542|      0|            }
  543|       |
  544|  18.0k|            pArch = ret.first;
  545|  18.0k|        }
  546|       |
  547|  18.0k|        if (pArch)
  ------------------
  |  Branch (547:13): [True: 0, False: 18.0k]
  ------------------
  548|      0|        {
  549|      0|            DataStreamPtr stream = pArch->open(resourceName);
  550|      0|            if (mLoadingListener)
  ------------------
  |  Branch (550:17): [True: 0, False: 0]
  ------------------
  551|      0|                mLoadingListener->resourceStreamOpened(resourceName, groupName, resourceBeingLoaded, stream);
  552|      0|            return stream;
  553|      0|        }
  554|       |
  555|  18.0k|        if(!throwOnFailure)
  ------------------
  |  Branch (555:12): [True: 0, False: 18.0k]
  ------------------
  556|      0|            return DataStreamPtr();
  557|       |
  558|  18.0k|        OGRE_EXCEPT(Exception::ERR_FILE_NOT_FOUND, "Cannot locate resource " + 
  559|  18.0k|            resourceName + " in resource group " + groupName + ".", 
  560|  18.0k|            "ResourceGroupManager::openResource");
  561|       |
  562|  18.0k|    }
_ZN4Ogre20ResourceGroupManager24_registerResourceManagerERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_15ResourceManagerE:
  702|      3|    {
  703|      3|        OGRE_LOCK_AUTO_MUTEX;
  704|       |
  705|      3|        LogManager::getSingleton().logMessage(
  706|      3|            "Registering ResourceManager for type " + resourceType);
  707|      3|        mResourceManagerMap[resourceType] = rm;
  708|      3|    }
_ZNK4Ogre20ResourceGroupManager22_notifyResourceCreatedERNS_9SharedPtrINS_8ResourceEEE:
  863|  10.0k|    {
  864|  10.0k|        if (mCurrentGroup && res->getGroup() == mCurrentGroup->name)
  ------------------
  |  Branch (864:13): [True: 0, False: 10.0k]
  |  Branch (864:30): [True: 0, False: 0]
  ------------------
  865|      0|        {
  866|       |            // Use current group (batch loading)
  867|      0|            addCreatedResource(res, *mCurrentGroup);
  868|      0|        }
  869|  10.0k|        else
  870|  10.0k|        {
  871|       |            // Find group
  872|  10.0k|            ResourceGroup* grp = getResourceGroup(res->getGroup());
  873|  10.0k|            if (grp)
  ------------------
  |  Branch (873:17): [True: 10.0k, False: 0]
  ------------------
  874|  10.0k|            {
  875|  10.0k|                addCreatedResource(res, *grp);
  876|  10.0k|            }
  877|  10.0k|        }
  878|       |
  879|  10.0k|        fireResourceCreated(res);
  880|  10.0k|    }
_ZNK4Ogre20ResourceGroupManager22_notifyResourceRemovedERKNS_9SharedPtrINS_8ResourceEEE:
  883|  7.11k|    {
  884|  7.11k|        fireResourceRemove(res);
  885|       |
  886|  7.11k|        if (mCurrentGroup && res->getGroup() == mCurrentGroup->name)
  ------------------
  |  Branch (886:13): [True: 0, False: 7.11k]
  |  Branch (886:30): [True: 0, False: 0]
  ------------------
  887|      0|        {
  888|       |            // Do nothing - we're batch unloading so list will be cleared
  889|      0|        }
  890|  7.11k|        else
  891|  7.11k|        {
  892|       |            // Find group
  893|  7.11k|            ResourceGroup* grp = getResourceGroup(res->getGroup());
  894|  7.11k|            if (grp)
  ------------------
  |  Branch (894:17): [True: 7.11k, False: 0]
  ------------------
  895|  7.11k|            {
  896|  7.11k|                            OGRE_LOCK_MUTEX(grp->OGRE_AUTO_MUTEX_NAME); // lock group mutex
  897|  7.11k|                ResourceGroup::LoadResourceOrderMap::iterator i = 
  898|  7.11k|                    grp->loadResourceOrderMap.find(
  899|  7.11k|                        res->getCreator()->getLoadingOrder());
  900|  7.11k|                if (i != grp->loadResourceOrderMap.end())
  ------------------
  |  Branch (900:21): [True: 7.11k, False: 0]
  ------------------
  901|  7.11k|                {
  902|       |                    // Iterate over the resource list and remove
  903|  7.11k|                    LoadUnloadResourceList& resList = i->second;
  904|  7.11k|                    for (LoadUnloadResourceList::iterator l = resList.begin();
  905|   498k|                        l != resList.end(); ++ l)
  ------------------
  |  Branch (905:25): [True: 498k, False: 0]
  ------------------
  906|   498k|                    {
  907|   498k|                        if ((*l).get() == res.get())
  ------------------
  |  Branch (907:29): [True: 7.11k, False: 491k]
  ------------------
  908|  7.11k|                        {
  909|       |                            // this is the one
  910|  7.11k|                            resList.erase(l);
  911|  7.11k|                            break;
  912|  7.11k|                        }
  913|   498k|                    }
  914|  7.11k|                }
  915|  7.11k|            }
  916|  7.11k|        }
  917|  7.11k|    }
_ZNK4Ogre20ResourceGroupManager18addCreatedResourceERNS_9SharedPtrINS_8ResourceEEERNS0_13ResourceGroupE:
  990|  10.0k|    {
  991|  10.0k|            OGRE_LOCK_MUTEX(grp.OGRE_AUTO_MUTEX_NAME);
  992|  10.0k|        Real order = res->getCreator()->getLoadingOrder();
  993|       |
  994|  10.0k|        ResourceGroup::LoadResourceOrderMap::iterator i = grp.loadResourceOrderMap.find(order);
  995|  10.0k|        LoadUnloadResourceList& loadList =
  996|  10.0k|            i == grp.loadResourceOrderMap.end() ? grp.loadResourceOrderMap[order] : i->second;
  ------------------
  |  Branch (996:13): [True: 3, False: 10.0k]
  ------------------
  997|       |
  998|  10.0k|        loadList.push_back(res);
  999|  10.0k|    }
_ZNK4Ogre20ResourceGroupManager16getResourceGroupERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
 1003|   267k|    {
 1004|   267k|        OGRE_LOCK_AUTO_MUTEX;
 1005|   267k|        ResourceGroupMap::const_iterator i = mResourceGroupMap.find(name);
 1006|       |
 1007|   267k|        if (i == mResourceGroupMap.end())
  ------------------
  |  Branch (1007:13): [True: 3, False: 267k]
  ------------------
 1008|      3|        {
 1009|      3|            if (throwOnFailure)
  ------------------
  |  Branch (1009:17): [True: 0, False: 3]
  ------------------
 1010|      3|                OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Cannot locate a resource group called '" + name + "'");
 1011|       |
 1012|      3|            return nullptr;
 1013|      3|        }
 1014|       |
 1015|   267k|        return i->second;
 1016|   267k|    }
_ZNK4Ogre20ResourceGroupManager19fireResourceCreatedERKNS_9SharedPtrINS_8ResourceEEE:
 1203|  10.0k|    {
 1204|  10.0k|        OGRE_LOCK_AUTO_MUTEX;
 1205|  10.0k|        for (auto l : mResourceGroupListenerList)
  ------------------
  |  Branch (1205:21): [True: 0, False: 10.0k]
  ------------------
 1206|      0|        {
 1207|      0|            l->resourceCreated(resource);
 1208|      0|        }
 1209|  10.0k|    }
_ZNK4Ogre20ResourceGroupManager18fireResourceRemoveERKNS_9SharedPtrINS_8ResourceEEE:
 1212|  7.11k|    {
 1213|  7.11k|        OGRE_LOCK_AUTO_MUTEX;
 1214|  7.11k|        for (auto l : mResourceGroupListenerList)
  ------------------
  |  Branch (1214:21): [True: 0, False: 7.11k]
  ------------------
 1215|      0|        {
 1216|      0|            l->resourceRemove(resource);
 1217|      0|        }
 1218|  7.11k|    }
_ZNK4Ogre20ResourceGroupManager14resourceExistsEPNS0_13ResourceGroupERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
 1317|  72.0k|    {
 1318|       |
 1319|  72.0k|            OGRE_LOCK_MUTEX(grp->OGRE_AUTO_MUTEX_NAME); // lock group mutex
 1320|       |
 1321|       |        // Try indexes first
 1322|  72.0k|        ResourceLocationIndex::iterator rit = grp->resourceIndexCaseSensitive.find(resourceName);
 1323|  72.0k|        if (rit != grp->resourceIndexCaseSensitive.end())
  ------------------
  |  Branch (1323:13): [True: 0, False: 72.0k]
  ------------------
 1324|      0|        {
 1325|       |            // Found in the index
 1326|      0|            return rit->second;
 1327|      0|        }
 1328|       |
 1329|       |#if !OGRE_RESOURCEMANAGER_STRICT
 1330|       |        // try case insensitive
 1331|       |        String lcResourceName = resourceName;
 1332|       |        StringUtil::toLowerCase(lcResourceName);
 1333|       |        rit = grp->resourceIndexCaseInsensitive.find(lcResourceName);
 1334|       |        if (rit != grp->resourceIndexCaseInsensitive.end())
 1335|       |        {
 1336|       |            // Found in the index
 1337|       |            return rit->second;
 1338|       |        }
 1339|       |
 1340|       |        // Search the hard way
 1341|       |        for (auto& li : grp->locationList)
 1342|       |        {
 1343|       |            if (li.archive->exists(resourceName))
 1344|       |            {
 1345|       |                return li.archive;
 1346|       |            }
 1347|       |        }
 1348|       |#endif
 1349|       |
 1350|  72.0k|        return NULL;
 1351|       |
 1352|  72.0k|    }
_ZNK4Ogre20ResourceGroupManager28resourceExistsInAnyGroupImplERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1374|  18.0k|    {
 1375|  18.0k|        OgreAssert(!filename.empty(), "resourceName is empty string");
  ------------------
  |  Branch (1375:9): [True: 0, False: 18.0k]
  ------------------
 1376|  18.0k|            OGRE_LOCK_AUTO_MUTEX;
 1377|       |
 1378|       |            // Iterate over resource groups and find
 1379|  18.0k|        for (const auto & i : mResourceGroupMap)
  ------------------
  |  Branch (1379:29): [True: 54.0k, False: 18.0k]
  ------------------
 1380|  54.0k|        {
 1381|  54.0k|            Archive* arch = resourceExists(i.second, filename);
 1382|  54.0k|            if (arch)
  ------------------
  |  Branch (1382:17): [True: 0, False: 54.0k]
  ------------------
 1383|      0|                return std::make_pair(arch, i.second);
 1384|  54.0k|        }
 1385|       |        // Not found
 1386|  18.0k|        return std::pair<Archive*, ResourceGroup*>();
 1387|  18.0k|    }
_ZNK4Ogre20ResourceGroupManager27isResourceGroupInGlobalPoolERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1462|   232k|    {
 1463|   232k|        return getResourceGroup(name, true)->inGlobalPool;
 1464|   232k|    }
_ZNK4Ogre20ResourceGroupManager18getLoadingListenerEv:
 1495|  10.0k|    {
 1496|  10.0k|        return mLoadingListener;
 1497|  10.0k|    }

_ZN4Ogre15ResourceManagerC2Ev:
   35|      3|        : mNextHandle(1), mMemoryUsage(0), mVerbose(true), mLoadOrder(0)
   36|      3|    {
   37|       |        // Init memory limit & usage
   38|      3|        mMemoryBudget = std::numeric_limits<unsigned long>::max();
   39|      3|    }
_ZN4Ogre15ResourceManager14createResourceERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
   53|  10.0k|    {
   54|  10.0k|        OgreAssert(!name.empty(), "resource name must not be empty");
  ------------------
  |  Branch (54:9): [True: 4, False: 10.0k]
  ------------------
   55|       |
   56|       |        // Call creation implementation
   57|  10.0k|        ResourcePtr ret = ResourcePtr(
   58|  10.0k|            createImpl(name, getNextHandle(), group, isManual, loader, params));
   59|  10.0k|        if (params)
  ------------------
  |  Branch (59:13): [True: 0, False: 10.0k]
  ------------------
   60|      0|            ret->setParameterList(*params);
   61|       |
   62|  10.0k|        addImpl(ret);
   63|       |        // Tell resource group manager
   64|  10.0k|        if(ret)
  ------------------
  |  Branch (64:12): [True: 10.0k, False: 0]
  ------------------
   65|  10.0k|            ResourceGroupManager::getSingleton()._notifyResourceCreated(ret);
   66|  10.0k|        return ret;
   67|       |
   68|  10.0k|    }
_ZN4Ogre15ResourceManager16createOrRetrieveERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
   75|  18.0k|    {
   76|       |        // Lock for the whole get / insert
   77|  18.0k|            OGRE_LOCK_AUTO_MUTEX;
   78|       |
   79|  18.0k|        ResourcePtr res = getResourceByName(name, group);
   80|  18.0k|        bool created = false;
   81|  18.0k|        if (!res)
  ------------------
  |  Branch (81:13): [True: 2.95k, False: 15.0k]
  ------------------
   82|  2.95k|        {
   83|  2.95k|            created = true;
   84|  2.95k|            res = createResource(name, group, isManual, loader, params);
   85|  2.95k|        }
   86|       |
   87|  18.0k|        return ResourceCreateOrRetrieveResult(res, created);
   88|  18.0k|    }
_ZN4Ogre15ResourceManager7prepareERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEEb:
   93|    194|    {
   94|    194|        ResourcePtr r = createOrRetrieve(name,group,isManual,loader,loadParams).first;
   95|       |        // ensure prepared
   96|    194|        r->prepare(backgroundThread);
   97|    194|        return r;
   98|    194|    }
_ZN4Ogre15ResourceManager4loadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEEb:
  103|  17.8k|    {
  104|  17.8k|        ResourcePtr r = createOrRetrieve(name,group,isManual,loader,loadParams).first;
  105|       |        // ensure loaded
  106|  17.8k|        r->load(backgroundThread);
  107|       |
  108|  17.8k|        return r;
  109|  17.8k|    }
_ZN4Ogre15ResourceManager7addImplERNS_9SharedPtrINS_8ResourceEEE:
  112|  10.0k|    {
  113|  10.0k|            OGRE_LOCK_AUTO_MUTEX;
  114|       |
  115|  10.0k|            std::pair<ResourceMap::iterator, bool> result;
  116|  10.0k|        if(ResourceGroupManager::getSingleton().isResourceGroupInGlobalPool(res->getGroup()))
  ------------------
  |  Branch (116:12): [True: 10.0k, False: 0]
  ------------------
  117|  10.0k|        {
  118|  10.0k|            result = mResources.emplace(res->getName(), res);
  119|  10.0k|        }
  120|      0|        else
  121|      0|        {
  122|       |            // we will create the group if it doesn't exists in our list
  123|      0|            auto resgroup = mResourcesWithGroup.emplace(res->getGroup(), ResourceMap()).first;
  124|      0|            result = resgroup->second.emplace(res->getName(), res);
  125|      0|        }
  126|       |
  127|       |        // Attempt to resolve the collision
  128|  10.0k|        ResourceLoadingListener* listener = ResourceGroupManager::getSingleton().getLoadingListener();
  129|  10.0k|        if (!result.second && listener)
  ------------------
  |  Branch (129:13): [True: 0, False: 10.0k]
  |  Branch (129:31): [True: 0, False: 0]
  ------------------
  130|      0|        {
  131|      0|            if(listener->resourceCollision(res.get(), this) == false)
  ------------------
  |  Branch (131:16): [True: 0, False: 0]
  ------------------
  132|      0|            {
  133|       |                // explicitly use previous instance and destroy current
  134|      0|                res.reset();
  135|      0|                return;
  136|      0|            }
  137|       |
  138|       |            // Try to do the addition again, no seconds attempts to resolve collisions are allowed
  139|      0|            if(ResourceGroupManager::getSingleton().isResourceGroupInGlobalPool(res->getGroup()))
  ------------------
  |  Branch (139:16): [True: 0, False: 0]
  ------------------
  140|      0|            {
  141|      0|                result = mResources.emplace(res->getName(), res);
  142|      0|            }
  143|      0|            else
  144|      0|            {
  145|      0|                auto resgroup = mResourcesWithGroup.emplace(res->getGroup(), ResourceMap()).first;
  146|      0|                result = resgroup->second.emplace(res->getName(), res);
  147|      0|            }
  148|      0|        }
  149|       |
  150|  10.0k|        if (!result.second)
  ------------------
  |  Branch (150:13): [True: 0, False: 10.0k]
  ------------------
  151|      0|        {
  152|      0|            OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, getResourceType()+" with the name " + res->getName() +
  153|      0|                " already exists.", "ResourceManager::add");
  154|      0|        }
  155|       |
  156|       |        // Insert the handle
  157|  10.0k|        std::pair<ResourceHandleMap::iterator, bool> resultHandle = mResourcesByHandle.emplace(res->getHandle(), res);
  158|  10.0k|        if (!resultHandle.second)
  ------------------
  |  Branch (158:13): [True: 0, False: 10.0k]
  ------------------
  159|      0|        {
  160|       |            OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, getResourceType()+" with the handle " +
  161|      0|                StringConverter::toString((long) (res->getHandle())) +
  162|      0|                " already exists.", "ResourceManager::add");
  163|      0|        }
  164|  10.0k|    }
_ZN4Ogre15ResourceManager10removeImplERKNS_9SharedPtrINS_8ResourceEEE:
  167|  7.11k|    {
  168|  7.11k|        OgreAssert(res, "attempting to remove nullptr");
  ------------------
  |  Branch (168:9): [True: 0, False: 7.11k]
  ------------------
  169|       |
  170|  7.11k|#if OGRE_RESOURCEMANAGER_STRICT
  171|  7.11k|        if (res->getCreator() != this)
  ------------------
  |  Branch (171:13): [True: 0, False: 7.11k]
  ------------------
  172|  7.11k|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Resource '" + res->getName() + "' was not created by the '" +
  173|  7.11k|                                                          getResourceType() + "' ResourceManager");
  174|  7.11k|#endif
  175|       |
  176|  7.11k|        OGRE_LOCK_AUTO_MUTEX;
  177|       |
  178|  7.11k|        if(ResourceGroupManager::getSingleton().isResourceGroupInGlobalPool(res->getGroup()))
  ------------------
  |  Branch (178:12): [True: 7.11k, False: 0]
  ------------------
  179|  7.11k|        {
  180|  7.11k|            ResourceMap::iterator nameIt = mResources.find(res->getName());
  181|  7.11k|            if (nameIt != mResources.end())
  ------------------
  |  Branch (181:17): [True: 7.11k, False: 0]
  ------------------
  182|  7.11k|            {
  183|  7.11k|                mResources.erase(nameIt);
  184|  7.11k|            }
  185|  7.11k|        }
  186|      0|        else
  187|      0|        {
  188|      0|            ResourceWithGroupMap::iterator groupIt = mResourcesWithGroup.find(res->getGroup());
  189|      0|            if (groupIt != mResourcesWithGroup.end())
  ------------------
  |  Branch (189:17): [True: 0, False: 0]
  ------------------
  190|      0|            {
  191|      0|                ResourceMap::iterator nameIt = groupIt->second.find(res->getName());
  192|      0|                if (nameIt != groupIt->second.end())
  ------------------
  |  Branch (192:21): [True: 0, False: 0]
  ------------------
  193|      0|                {
  194|      0|                    groupIt->second.erase(nameIt);
  195|      0|                }
  196|       |
  197|      0|                if (groupIt->second.empty())
  ------------------
  |  Branch (197:21): [True: 0, False: 0]
  ------------------
  198|      0|                {
  199|      0|                    mResourcesWithGroup.erase(groupIt);
  200|      0|                }
  201|      0|            }
  202|      0|        }
  203|       |
  204|  7.11k|        ResourceHandleMap::iterator handleIt = mResourcesByHandle.find(res->getHandle());
  205|  7.11k|        if (handleIt != mResourcesByHandle.end())
  ------------------
  |  Branch (205:13): [True: 7.11k, False: 0]
  ------------------
  206|  7.11k|        {
  207|  7.11k|            mResourcesByHandle.erase(handleIt);
  208|  7.11k|        }
  209|       |        // Tell resource group manager
  210|  7.11k|        ResourceGroupManager::getSingleton()._notifyResourceRemoved(res);
  211|  7.11k|    }
_ZN4Ogre15ResourceManager6removeERKNS_9SharedPtrINS_8ResourceEEE:
  298|  7.11k|    {
  299|  7.11k|        removeImpl(res);
  300|  7.11k|    }
_ZNK4Ogre15ResourceManager17getResourceByNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
  368|   215k|    {
  369|   215k|        OGRE_LOCK_AUTO_MUTEX;
  370|       |
  371|       |        // resource should be in global pool
  372|   215k|        bool isGlobal = ResourceGroupManager::getSingleton().isResourceGroupInGlobalPool(groupName);
  373|       |
  374|   215k|        if(isGlobal)
  ------------------
  |  Branch (374:12): [True: 215k, False: 0]
  ------------------
  375|   215k|        {
  376|   215k|            auto it = mResources.find(name);
  377|   215k|            if( it != mResources.end())
  ------------------
  |  Branch (377:17): [True: 15.0k, False: 199k]
  ------------------
  378|  15.0k|            {
  379|  15.0k|                return it->second;
  380|  15.0k|            }
  381|   215k|        }
  382|       |
  383|       |        // look in all grouped pools
  384|   199k|        if (groupName == ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME)
  ------------------
  |  Branch (384:13): [True: 0, False: 199k]
  ------------------
  385|      0|        {
  386|      0|            for (auto& r : mResourcesWithGroup)
  ------------------
  |  Branch (386:26): [True: 0, False: 0]
  ------------------
  387|      0|            {
  388|      0|                auto resMapIt = r.second.find(name);
  389|       |
  390|      0|                if( resMapIt != r.second.end())
  ------------------
  |  Branch (390:21): [True: 0, False: 0]
  ------------------
  391|      0|                {
  392|      0|                    return resMapIt->second;
  393|      0|                }
  394|      0|            }
  395|      0|        }
  396|   199k|        else if (!isGlobal)
  ------------------
  |  Branch (396:18): [True: 0, False: 199k]
  ------------------
  397|      0|        {
  398|       |            // look in the grouped pool
  399|      0|            auto itGroup = mResourcesWithGroup.find(groupName);
  400|      0|            if (itGroup != mResourcesWithGroup.end())
  ------------------
  |  Branch (400:17): [True: 0, False: 0]
  ------------------
  401|      0|            {
  402|      0|                auto it = itGroup->second.find(name);
  403|       |
  404|      0|                if( it != itGroup->second.end())
  ------------------
  |  Branch (404:21): [True: 0, False: 0]
  ------------------
  405|      0|                {
  406|      0|                    return it->second;
  407|      0|                }
  408|      0|            }
  409|       |
  410|       |#if !OGRE_RESOURCEMANAGER_STRICT
  411|       |            // fall back to global
  412|       |            auto it = mResources.find(name);
  413|       |            if( it != mResources.end())
  414|       |            {
  415|       |                return it->second;
  416|       |            }
  417|       |#endif
  418|      0|        }
  419|       |    
  420|   199k|        return ResourcePtr();
  421|   199k|    }
_ZN4Ogre15ResourceManager13getNextHandleEv:
  431|  10.0k|    {
  432|       |        // This is an atomic operation and hence needs no locking
  433|  10.0k|        return mNextHandle++;
  434|  10.0k|    }
_ZN4Ogre15ResourceManager10checkUsageEv:
  437|  5.79k|    {
  438|  5.79k|        if (getMemoryUsage() > mMemoryBudget)
  ------------------
  |  Branch (438:13): [True: 0, False: 5.79k]
  ------------------
  439|      0|        {
  440|      0|            OGRE_LOCK_AUTO_MUTEX;
  441|       |            // unload unreferenced resources until we are within our budget again
  442|      0|            ResourceMap::iterator i, iend;
  443|      0|            iend = mResources.end();
  444|      0|            for (i = mResources.begin(); i != iend && getMemoryUsage() > mMemoryBudget; ++i)
  ------------------
  |  Branch (444:42): [True: 0, False: 0]
  |  Branch (444:55): [True: 0, False: 0]
  ------------------
  445|      0|            {
  446|       |                // A use count of 3 means that only RGM and RM have references
  447|       |                // RGM has one (this one) and RM has 2 (by name and by handle)
  448|      0|                if (i->second.use_count() == ResourceGroupManager::RESOURCE_SYSTEM_NUM_REFERENCE_COUNTS)
  ------------------
  |  Branch (448:21): [True: 0, False: 0]
  ------------------
  449|      0|                {
  450|      0|                    Resource* res = i->second.get();
  451|      0|                    if (res->isReloadable())
  ------------------
  |  Branch (451:25): [True: 0, False: 0]
  ------------------
  452|      0|                    {
  453|      0|                        res->unload();
  454|      0|                    }
  455|      0|                }
  456|      0|            }
  457|      0|        }
  458|  5.79k|    }
_ZN4Ogre15ResourceManager21_notifyResourceLoadedEPNS_8ResourceE:
  466|  5.79k|    {
  467|  5.79k|        mMemoryUsage += res->getSize();
  468|  5.79k|        checkUsage();
  469|  5.79k|    }
_ZN4Ogre15ResourceManager23_notifyResourceUnloadedEPNS_8ResourceE:
  472|  5.79k|    {
  473|  5.79k|        mMemoryUsage -= res->getSize();
  474|  5.79k|    }

_ZN4Ogre4Root15getSingletonPtrEv:
   86|   151k|    {
   87|   151k|        return msSingleton;
   88|   151k|    }

_ZN4Ogre10SerializerC2Ev:
   36|  36.7k|        mVersion("[Serializer_v1.00]"), // Version number
   37|  36.7k|        mFlipEndian(false),
   38|  36.7k|        mReportChunkErrors(true)
   39|  36.7k|    {
   40|  36.7k|    }
_ZN4Ogre10SerializerD2Ev:
   44|  36.7k|    {
   45|  36.7k|    }
_ZN4Ogre10Serializer19determineEndiannessERKNS_9SharedPtrINS_10DataStreamEEE:
   48|  12.8k|    {
   49|  12.8k|        if (stream->tell() != 0)
  ------------------
  |  Branch (49:13): [True: 0, False: 12.8k]
  ------------------
   50|      0|        {
   51|      0|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
   52|      0|                "Can only determine the endianness of the input stream if it "
   53|      0|                "is at the start", "Serializer::determineEndianness");
   54|      0|        }
   55|       |                
   56|  12.8k|        uint16 dest;
   57|       |        // read header id manually (no conversion)
   58|  12.8k|        size_t actually_read = stream->read(&dest, sizeof(uint16));
   59|       |        // skip back
   60|  12.8k|        stream->skip(0 - (long)actually_read);
   61|  12.8k|        if (actually_read != sizeof(uint16))
  ------------------
  |  Branch (61:13): [True: 4, False: 12.8k]
  ------------------
   62|      4|        {
   63|       |            // end of file?
   64|      4|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
   65|      4|                        "Couldn't read 16 bit header value from input stream.",
   66|      4|                        "Serializer::determineEndianness");
   67|      4|        }
   68|  12.8k|        if (dest == HEADER_STREAM_ID)
  ------------------
  |  Branch (68:13): [True: 3.74k, False: 9.05k]
  ------------------
   69|  3.74k|        {
   70|  3.74k|            mFlipEndian = false;
   71|  3.74k|        }
   72|  9.05k|        else if (dest == OTHER_ENDIAN_HEADER_STREAM_ID)
  ------------------
  |  Branch (72:18): [True: 9.01k, False: 45]
  ------------------
   73|  9.01k|        {
   74|  9.01k|            mFlipEndian = true;
   75|  9.01k|        }
   76|     45|        else
   77|     45|        {
   78|       |            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
   79|     45|                "Header chunk didn't match either endian: Corrupted stream?",
   80|     45|                "Serializer::determineEndianness");
   81|     45|        }
   82|  12.8k|    }
_ZN4Ogre10Serializer14readFileHeaderERKNS_9SharedPtrINS_10DataStreamEEE:
  233|  5.68k|    {
  234|  5.68k|        unsigned short headerID;
  235|       |        
  236|       |        // Read header ID
  237|  5.68k|        readShorts(stream, &headerID, 1);
  238|       |        
  239|  5.68k|        if (headerID == HEADER_STREAM_ID)
  ------------------
  |  Branch (239:13): [True: 5.68k, False: 0]
  ------------------
  240|  5.68k|        {
  241|       |            // Read version
  242|  5.68k|            String ver = readString(stream);
  243|  5.68k|            if (ver != mVersion)
  ------------------
  |  Branch (243:17): [True: 0, False: 5.68k]
  ------------------
  244|      0|            {
  245|      0|                OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, 
  246|      0|                    "Invalid file: version incompatible, file reports " + String(ver) +
  247|      0|                    " Serializer is version " + mVersion,
  248|      0|                    "Serializer::readFileHeader");
  249|      0|            }
  250|  5.68k|        }
  251|      0|        else
  252|      0|        {
  253|      0|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Invalid file: no header", 
  254|      0|                "Serializer::readFileHeader");
  255|      0|        }
  256|       |
  257|  5.68k|    }
_ZN4Ogre10Serializer9readChunkERKNS_9SharedPtrINS_10DataStreamEEE:
  260|   964k|    {
  261|   964k|        size_t pos = stream->tell();
  262|   964k|        unsigned short id;
  263|   964k|        readShorts(stream, &id, 1);
  264|       |        
  265|   964k|        readInts(stream, &mCurrentstreamLen, 1);
  266|       |
  267|   964k|        if (!stream->eof())
  ------------------
  |  Branch (267:13): [True: 958k, False: 6.06k]
  ------------------
  268|   958k|        {
  269|       |            // chunk size cant be smaller than the header size, and must fit within the stream
  270|   958k|            if (mCurrentstreamLen < calcChunkHeaderSize())
  ------------------
  |  Branch (270:17): [True: 624, False: 957k]
  ------------------
  271|   958k|                OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Corrupt chunk length");
  272|       |
  273|   957k|            if (pos + mCurrentstreamLen > stream->size())
  ------------------
  |  Branch (273:17): [True: 41.8k, False: 915k]
  ------------------
  274|  41.8k|            {
  275|  41.8k|                if (mReportChunkErrors)
  ------------------
  |  Branch (275:21): [True: 548, False: 41.3k]
  ------------------
  276|  41.8k|                    OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Corrupt chunk length");
  277|       |
  278|       |                // legacy exporters wrote chunk sizes that do not match the data they wrote.
  279|       |                // all reads are still bounded by the stream, so just clamp the chunk end.
  280|  41.3k|                LogManager::getSingleton().stream(LML_WARNING)
  281|  41.3k|                    << "Chunk " << id << " in '" << stream->getName()
  282|  41.3k|                    << "' extends past the end of the stream, clamping to stream size";
  283|  41.3k|                mCurrentstreamLen = static_cast<uint32>(stream->size() - pos);
  284|  41.3k|            }
  285|   957k|        }
  286|       |
  287|       |#if OGRE_SERIALIZER_VALIDATE_CHUNKSIZE
  288|       |        if (!mChunkSizeStack.empty() && !stream->eof()){
  289|       |            if (pos != static_cast<size_t>(mChunkSizeStack.back()) && mReportChunkErrors){
  290|       |                LogManager::getSingleton().logMessage("Corrupted chunk detected! Stream name: '" + stream->getName() + "' Chunk id: " + StringConverter::toString(id));
  291|       |            }
  292|       |            mChunkSizeStack.back() = pos + mCurrentstreamLen;
  293|       |        }
  294|       |#endif
  295|   962k|        return id;
  296|   964k|    }
_ZN4Ogre10Serializer9readBoolsERKNS_9SharedPtrINS_10DataStreamEEEPbm:
  299|   302M|    {
  300|   302M|        static_assert(sizeof(bool) == 1, "add conversion to char for your platform");
  301|   302M|        stream->read(pDest, sizeof(bool) * count);
  302|       |        // Normalize raw bytes to canonical bool values (0 or 1).
  303|       |        // A non-zero byte that is not exactly 1 can cause miscompile bugs later
  304|   604M|        for (size_t i = 0; i < count; ++i)
  ------------------
  |  Branch (304:28): [True: 302M, False: 302M]
  ------------------
  305|   302M|        {
  306|   302M|            uint8_t raw;
  307|   302M|            memcpy(&raw, &pDest[i], 1);
  308|   302M|            pDest[i] = (raw != 0);
  309|   302M|        }
  310|   302M|    }
_ZN4Ogre10Serializer10readFloatsERKNS_9SharedPtrINS_10DataStreamEEEPfm:
  313|  59.3k|    {
  314|  59.3k|        stream->read(pDest, sizeof(float) * count);
  315|  59.3k|        flipFromLittleEndian(pDest, sizeof(float), count);
  316|  59.3k|    }
_ZN4Ogre10Serializer10readShortsERKNS_9SharedPtrINS_10DataStreamEEEPtm:
  334|  1.28M|    {
  335|  1.28M|        stream->read(pDest, sizeof(unsigned short) * count);
  336|  1.28M|        flipFromLittleEndian(pDest, sizeof(unsigned short), count);
  337|  1.28M|    }
_ZN4Ogre10Serializer8readIntsERKNS_9SharedPtrINS_10DataStreamEEEPjm:
  340|   907M|    {
  341|   907M|        stream->read(pDest, sizeof(uint32) * count);
  342|   907M|        flipFromLittleEndian(pDest, sizeof(uint32), count);
  343|   907M|    }
_ZN4Ogre10Serializer10readStringERKNS_9SharedPtrINS_10DataStreamEEE:
  346|   278k|    {
  347|   278k|        return stream->getLine(false);
  348|   278k|    }
_ZN4Ogre10Serializer10readObjectERKNS_9SharedPtrINS_10DataStreamEEERNS_6VectorILi3EfEE:
  367|  2.11k|    {
  368|  2.11k|        readFloats(stream, pDest.ptr(), 3);
  369|  2.11k|    }
_ZN4Ogre10Serializer10readObjectERKNS_9SharedPtrINS_10DataStreamEEERNS_10QuaternionE:
  372|  1.82k|    {
  373|  1.82k|        float tmp[4];
  374|  1.82k|        readFloats(stream, tmp, 4);
  375|  1.82k|        pDest.x = tmp[0];
  376|  1.82k|        pDest.y = tmp[1];
  377|  1.82k|        pDest.z = tmp[2];
  378|  1.82k|        pDest.w = tmp[3];
  379|  1.82k|    }
_ZN4Ogre10Serializer20flipFromLittleEndianEPvmm:
  392|   908M|    {
  393|   908M|        if(mFlipEndian)
  ------------------
  |  Branch (393:12): [True: 908M, False: 213k]
  ------------------
  394|   908M|        {
  395|   908M|	        Bitwise::bswapChunks(pData, size, count);
  396|   908M|        }
  397|   908M|    }
_ZN4Ogre10Serializer14pushInnerChunkERKNS_9SharedPtrINS_10DataStreamEEE:
  400|   447k|    {
  401|       |#if OGRE_SERIALIZER_VALIDATE_CHUNKSIZE
  402|       |        mChunkSizeStack.push_back(stream->tell());
  403|       |#endif
  404|   447k|    }
_ZN4Ogre10Serializer20backpedalChunkHeaderERKNS_9SharedPtrINS_10DataStreamEEE:
  406|   406k|    {
  407|   406k|        if (!stream->eof()){
  ------------------
  |  Branch (407:13): [True: 406k, False: 0]
  ------------------
  408|   406k|            stream->skip(-(int)calcChunkHeaderSize());
  409|   406k|        }
  410|       |#if OGRE_SERIALIZER_VALIDATE_CHUNKSIZE
  411|       |        mChunkSizeStack.back() = stream->tell();
  412|       |#endif
  413|   406k|    }
_ZN4Ogre10Serializer13popInnerChunkERKNS_9SharedPtrINS_10DataStreamEEE:
  415|   436k|    {
  416|       |#if OGRE_SERIALIZER_VALIDATE_CHUNKSIZE
  417|       |        if (!mChunkSizeStack.empty()){
  418|       |            size_t pos = stream->tell();
  419|       |            if (pos != static_cast<size_t>(mChunkSizeStack.back()) && !stream->eof() && mReportChunkErrors){
  420|       |                LogManager::getSingleton().logMessage("Corrupted chunk detected! Stream name: " + stream->getName());
  421|       |            }
  422|       |
  423|       |            mChunkSizeStack.pop_back();
  424|       |        }
  425|       |#endif
  426|   436k|    }

_ZN4Ogre8SkeletonC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE:
   49|  4.27k|        : Resource(creator, name, handle, group, isManual, loader), 
   50|  4.27k|        mBlendState(ANIMBLEND_AVERAGE)
   51|       |        // set animation blending to weighted, not cumulative
   52|  4.27k|    {
   53|  4.27k|        if (createParamDictionary("Skeleton"))
  ------------------
  |  Branch (53:13): [True: 1, False: 4.27k]
  ------------------
   54|      1|        {
   55|       |            // no custom params
   56|      1|        }
   57|  4.27k|    }
_ZN4Ogre8SkeletonD2Ev:
   60|  1.32k|    {
   61|       |        // have to call this here reather than in Resource destructor
   62|       |        // since calling virtual methods in base destructors causes crash
   63|  1.32k|        unload(); 
   64|  1.32k|    }
_ZN4Ogre8Skeleton11prepareImplEv:
   67|  18.0k|    {
   68|  18.0k|        SkeletonSerializer serializer;
   69|       |
   70|  18.0k|        if (getCreator()->getVerbose())
  ------------------
  |  Branch (70:13): [True: 18.0k, False: 0]
  ------------------
   71|  18.0k|            LogManager::getSingleton().stream() << "Skeleton: Loading " << mName;
   72|       |
   73|  18.0k|        DataStreamPtr stream = ResourceGroupManager::getSingleton().openResource(mName, mGroup, this);
   74|       |
   75|  18.0k|        serializer.importSkeleton(stream, this);
   76|       |
   77|       |        // Load any linked skeletons
   78|  18.0k|        for (auto& s : mLinkedSkeletonAnimSourceList)
  ------------------
  |  Branch (78:22): [True: 0, False: 18.0k]
  ------------------
   79|      0|        {
   80|      0|            s.pSkeleton = static_pointer_cast<Skeleton>(
   81|      0|                SkeletonManager::getSingleton().prepare(s.skeletonName, mGroup));
   82|      0|        }
   83|  18.0k|    }
_ZN4Ogre8Skeleton13unprepareImplEv:
   86|  19.3k|    {
   87|       |        // destroy bones
   88|  19.3k|        for (auto *b : mBoneList)
  ------------------
  |  Branch (88:22): [True: 756, False: 19.3k]
  ------------------
   89|    756|        {
   90|    756|            OGRE_DELETE b;
   91|    756|        }
   92|  19.3k|        mBoneList.clear();
   93|  19.3k|        mBoneListByName.clear();
   94|  19.3k|        mRootBones.clear();
   95|  19.3k|        mManualBones.clear();
   96|  19.3k|        mManualBonesDirty = false;
   97|       |
   98|       |        // Destroy animations
   99|  19.3k|        for (auto& ai : mAnimationsList)
  ------------------
  |  Branch (99:23): [True: 2.47k, False: 19.3k]
  ------------------
  100|  2.47k|        {
  101|  2.47k|            OGRE_DELETE ai.second;
  102|  2.47k|        }
  103|  19.3k|        mAnimationsList.clear();
  104|       |
  105|       |        // Remove all linked skeletons
  106|  19.3k|        mLinkedSkeletonAnimSourceList.clear();
  107|  19.3k|    }
_ZN4Ogre8Skeleton10createBoneERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEt:
  125|    764|    {
  126|    764|        OgreAssert(handle < OGRE_MAX_NUM_BONES, "Exceeded the maximum number of bones per skeleton");
  ------------------
  |  Branch (126:9): [True: 0, False: 764]
  ------------------
  127|       |        // Check handle not used
  128|    764|        if (handle < mBoneList.size() && mBoneList[handle] != NULL)
  ------------------
  |  Branch (128:13): [True: 5, False: 759]
  |  Branch (128:42): [True: 5, False: 0]
  ------------------
  129|      5|        {
  130|      5|            OGRE_EXCEPT(
  131|      5|                Exception::ERR_DUPLICATE_ITEM,
  132|      5|                "A bone with the handle " + StringConverter::toString(handle) + " already exists",
  133|      5|                "Skeleton::createBone" );
  134|      5|        }
  135|       |        // Check name not used
  136|    759|        if (mBoneListByName.find(name) != mBoneListByName.end())
  ------------------
  |  Branch (136:13): [True: 3, False: 756]
  ------------------
  137|      3|        {
  138|      3|            OGRE_EXCEPT(
  139|      3|                Exception::ERR_DUPLICATE_ITEM,
  140|      3|                "A bone with the name " + name + " already exists",
  141|      3|                "Skeleton::createBone" );
  142|      3|        }
  143|    756|        Bone* ret = OGRE_NEW Bone(name, handle, this);
  144|    756|        if (mBoneList.size() <= handle)
  ------------------
  |  Branch (144:13): [True: 756, False: 0]
  ------------------
  145|    756|        {
  146|    756|            mBoneList.resize(handle+1);
  147|    756|        }
  148|    756|        mBoneList[handle] = ret;
  149|    756|        mBoneListByName[name] = ret;
  150|    756|        return ret;
  151|    759|    }
_ZN4Ogre8Skeleton14setBindingPoseEv:
  223|    725|    {
  224|       |        // Update the derived transforms
  225|    725|        _updateTransforms();
  226|       |
  227|    725|        for (auto *b : mBoneList)
  ------------------
  |  Branch (227:22): [True: 650, False: 725]
  ------------------
  228|    650|        {            
  229|    650|            b->setBindingPose();
  230|    650|        }
  231|    725|    }
_ZN4Ogre8Skeleton15createAnimationERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEf:
  243|  2.48k|    {
  244|       |        // Check name not used
  245|  2.48k|        if (mAnimationsList.find(name) != mAnimationsList.end())
  ------------------
  |  Branch (245:13): [True: 7, False: 2.47k]
  ------------------
  246|      7|        {
  247|      7|            OGRE_EXCEPT(
  248|      7|                Exception::ERR_DUPLICATE_ITEM,
  249|      7|                "An animation with the name " + name + " already exists",
  250|      7|                "Skeleton::createAnimation");
  251|      7|        }
  252|       |
  253|  2.47k|        Animation* ret = OGRE_NEW Animation(name, length);
  254|  2.47k|        ret->_notifyContainer(this);
  255|       |
  256|       |        // Add to list
  257|  2.47k|        mAnimationsList[name] = ret;
  258|       |
  259|  2.47k|        return ret;
  260|       |
  261|  2.48k|    }
_ZN4Ogre8Skeleton17_updateTransformsEv:
  548|    725|    {
  549|    725|        for (auto *b : mRootBones)
  ------------------
  |  Branch (549:22): [True: 0, False: 725]
  ------------------
  550|      0|        {
  551|      0|            b->_update(true, false);
  552|      0|        }
  553|    725|        mManualBonesDirty = false;
  554|    725|    }
_ZN4Ogre8Skeleton32addLinkedSkeletonAnimationSourceERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEf:
  591|    194|    {
  592|       |        // Check not already linked
  593|    194|        for (auto& l : mLinkedSkeletonAnimSourceList)
  ------------------
  |  Branch (593:22): [True: 0, False: 194]
  ------------------
  594|      0|        {
  595|      0|            if (skelName == l.skeletonName)
  ------------------
  |  Branch (595:17): [True: 0, False: 0]
  ------------------
  596|      0|                return; // don't bother
  597|      0|        }
  598|       |
  599|    194|        if (isPrepared() || isLoaded())
  ------------------
  |  Branch (599:13): [True: 194, False: 0]
  |  Branch (599:29): [True: 0, False: 0]
  ------------------
  600|    194|        {
  601|       |            // Load immediately
  602|    194|            SkeletonPtr skelPtr = static_pointer_cast<Skeleton>(
  603|    194|                SkeletonManager::getSingleton().prepare(skelName, mGroup));
  604|    194|            mLinkedSkeletonAnimSourceList.push_back(
  605|    194|                LinkedSkeletonAnimationSource(skelName, scale, skelPtr));
  606|       |
  607|    194|        }
  608|      0|        else
  609|      0|        {
  610|       |            // Load later
  611|      0|            mLinkedSkeletonAnimSourceList.push_back(
  612|      0|                LinkedSkeletonAnimationSource(skelName, scale));
  613|      0|        }
  614|       |
  615|    194|    }

_ZN4Ogre15SkeletonManager12getSingletonEv:
   40|  20.6k|    {  
   41|       |        assert( msSingleton );  return ( *msSingleton );  
   42|  20.6k|    }
_ZN4Ogre15SkeletonManagerC2Ev:
   45|      1|    {
   46|      1|        mLoadOrder = 300.0f;
   47|      1|        mResourceType = "Skeleton";
   48|       |
   49|      1|        ResourceGroupManager::getSingleton()._registerResourceManager(mResourceType, this);
   50|      1|    }
_ZN4Ogre15SkeletonManager6createERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
   60|  1.32k|    {
   61|  1.32k|        return static_pointer_cast<Skeleton>(createResource(name,group,isManual,loader,createParams));
   62|  1.32k|    }
_ZN4Ogre15SkeletonManager10createImplERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmS9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
   72|  4.27k|    {
   73|       |        return OGRE_NEW Skeleton(this, name, handle, group, isManual, loader);
   74|  4.27k|    }

_ZN4Ogre18SkeletonSerializerC2Ev:
   42|  19.3k|    {
   43|       |        // Version number
   44|       |        // NB changed to include bone names in 1.1
   45|  19.3k|        mVersion = "[Unknown]";
   46|  19.3k|    }
_ZN4Ogre18SkeletonSerializer14importSkeletonERNS_9SharedPtrINS_10DataStreamEEEPNS_8SkeletonE:
  105|  1.32k|    {
  106|       |        // Determine endianness (must be the first thing we do!)
  107|  1.32k|        determineEndianness(stream);
  108|       |
  109|       |        // Check header
  110|  1.32k|        unsigned short headerID;
  111|  1.32k|        readShorts(stream, &headerID, 1);
  112|  1.32k|        if (headerID != HEADER_STREAM_ID_EXT)
  ------------------
  |  Branch (112:13): [True: 0, False: 1.32k]
  ------------------
  113|      0|        {
  114|      0|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "File header not found",
  115|      0|                "SkeletonSerializer::importSkeleton");
  116|      0|        }
  117|       |
  118|       |        // Read version
  119|  1.32k|        String ver = readString(stream);
  120|  1.32k|        if ((ver != "[Serializer_v1.10]") &&
  ------------------
  |  Branch (120:13): [True: 1.21k, False: 107]
  ------------------
  121|  1.21k|            (ver != "[Serializer_v1.80]"))
  ------------------
  |  Branch (121:13): [True: 116, False: 1.09k]
  ------------------
  122|    116|        {
  123|    116|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
  124|    116|                "Invalid file: version incompatible, file reports " + String(ver),
  125|    116|                "SkeletonSerializer::importSkeleton");
  126|    116|        }
  127|  1.20k|        mVersion = ver;
  128|       |
  129|  1.20k|        pushInnerChunk(stream);
  130|  1.20k|        unsigned short streamID = readChunk(stream);
  131|       |
  132|  4.97k|        while(!stream->eof())
  ------------------
  |  Branch (132:15): [True: 4.11k, False: 858]
  ------------------
  133|  4.11k|        {
  134|  4.11k|            switch (streamID)
  135|  4.11k|            {
  136|    249|            case SKELETON_BLENDMODE:
  ------------------
  |  Branch (136:13): [True: 249, False: 3.86k]
  ------------------
  137|    249|            {
  138|       |                // Optional blend mode
  139|    249|                uint16 blendMode;
  140|    249|                readShorts(stream, &blendMode, 1);
  141|    249|                pSkel->setBlendMode(static_cast<SkeletonAnimationBlendMode>(blendMode));
  142|    249|                break;
  143|      0|            }
  144|    787|            case SKELETON_BONE:
  ------------------
  |  Branch (144:13): [True: 787, False: 3.32k]
  ------------------
  145|    787|                readBone(stream, pSkel);
  146|    787|                break;
  147|     50|            case SKELETON_BONE_PARENT:
  ------------------
  |  Branch (147:13): [True: 50, False: 4.06k]
  ------------------
  148|     50|                readBoneParent(stream, pSkel);
  149|     50|                break;
  150|  2.48k|            case SKELETON_ANIMATION:
  ------------------
  |  Branch (150:13): [True: 2.48k, False: 1.63k]
  ------------------
  151|  2.48k|                readAnimation(stream, pSkel);
  152|  2.48k|                break;
  153|    194|            case SKELETON_ANIMATION_LINK:
  ------------------
  |  Branch (153:13): [True: 194, False: 3.92k]
  ------------------
  154|    194|                readSkeletonAnimationLink(stream, pSkel);
  155|    194|                break;
  156|    354|            default:
  ------------------
  |  Branch (156:13): [True: 354, False: 3.76k]
  ------------------
  157|    354|                break;
  158|  4.11k|            }
  159|       |
  160|  3.76k|            streamID = readChunk(stream);
  161|  3.76k|        }
  162|       |        // Assume bones are stored in the binding pose
  163|    858|        pSkel->setBindingPose();
  164|    858|        popInnerChunk(stream);
  165|       |
  166|    858|    }
_ZN4Ogre18SkeletonSerializer24calcBoneSizeWithoutScaleEPKNS_8SkeletonEPKNS_4BoneE:
  337|    756|    {
  338|    756|        size_t size = SSTREAM_OVERHEAD_SIZE;
  339|       |
  340|       |        // TODO: Add this for next skeleton format!
  341|       |        // Currently it is broken, because to determine that we have scale, it will compare chunk size.
  342|       |        //size += calcStringSize(pBone->getName());
  343|       |
  344|       |        // handle
  345|    756|        size += sizeof(unsigned short);
  346|       |
  347|       |        // position
  348|    756|        size += sizeof(float) * 3;
  349|       |
  350|       |        // orientation
  351|    756|        size += sizeof(float) * 4;
  352|       |
  353|    756|        return size;
  354|    756|    }
_ZN4Ogre18SkeletonSerializer28calcKeyFrameSizeWithoutScaleEPKNS_8SkeletonEPKNS_17TransformKeyFrameE:
  432|  1.06k|    {
  433|  1.06k|        size_t size = SSTREAM_OVERHEAD_SIZE;
  434|       |
  435|       |        // float time                    : The time position (seconds)
  436|  1.06k|        size += sizeof(float);
  437|       |        // Quaternion rotate            : Rotation to apply at this keyframe
  438|  1.06k|        size += sizeof(float) * 4;
  439|       |        // Vector3 translate            : Translation to apply at this keyframe
  440|  1.06k|        size += sizeof(float) * 3;
  441|       |
  442|  1.06k|        return size;
  443|  1.06k|    }
_ZN4Ogre18SkeletonSerializer8readBoneERNS_9SharedPtrINS_10DataStreamEEEPNS_8SkeletonE:
  446|    787|    {
  447|       |        // char* name
  448|    787|        String name = readString(stream);
  449|       |        // unsigned short handle            : handle of the bone, should be contiguous & start at 0
  450|    787|        unsigned short handle;
  451|    787|        readShorts(stream, &handle, 1);
  452|       |
  453|    787|        if (handle > pSkel->getNumBones())
  ------------------
  |  Branch (453:13): [True: 23, False: 764]
  ------------------
  454|    787|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Bone handles must be contiguous");
  455|       |
  456|       |        // Create new bone
  457|    764|        Bone* pBone = pSkel->createBone(name, handle);
  458|       |
  459|       |        // Vector3 position                 : position of this bone relative to parent 
  460|    764|        Vector3 pos;
  461|    764|        readObject(stream, pos);
  462|    764|        pBone->setPosition(pos);
  463|       |        // Quaternion orientation           : orientation of this bone relative to parent 
  464|    764|        Quaternion q;
  465|    764|        readObject(stream, q);
  466|    764|        pBone->setOrientation(q);
  467|       |
  468|       |#if OGRE_SERIALIZER_VALIDATE_CHUNKSIZE
  469|       |        // Hack to fix chunk size validation:
  470|       |        mChunkSizeStack.back() += calcStringSize(name);
  471|       |#endif
  472|       |        // TODO: don't depend on mCurrentstreamLen in next skeleton format!
  473|       |        // Currently we use wrong chunk sizes, but we can't fix it, because we depend on mCurrentstreamLen
  474|       |        // Do we have scale?
  475|    764|        if (mCurrentstreamLen > calcBoneSizeWithoutScale(pSkel, pBone))
  ------------------
  |  Branch (475:13): [True: 23, False: 741]
  ------------------
  476|     23|        {
  477|     23|            Vector3 scale;
  478|     23|            readObject(stream, scale);
  479|     23|            pBone->setScale(scale);
  480|     23|        }
  481|       |        
  482|    764|    }
_ZN4Ogre18SkeletonSerializer14readBoneParentERNS_9SharedPtrINS_10DataStreamEEEPNS_8SkeletonE:
  485|     50|    {
  486|       |        // All bones have been created by this point
  487|     50|        Bone *child, *parent;
  488|     50|        unsigned short childHandle, parentHandle;
  489|       |
  490|       |        // unsigned short handle             : child bone
  491|     50|        readShorts(stream, &childHandle, 1);
  492|       |        // unsigned short parentHandle   : parent bone
  493|     50|        readShorts(stream, &parentHandle, 1);
  494|       |
  495|     50|        auto numBones = pSkel->getBones().size();
  496|     50|        if (parentHandle >= numBones || childHandle >= numBones)
  ------------------
  |  Branch (496:13): [True: 20, False: 30]
  |  Branch (496:41): [True: 12, False: 18]
  ------------------
  497|     50|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Bone handle out of range");
  498|       |
  499|     18|        if (childHandle == parentHandle)
  ------------------
  |  Branch (499:13): [True: 4, False: 14]
  ------------------
  500|     18|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "A bone cannot be parent of itself");
  501|       |
  502|       |        // Find bones
  503|     14|        parent = pSkel->getBone(parentHandle);
  504|     14|        child = pSkel->getBone(childHandle);
  505|       |
  506|       |        // attach
  507|     14|        parent->addChild(child);
  508|       |
  509|     14|    }
_ZN4Ogre18SkeletonSerializer13readAnimationERNS_9SharedPtrINS_10DataStreamEEEPNS_8SkeletonE:
  512|  2.48k|    {
  513|       |        // char* name                       : Name of the animation
  514|  2.48k|        String name;
  515|  2.48k|        name = readString(stream);
  516|       |        // float length                      : Length of the animation in seconds
  517|  2.48k|        float len;
  518|  2.48k|        readFloats(stream, &len, 1);
  519|       |
  520|  2.48k|        Animation *pAnim = pSkel->createAnimation(name, len);
  521|       |        // Read all tracks
  522|  2.48k|        if (!stream->eof())
  ------------------
  |  Branch (522:13): [True: 2.23k, False: 246]
  ------------------
  523|  2.23k|        {
  524|  2.23k|            pushInnerChunk(stream);
  525|  2.23k|            unsigned short streamID = readChunk(stream);
  526|       |            // Optional base info is possible
  527|  2.23k|            if (streamID == SKELETON_ANIMATION_BASEINFO)
  ------------------
  |  Branch (527:17): [True: 119, False: 2.11k]
  ------------------
  528|    119|            {
  529|       |                // char baseAnimationName
  530|    119|                String baseAnimName = readString(stream);
  531|       |                // float baseKeyFrameTime
  532|    119|                float baseKeyTime;
  533|    119|                readFloats(stream, &baseKeyTime, 1);
  534|       |                
  535|    119|                pAnim->setUseBaseKeyFrame(true, baseKeyTime, baseAnimName);
  536|       |                
  537|    119|                if (!stream->eof())
  ------------------
  |  Branch (537:21): [True: 112, False: 7]
  ------------------
  538|    112|                {
  539|       |                    // Get next stream
  540|    112|                    streamID = readChunk(stream);
  541|    112|                }
  542|    119|            }
  543|       |            
  544|  2.46k|            while(streamID == SKELETON_ANIMATION_TRACK && !stream->eof())
  ------------------
  |  Branch (544:19): [True: 284, False: 2.18k]
  |  Branch (544:59): [True: 234, False: 50]
  ------------------
  545|    234|            {
  546|    234|                readAnimationTrack(stream, pAnim, pSkel);
  547|       |
  548|    234|                if (!stream->eof())
  ------------------
  |  Branch (548:21): [True: 154, False: 80]
  ------------------
  549|    154|                {
  550|       |                    // Get next stream
  551|    154|                    streamID = readChunk(stream);
  552|    154|                }
  553|    234|            }
  554|  2.23k|            if (!stream->eof())
  ------------------
  |  Branch (554:17): [True: 2.04k, False: 188]
  ------------------
  555|  2.04k|            {
  556|       |                // Backpedal back to start of this stream if we've found a non-track
  557|  2.04k|                backpedalChunkHeader(stream);
  558|  2.04k|            }
  559|  2.23k|            popInnerChunk(stream);
  560|  2.23k|        }
  561|  2.48k|    }
_ZN4Ogre18SkeletonSerializer18readAnimationTrackERNS_9SharedPtrINS_10DataStreamEEEPNS_9AnimationEPNS_8SkeletonE:
  565|    234|    {
  566|       |        // unsigned short boneIndex     : Index of bone to apply to
  567|    234|        unsigned short boneHandle;
  568|    234|        readShorts(stream, &boneHandle, 1);
  569|       |
  570|       |        // Find bone
  571|    234|        if (boneHandle >= pSkel->getBones().size())
  ------------------
  |  Branch (571:13): [True: 19, False: 215]
  ------------------
  572|    234|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Animation track boneHandle out of range");
  573|    215|        Bone* targetBone = pSkel->getBone(boneHandle);
  574|       |
  575|       |        // Create track
  576|    215|        NodeAnimationTrack* pTrack = anim->createNodeTrack(boneHandle, targetBone);
  577|       |
  578|       |        // Keep looking for nested keyframes
  579|    215|        if (!stream->eof())
  ------------------
  |  Branch (579:13): [True: 209, False: 6]
  ------------------
  580|    209|        {
  581|    209|            pushInnerChunk(stream);
  582|    209|            unsigned short streamID = readChunk(stream);
  583|  1.27k|            while(streamID == SKELETON_ANIMATION_TRACK_KEYFRAME && !stream->eof())
  ------------------
  |  Branch (583:19): [True: 1.09k, False: 179]
  |  Branch (583:68): [True: 1.06k, False: 30]
  ------------------
  584|  1.06k|            {
  585|  1.06k|                readKeyFrame(stream, pTrack, pSkel);
  586|       |
  587|  1.06k|                if (!stream->eof())
  ------------------
  |  Branch (587:21): [True: 1.04k, False: 25]
  ------------------
  588|  1.04k|                {
  589|       |                    // Get next stream
  590|  1.04k|                    streamID = readChunk(stream);
  591|  1.04k|                }
  592|  1.06k|            }
  593|    209|            if (!stream->eof())
  ------------------
  |  Branch (593:17): [True: 154, False: 55]
  ------------------
  594|    154|            {
  595|       |                // Backpedal back to start of this stream if we've found a non-keyframe
  596|    154|                backpedalChunkHeader(stream);
  597|    154|            }
  598|    209|            popInnerChunk(stream);
  599|    209|        }
  600|       |
  601|       |
  602|    215|    }
_ZN4Ogre18SkeletonSerializer12readKeyFrameERNS_9SharedPtrINS_10DataStreamEEEPNS_18NodeAnimationTrackEPNS_8SkeletonE:
  606|  1.06k|    {
  607|       |        // float time                    : The time position (seconds)
  608|  1.06k|        float time;
  609|  1.06k|        readFloats(stream, &time, 1);
  610|       |
  611|  1.06k|        TransformKeyFrame *kf = track->createNodeKeyFrame(time);
  612|       |
  613|       |        // Quaternion rotate            : Rotation to apply at this keyframe
  614|  1.06k|        Quaternion rot;
  615|  1.06k|        readObject(stream, rot);
  616|  1.06k|        kf->setRotation(rot);
  617|       |        // Vector3 translate            : Translation to apply at this keyframe
  618|  1.06k|        Vector3 trans;
  619|  1.06k|        readObject(stream, trans);
  620|  1.06k|        kf->setTranslate(trans);
  621|       |        // Do we have scale?
  622|  1.06k|        if (mCurrentstreamLen > calcKeyFrameSizeWithoutScale(pSkel, kf))
  ------------------
  |  Branch (622:13): [True: 267, False: 798]
  ------------------
  623|    267|        {
  624|    267|            Vector3 scale;
  625|    267|            readObject(stream, scale);
  626|    267|            kf->setScale(scale);
  627|    267|        }
  628|  1.06k|    }
_ZN4Ogre18SkeletonSerializer25readSkeletonAnimationLinkERNS_9SharedPtrINS_10DataStreamEEEPNS_8SkeletonE:
  659|    194|    {
  660|       |        // char* skeletonName
  661|    194|        String skelName = readString(stream);
  662|       |        // float scale
  663|    194|        float scale;
  664|    194|        readFloats(stream, &scale, 1);
  665|       |
  666|    194|        pSkel->addLinkedSkeletonAnimationSource(skelName, scale);
  667|       |
  668|    194|    }

_ZN4Ogre16StreamSerialiserC2ERKNS_9SharedPtrINS_10DataStreamEEENS0_6EndianEbNS0_17RealStorageFormatE:
  109|    436|        : mStream(stream)
  110|    436|        , mEndian(endianMode)
  111|    436|        , mFlipEndian(false)
  112|    436|        , mReadWriteHeader(autoHeader)
  113|    436|        , mRealFormat(realFormat)
  114|    436|    {
  115|    436|        if (mEndian != ENDIAN_AUTO)
  ------------------
  |  Branch (115:13): [True: 0, False: 436]
  ------------------
  116|      0|        {
  117|       |#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
  118|       |            if (mEndian == ENDIAN_LITTLE)
  119|       |                mFlipEndian = true;
  120|       |#else
  121|      0|            if (mEndian == ENDIAN_BIG)
  ------------------
  |  Branch (121:17): [True: 0, False: 0]
  ------------------
  122|      0|                mFlipEndian = true;
  123|      0|#endif
  124|       |
  125|      0|        }
  126|       |
  127|       |        OgreAssert(mStream, "Stream is null");
  ------------------
  |  Branch (127:9): [True: 0, False: 436]
  ------------------
  128|    436|    }
_ZN4Ogre16StreamSerialiserD2Ev:
  131|    436|    {
  132|       |        // really this should be empty if read/write was complete, but be tidy
  133|    436|        if (!mChunkStack.empty())
  ------------------
  |  Branch (133:13): [True: 2, False: 434]
  ------------------
  134|      2|        {
  135|      2|            LogManager::getSingleton().stream(LML_WARNING) <<
  136|      2|                "Warning: stream " << mStream->getName() << " was not fully read / written; " <<
  137|      2|                mChunkStack.size() << " chunks remain unterminated.";
  138|      2|        }
  139|    436|        for (auto & i : mChunkStack)
  ------------------
  |  Branch (139:23): [True: 2, False: 436]
  ------------------
  140|      2|            delete i;
  141|    436|        mChunkStack.clear();
  142|       |
  143|    436|    }
_ZN4Ogre16StreamSerialiser14makeIdentifierERA5_Kc:
  146|      2|    {
  147|      2|        uint32 ret = 0;
  148|     10|        for (size_t i = 0; i < 4; ++i)
  ------------------
  |  Branch (148:28): [True: 8, False: 2]
  ------------------
  149|      8|        {
  150|      8|            ret += (code[i] << (i * 8));
  151|      8|        }
  152|      2|        return ret;
  153|       |
  154|      2|    }
_ZN4Ogre16StreamSerialiser14readChunkBeginEv:
  165|  1.87k|    {
  166|       |        // Have we figured out the endian mode yet?
  167|  1.87k|        if (mReadWriteHeader)
  ------------------
  |  Branch (167:13): [True: 436, False: 1.43k]
  ------------------
  168|    436|            readHeader();
  169|       |
  170|  1.87k|        OgreAssert(mEndian != ENDIAN_AUTO,
  ------------------
  |  Branch (170:9): [True: 0, False: 1.87k]
  ------------------
  171|  1.87k|                   "Endian mode has not been determined, did you disable header without setting?");
  172|       |
  173|  1.87k|        Chunk* chunk = readChunkImpl();
  174|  1.87k|        mChunkStack.push_back(chunk);
  175|       |
  176|  1.87k|        return chunk;
  177|       |
  178|  1.87k|    }
_ZN4Ogre16StreamSerialiser12readChunkEndEj:
  239|  1.33k|    {
  240|  1.33k|        Chunk* c = popChunk(id);
  241|       |
  242|  1.33k|        OgreAssert(mStream, "Stream is null");
  ------------------
  |  Branch (242:9): [True: 0, False: 1.33k]
  ------------------
  243|       |
  244|       |        // skip to the end of the chunk if we were not there already
  245|       |        // this lets us quite reading a chunk anywhere and have the read marker
  246|       |        // automatically skip to the next one
  247|  1.33k|        if (mStream->tell() < (c->offset + CHUNK_HEADER_SIZE + c->length))
  ------------------
  |  Branch (247:13): [True: 118, False: 1.21k]
  ------------------
  248|    118|            mStream->seek(c->offset + CHUNK_HEADER_SIZE + c->length);
  249|       |
  250|       |        OGRE_DELETE c;
  251|  1.33k|    }
_ZN4Ogre16StreamSerialiser10readHeaderEv:
  261|    436|    {
  262|    436|        uint32 headerid = 0;
  263|    436|        size_t actually_read = mStream->read(&headerid, sizeof(uint32));
  264|       |        // skip back
  265|    436|        mStream->skip(0 - (long)actually_read);
  266|       |        // validate that this is a header chunk
  267|    436|        if (headerid == REVERSE_HEADER_ID)
  ------------------
  |  Branch (267:13): [True: 17, False: 419]
  ------------------
  268|     17|        {
  269|     17|            mFlipEndian = true;
  270|     17|        }
  271|    419|        else if (headerid == HEADER_ID)
  ------------------
  |  Branch (271:18): [True: 327, False: 92]
  ------------------
  272|    327|        {
  273|    327|            mFlipEndian = false;
  274|    327|        }
  275|     92|        else
  276|     92|        {
  277|       |            // no good
  278|     92|            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 
  279|     92|                "Cannot determine endian mode because header is missing", 
  280|     92|                "StreamSerialiser::readHeader");
  281|     92|        }
  282|    344|        determineEndianness();
  283|       |
  284|    344|        mReadWriteHeader = false;
  285|       |
  286|    344|        const Chunk* c = readChunkBegin();
  287|       |        // endian should be flipped now
  288|    344|        assert(c->id == HEADER_ID);
  289|    344|        (void)c; // Silence warning
  290|       |
  291|       |        // read real storage format
  292|    344|        bool realIsDouble;
  293|    344|        read(&realIsDouble);
  294|    344|        mRealFormat = realIsDouble? REAL_DOUBLE : REAL_FLOAT;
  ------------------
  |  Branch (294:23): [True: 48, False: 296]
  ------------------
  295|       |
  296|    344|        readChunkEnd(HEADER_ID);
  297|       |
  298|    344|    }
_ZN4Ogre16StreamSerialiser19determineEndiannessEv:
  301|    344|    {
  302|       |#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
  303|       |        if (mFlipEndian)
  304|       |            mEndian = ENDIAN_LITTLE;
  305|       |        else
  306|       |            mEndian = ENDIAN_BIG;
  307|       |#else
  308|    344|        if (mFlipEndian)
  ------------------
  |  Branch (308:13): [True: 17, False: 327]
  ------------------
  309|     17|            mEndian = ENDIAN_BIG;
  310|    327|        else
  311|    327|            mEndian = ENDIAN_LITTLE;
  312|    344|#endif
  313|    344|    }
_ZNK4Ogre16StreamSerialiser11checkStreamEbbb:
  330|  10.9k|    {
  331|  10.9k|        OgreAssert(mStream, "Stream is null");
  ------------------
  |  Branch (331:9): [True: 0, False: 10.9k]
  ------------------
  332|       |
  333|  10.9k|        if (failOnEof && mStream->eof())
  ------------------
  |  Branch (333:13): [True: 10.9k, False: 0]
  |  Branch (333:26): [True: 506, False: 10.4k]
  ------------------
  334|  10.9k|            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "Invalid operation, end of file on stream");
  335|       |
  336|  10.4k|        if (validateReadable && !mStream->isReadable())
  ------------------
  |  Branch (336:13): [True: 10.4k, False: 0]
  |  Branch (336:33): [True: 0, False: 10.4k]
  ------------------
  337|  10.4k|            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "Invalid operation, file is not readable");
  338|       |
  339|  10.4k|        if (validateWriteable && !mStream->isWriteable())
  ------------------
  |  Branch (339:13): [True: 0, False: 10.4k]
  |  Branch (339:34): [True: 0, False: 0]
  ------------------
  340|       |            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "Invalid operation, file is not writeable");
  341|  10.4k|    }
_ZN4Ogre16StreamSerialiser13readChunkImplEv:
  421|  1.67k|    {
  422|  1.67k|        auto chunk = std::make_unique<Chunk>();
  423|  1.67k|        chunk->offset = static_cast<uint32>(mStream->tell());
  424|  1.67k|        read(&chunk->id);
  425|  1.67k|        read(&chunk->version);
  426|  1.67k|        read(&chunk->length);
  427|       |
  428|  1.67k|        if (chunk->length > mStream->size() - mStream->tell())
  ------------------
  |  Branch (428:13): [True: 37, False: 1.63k]
  ------------------
  429|  1.67k|            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "Chunk length field exceeds remaining stream data");
  430|       |
  431|  1.63k|        uint32 checksum;
  432|  1.63k|        read(&checksum);
  433|       |        
  434|  1.63k|        if (checksum != calculateChecksum(chunk.get()))
  ------------------
  |  Branch (434:13): [True: 121, False: 1.51k]
  ------------------
  435|    121|        {
  436|       |            // no good, this is an invalid chunk
  437|    121|            uint32 off = chunk->offset;
  438|    121|            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 
  439|    121|                "Corrupt chunk detected in stream " + mStream->getName() + " at byte "
  440|    121|                + StringConverter::toString(off), 
  441|    121|                "StreamSerialiser::readChunkImpl");
  442|    121|        }
  443|       |
  444|  1.51k|        return chunk.release();
  445|       |
  446|       |
  447|  1.63k|    }
_ZN4Ogre16StreamSerialiser8readDataEPvmm:
  617|  10.9k|    {
  618|  10.9k|        checkStream(true, true, false);
  619|       |
  620|  10.9k|        size_t totSize = size * count;
  621|  10.9k|        mStream->read(buf, totSize);
  622|       |
  623|  10.9k|        if (mFlipEndian)
  ------------------
  |  Branch (623:13): [True: 60, False: 10.8k]
  ------------------
  624|     60|			Bitwise::bswapChunks(buf, size, count);
  625|       |
  626|  10.9k|    }
_ZN4Ogre16StreamSerialiser4readEPNS_6VectorILi3EfEEm:
  637|  1.09k|    {
  638|  2.19k|        for (size_t i = 0; i < count; ++i, ++vec)
  ------------------
  |  Branch (638:28): [True: 1.09k, False: 1.09k]
  ------------------
  639|  1.09k|        {
  640|  1.09k|            read(vec->ptr(), 3);
  641|  1.09k|        }
  642|  1.09k|    }
_ZN4Ogre16StreamSerialiser4readEPNS_6VectorILi4EfEEm:
  645|  1.09k|    {
  646|  2.19k|        for (size_t i = 0; i < count; ++i, ++vec)
  ------------------
  |  Branch (646:28): [True: 1.09k, False: 1.09k]
  ------------------
  647|  1.09k|        {
  648|  1.09k|            read(vec->ptr(), 4);
  649|  1.09k|        }
  650|  1.09k|    }
_ZN4Ogre16StreamSerialiser4readEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  677|  1.09k|    {
  678|       |        // String is stored as a uint32 character count, then string
  679|  1.09k|        uint32 len;
  680|  1.09k|        read(&len);
  681|       |
  682|       |        // Guard against OOM from corrupt/malicious input: cap len to remaining chunk bytes
  683|  1.09k|        OgreAssertDbg(mChunkStack.size(), "Not currently in a chunk, cannot read string length");
  684|  1.09k|        if (len > mChunkStack.back()->length)
  ------------------
  |  Branch (684:13): [True: 785, False: 314]
  ------------------
  685|  1.09k|            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "String length field exceeds remaining chunk data");
  686|       |
  687|    314|        string->resize(len);
  688|    314|        if (len)
  ------------------
  |  Branch (688:13): [True: 114, False: 200]
  ------------------
  689|    114|            read(&(*string->begin()), len);
  690|    314|    }
_ZN4Ogre16StreamSerialiser4readEPfm:
  693|  3.29k|    {
  694|       |#if OGRE_DOUBLE_PRECISION
  695|       |        if (mRealFormat == REAL_DOUBLE)
  696|       |            readData(val, sizeof(double), count);
  697|       |        else
  698|       |            readFloatsAsDoubles(val, count);
  699|       |#else
  700|  3.29k|        if (mRealFormat == REAL_FLOAT)
  ------------------
  |  Branch (700:13): [True: 2.65k, False: 642]
  ------------------
  701|  2.65k|            readData(val, sizeof(float), count);
  702|    642|        else
  703|    642|            readDoublesAsFloats(val, count);
  704|  3.29k|#endif
  705|       |
  706|  3.29k|    }
_ZN4Ogre16StreamSerialiser4readEPbm:
  785|    237|    {
  786|    474|        for (size_t i = 0; i < count; ++i, ++val)
  ------------------
  |  Branch (786:28): [True: 237, False: 237]
  ------------------
  787|    237|        {
  788|    237|            char c;
  789|    237|            read(&c);
  790|    237|            *val = (c == 1);
  791|    237|        }
  792|    237|    }
_ZN4Ogre16StreamSerialiser19readDoublesAsFloatsEPfm:
  813|    642|    {
  814|    642|        double t = 0;
  815|    642|        readConverted(val, t, count);
  816|    642|    }
_ZN4Ogre16StreamSerialiser17calculateChecksumEPNS0_5ChunkE:
  819|  1.45k|    {
  820|       |        // Always calculate checksums in little endian to make sure they match 
  821|       |        // Otherwise checksums for the same data on different endians will not match
  822|  1.45k|        uint32 id = c->id;
  823|  1.45k|        uint16 version = c->version;
  824|  1.45k|        uint32 length = c->length;
  825|       |#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
  826|       |		Bitwise::bswapBuffer(&id, sizeof(uint32));
  827|       |		Bitwise::bswapBuffer(&version, sizeof(uint16));
  828|       |		Bitwise::bswapBuffer(&length, sizeof(uint32));
  829|       |#endif
  830|       |
  831|       |		// we cannot switch to murmur3 like everywhere else to allow loading legacy files
  832|  1.45k|        uint32 hashVal = SuperFastHash((const char*)&id, sizeof(uint32), 0);
  833|  1.45k|        hashVal = SuperFastHash((const char*)&version, sizeof(uint16), hashVal);
  834|  1.45k|        hashVal = SuperFastHash((const char*)&length, sizeof(uint32), hashVal);
  835|       |
  836|  1.45k|        return hashVal;
  837|  1.45k|    }
_ZN4Ogre16StreamSerialiser8popChunkEj:
  840|  1.33k|    {
  841|  1.33k|        OgreAssert(!mChunkStack.empty(), "No active chunk!");
  ------------------
  |  Branch (841:9): [True: 0, False: 1.33k]
  ------------------
  842|       |
  843|  1.33k|        const Chunk* chunk = mChunkStack.back();
  844|  1.33k|        OgreAssert(chunk->id == id, "Incorrect chunk id!");
  ------------------
  |  Branch (844:9): [True: 1, False: 1.33k]
  ------------------
  845|       |
  846|  1.33k|        Chunk* c = mChunkStack.back();
  847|  1.33k|        mChunkStack.pop_back();
  848|  1.33k|        return c;
  849|       |
  850|  1.33k|    }
OgreStreamSerialiser.cpp:_ZN4OgreL13SuperFastHashEPKcij:
   40|  4.37k|    {
   41|  4.37k|#if OGRE_ENDIAN == OGRE_ENDIAN_LITTLE
   42|  4.37k|#  define OGRE_GET16BITS(d) (*((const uint16 *) (d)))
   43|       |#else
   44|       |    // Cast to uint16 in little endian means first byte is least significant
   45|       |    // replicate that here
   46|       |#  define OGRE_GET16BITS(d) (*((const uint8 *) (d)) + (*((const uint8 *) (d+1))<<8))
   47|       |#endif
   48|  4.37k|        uint32 hash;
   49|  4.37k|        int rem;
   50|       |
   51|  4.37k|        if (hashSoFar)
  ------------------
  |  Branch (51:13): [True: 2.91k, False: 1.45k]
  ------------------
   52|  2.91k|            hash = hashSoFar;
   53|  1.45k|        else
   54|  1.45k|            hash = len;
   55|       |
   56|  4.37k|        if (len <= 0 || data == NULL) return 0;
  ------------------
  |  Branch (56:13): [True: 0, False: 4.37k]
  |  Branch (56:25): [True: 0, False: 4.37k]
  ------------------
   57|       |
   58|  4.37k|        rem = len & 3;
   59|  4.37k|        len >>= 2;
   60|       |
   61|       |        /* Main loop */
   62|  7.28k|        for (;len > 0; len--) {
  ------------------
  |  Branch (62:15): [True: 2.91k, False: 4.37k]
  ------------------
   63|  2.91k|            hash  += OGRE_GET16BITS (data);
  ------------------
  |  |   42|  2.91k|#  define OGRE_GET16BITS(d) (*((const uint16 *) (d)))
  ------------------
   64|  2.91k|            uint32 tmp    = (OGRE_GET16BITS (data+2) << 11) ^ hash;
  ------------------
  |  |   42|  2.91k|#  define OGRE_GET16BITS(d) (*((const uint16 *) (d)))
  ------------------
   65|  2.91k|            hash   = (hash << 16) ^ tmp;
   66|  2.91k|            data  += 2*sizeof (uint16);
   67|  2.91k|            hash  += hash >> 11;
   68|  2.91k|        }
   69|       |
   70|       |        /* Handle end cases */
   71|  4.37k|        switch (rem) {
  ------------------
  |  Branch (71:17): [True: 1.45k, False: 2.91k]
  ------------------
   72|      0|        case 3: hash += OGRE_GET16BITS (data);
  ------------------
  |  |   42|      0|#  define OGRE_GET16BITS(d) (*((const uint16 *) (d)))
  ------------------
  |  Branch (72:9): [True: 0, False: 4.37k]
  ------------------
   73|      0|            hash ^= hash << 16;
   74|      0|            hash ^= data[sizeof (uint16)] << 18;
   75|      0|            hash += hash >> 11;
   76|      0|            break;
   77|  1.45k|        case 2: hash += OGRE_GET16BITS (data);
  ------------------
  |  |   42|  1.45k|#  define OGRE_GET16BITS(d) (*((const uint16 *) (d)))
  ------------------
  |  Branch (77:9): [True: 1.45k, False: 2.91k]
  ------------------
   78|  1.45k|            hash ^= hash << 11;
   79|  1.45k|            hash += hash >> 17;
   80|  1.45k|            break;
   81|      0|        case 1: hash += *data;
  ------------------
  |  Branch (81:9): [True: 0, False: 4.37k]
  ------------------
   82|      0|            hash ^= hash << 10;
   83|      0|            hash += hash >> 1;
   84|  4.37k|        }
   85|       |
   86|       |        /* Force "avalanching" of final 127 bits */
   87|  4.37k|        hash ^= hash << 3;
   88|  4.37k|        hash += hash >> 5;
   89|  4.37k|        hash ^= hash << 4;
   90|  4.37k|        hash += hash >> 17;
   91|  4.37k|        hash ^= hash << 25;
   92|  4.37k|        hash += hash >> 6;
   93|       |
   94|  4.37k|        return hash;
   95|  4.37k|#undef OGRE_GET16BITS
   96|  4.37k|    }

_ZN4Ogre10StringUtil4trimERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbb:
   42|  62.6k|    {
   43|       |        /*
   44|       |        size_t lspaces, rspaces, len = length(), i;
   45|       |
   46|       |        lspaces = rspaces = 0;
   47|       |
   48|       |        if( left )
   49|       |        {
   50|       |            // Find spaces / tabs on the left
   51|       |            for( i = 0;
   52|       |                i < len && ( at(i) == ' ' || at(i) == '\t' || at(i) == '\r');
   53|       |                ++lspaces, ++i );
   54|       |        }
   55|       |        
   56|       |        if( right && lspaces < len )
   57|       |        {
   58|       |            // Find spaces / tabs on the right
   59|       |            for( i = len - 1;
   60|       |                i >= 0 && ( at(i) == ' ' || at(i) == '\t' || at(i) == '\r');
   61|       |                rspaces++, i-- );
   62|       |        }
   63|       |
   64|       |        *this = substr(lspaces, len-lspaces-rspaces);
   65|       |        */
   66|  62.6k|        static const String delims = " \t\r\n";
   67|  62.6k|        if(right)
  ------------------
  |  Branch (67:12): [True: 62.6k, False: 0]
  ------------------
   68|  62.6k|            str.erase(str.find_last_not_of(delims)+1); // trim right
   69|  62.6k|        if(left)
  ------------------
  |  Branch (69:12): [True: 62.6k, False: 0]
  ------------------
   70|  62.6k|            str.erase(0, str.find_first_not_of(delims)); // trim left
   71|  62.6k|    }
_ZN4Ogre10StringUtil6formatEPKcz:
  467|   197k|    {
  468|       |        // try to use a stack buffer and fall back to heap for large strings
  469|   197k|        char sbuf[1024];
  470|   197k|        size_t bsize = sizeof(sbuf);
  471|   197k|        std::vector<char> hbuf;
  472|   197k|        char* pbuf = sbuf;
  473|       |
  474|   197k|        while (true)
  ------------------
  |  Branch (474:16): [True: 197k, Folded]
  ------------------
  475|   197k|        {
  476|   197k|            va_list va;
  477|   197k|            va_start(va, fmt);
  478|   197k|            int len = vsnprintf(pbuf, bsize, fmt, va);
  479|   197k|            va_end(va);
  480|       |
  481|   197k|            OgreAssert(len >= 0, "Check format string for errors");
  ------------------
  |  Branch (481:13): [True: 0, False: 197k]
  ------------------
  482|   197k|            if (size_t(len) >= bsize)
  ------------------
  |  Branch (482:17): [True: 249, False: 197k]
  ------------------
  483|    249|            {
  484|    249|                hbuf.resize(len + 1);
  485|    249|                pbuf = hbuf.data();
  486|    249|                bsize = hbuf.size();
  487|    249|                continue;
  488|    249|            }
  489|   197k|            pbuf[bsize - 1] = 0;
  490|   197k|            return String(pbuf, len);
  491|   197k|        }
  492|   197k|    }

_ZN4Ogre15ParamDictionaryC2Ev:
   36|      2|    ParamDictionary::ParamDictionary() {}
_ZN4Ogre15ParamDictionaryD2Ev:
   37|      4|    ParamDictionary::~ParamDictionary() {}
_ZN4Ogre15StringInterface21createParamDictionaryERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   72|  4.27k|    {
   73|  4.27k|        OGRE_LOCK_MUTEX( msDictionaryMutex );
   74|       |
   75|  4.27k|        ParamDictionaryMap::iterator it = msDictionary.find(className);
   76|       |
   77|  4.27k|        if ( it == msDictionary.end() )
  ------------------
  |  Branch (77:14): [True: 2, False: 4.27k]
  ------------------
   78|      2|        {
   79|      2|            mParamDict = &msDictionary.insert( std::make_pair( className, ParamDictionary() ) ).first->second;
   80|      2|            mParamDictName = className;
   81|      2|            return true;
   82|      2|        }
   83|  4.27k|        else
   84|  4.27k|        {
   85|  4.27k|            mParamDict = &it->second;
   86|  4.27k|            mParamDictName = className;
   87|  4.27k|            return false;
   88|  4.27k|        }
   89|  4.27k|    }

_ZN4Ogre7SubMeshC2Ev:
   33|   197k|        : vertexData(0)
   34|   197k|        , parent(0)
   35|   197k|        , useSharedVertices(true)
   36|   197k|        , operationType(RenderOperation::OT_TRIANGLE_LIST)
   37|   197k|        , mBoneAssignmentsOutOfDate(false)
   38|   197k|        , mVertexAnimationType(VAT_NONE)
   39|   197k|        , mVertexAnimationIncludesNormals(false)
   40|   197k|        , mBuildEdgesEnabled(true)
   41|   197k|    {
   42|       |        indexData = OGRE_NEW IndexData();
   43|   197k|    }
_ZN4Ogre7SubMeshD2Ev:
   46|   197k|    {
   47|   197k|        removeLodLevels();
   48|   197k|        OGRE_DELETE vertexData;
   49|       |        OGRE_DELETE indexData;
   50|   197k|    }
_ZN4Ogre7SubMesh17addBoneAssignmentERKNS_20VertexBoneAssignmentE:
   81|  1.66k|    {
   82|  1.66k|        OgreAssert(!useSharedVertices,
  ------------------
  |  Branch (82:9): [True: 1, False: 1.66k]
  ------------------
   83|  1.66k|                   "This SubMesh uses shared geometry, you must assign bones to the Mesh, not the SubMesh");
   84|  1.66k|        mBoneAssignments.emplace(vertBoneAssign.vertexIndex, vertBoneAssign);
   85|  1.66k|        mBoneAssignmentsOutOfDate = true;
   86|  1.66k|    }
_ZN4Ogre7SubMesh15removeLodLevelsEv:
  116|   197k|    {
  117|   197k|        LODFaceList::iterator lodi, lodend;
  118|   197k|        lodend = mLodFaceList.end();
  119|   998k|        for (lodi = mLodFaceList.begin(); lodi != lodend; ++lodi)
  ------------------
  |  Branch (119:43): [True: 801k, False: 197k]
  ------------------
  120|   801k|        {
  121|   801k|            OGRE_DELETE *lodi;
  122|   801k|        }
  123|       |
  124|   197k|        mLodFaceList.clear();
  125|       |
  126|   197k|    }

_ZN4Ogre9TechniqueC2EPNS_8MaterialE:
   35|      3|        : mParent(parent), mIlluminationPassesCompilationPhase(IPS_NOT_COMPILED), mIsSupported(false), mLodIndex(0), mSchemeIndex(0)
   36|      3|    {
   37|       |        // See above, defaults to unsupported until examined
   38|      3|    }
_ZNK4Ogre9Technique11isSupportedEv:
   54|      2|    {
   55|      2|        return mIsSupported;
   56|      2|    }
_ZN4Ogre9Technique10createPassEv:
  310|      1|    {
  311|       |        Pass* newPass = OGRE_NEW Pass(this, static_cast<unsigned short>(mPasses.size()));
  312|      1|        mPasses.push_back(newPass);
  313|      1|        return newPass;
  314|      1|    }
_ZN4Ogre9Technique15removeAllPassesEv:
  341|      2|    {
  342|      2|        for (auto *p : mPasses)
  ------------------
  |  Branch (342:22): [True: 0, False: 2]
  ------------------
  343|      0|        {
  344|      0|            p->queueForDeletion();
  345|      0|        }
  346|      2|        mPasses.clear();
  347|      2|    }
_ZN4Ogre9TechniqueaSERKS0_:
  398|      2|    {
  399|      2|        if (this == &rhs)
  ------------------
  |  Branch (399:13): [True: 0, False: 2]
  ------------------
  400|      0|            return *this;
  401|       |
  402|      2|        mName = rhs.mName;
  403|      2|        this->mIsSupported = rhs.mIsSupported;
  404|      2|        this->mLodIndex = rhs.mLodIndex;
  405|      2|        this->mSchemeIndex = rhs.mSchemeIndex;
  406|      2|        this->mShadowCasterMaterial = rhs.mShadowCasterMaterial;
  407|      2|        this->mShadowCasterMaterialName = rhs.mShadowCasterMaterialName;
  408|      2|        this->mShadowReceiverMaterial = rhs.mShadowReceiverMaterial;
  409|      2|        this->mShadowReceiverMaterialName = rhs.mShadowReceiverMaterialName;
  410|      2|        this->mGPUVendorRules = rhs.mGPUVendorRules;
  411|      2|        this->mGPUDeviceNameRules = rhs.mGPUDeviceNameRules;
  412|       |
  413|       |        // copy passes
  414|      2|        removeAllPasses();
  415|      2|        for (auto *rp : rhs.mPasses)
  ------------------
  |  Branch (415:23): [True: 2, False: 2]
  ------------------
  416|      2|        {
  417|      2|            Pass* p = OGRE_NEW Pass(this, rp->getIndex(), *(rp));
  418|      2|            mPasses.push_back(p);
  419|      2|        }
  420|       |        // Compile for categorised illumination on demand
  421|      2|        clearIlluminationPasses();
  422|      2|        mIlluminationPassesCompilationPhase = IPS_NOT_COMPILED;
  423|      2|        return *this;
  424|      2|    }
_ZN4Ogre9Technique18setLightingEnabledEb:
  631|      1|    void Technique::setLightingEnabled(bool enabled) { ALL_PASSES(setLightingEnabled(enabled)); }
  ------------------
  |  |  581|      1|    #define ALL_PASSES(fncall) for(auto p : mPasses) p->fncall
  |  |  ------------------
  |  |  |  Branch (581:43): [True: 1, False: 1]
  |  |  ------------------
  ------------------
_ZN4Ogre9Technique23clearIlluminationPassesEv:
  958|      2|    {
  959|      2|        if(MaterialManager::getSingletonPtr())
  ------------------
  |  Branch (959:12): [True: 2, False: 0]
  ------------------
  960|      2|            MaterialManager::getSingleton()._notifyBeforeIlluminationPassesCleared(this);
  961|       |
  962|      2|        for (auto *i : mIlluminationPasses)
  ------------------
  |  Branch (962:22): [True: 0, False: 2]
  ------------------
  963|      0|        {
  964|      0|            if (i->destroyOnShutdown)
  ------------------
  |  Branch (964:17): [True: 0, False: 0]
  ------------------
  965|      0|            {
  966|      0|                i->pass->queueForDeletion();
  967|      0|            }
  968|       |            OGRE_DELETE i;
  969|      0|        }
  970|      2|        mIlluminationPasses.clear();
  971|      2|    }

_ZN4Ogre7SamplerC2Ev:
   40|      2|        : mBorderColour(ColourValue::Black)
   41|      2|        , mMaxAniso(1)
   42|      2|        , mMipmapBias(0)
   43|      2|        , mMinFilter(FO_LINEAR)
   44|      2|        , mMagFilter(FO_LINEAR)
   45|      2|        , mMipFilter(FO_POINT)
   46|      2|        , mCompareFunc(CMPF_GREATER_EQUAL)
   47|      2|        , mCompareEnabled(false)
   48|      2|        , mDirty(true)
   49|      2|    {
   50|      2|        setAddressingMode(TAM_WRAP);
   51|      2|    }
_ZN4Ogre7Sampler17setAddressingModeERKNS0_17UVWAddressingModeE:
   55|      2|    {
   56|      2|        mAddressMode = uvw;
   57|      2|        mDirty = true;
   58|      2|    }

_ZN4Ogre10VertexDataC2EPNS_25HardwareBufferManagerBaseE:
  172|   149k|    {
  173|   149k|        mMgr = mgr ? mgr : HardwareBufferManager::getSingletonPtr();
  ------------------
  |  Branch (173:16): [True: 0, False: 149k]
  ------------------
  174|   149k|        vertexBufferBinding = mMgr->createVertexBufferBinding();
  175|   149k|        vertexDeclaration = mMgr->createVertexDeclaration();
  176|   149k|        mDeleteDclBinding = true;
  177|   149k|        vertexCount = 0;
  178|   149k|        vertexStart = 0;
  179|   149k|        hwAnimDataItemsUsed = 0;
  180|       |
  181|   149k|    }
_ZN4Ogre10VertexDataD2Ev:
  196|   149k|    {
  197|   149k|        if (mDeleteDclBinding)
  ------------------
  |  Branch (197:13): [True: 149k, False: 0]
  ------------------
  198|   149k|        {
  199|   149k|            mMgr->destroyVertexBufferBinding(vertexBufferBinding);
  200|   149k|            mMgr->destroyVertexDeclaration(vertexDeclaration);
  201|   149k|        }
  202|   149k|    }
_ZN4Ogre10VertexData20convertVertexElementENS_21VertexElementSemanticENS_17VertexElementTypeEt:
  269|   131k|    {
  270|   131k|        auto elem = vertexDeclaration->findElementBySemantic(semantic, index);
  271|       |
  272|   131k|        if(!elem)
  ------------------
  |  Branch (272:12): [True: 129k, False: 1.60k]
  ------------------
  273|   129k|            return; // nothing to do
  274|       |
  275|  1.60k|        auto srcBaseType = VertexElement::getBaseType(elem->getType());
  276|  1.60k|        if (srcBaseType == VET_FLOAT1 && srcBaseType == VertexElement::getBaseType(dstType))
  ------------------
  |  Branch (276:13): [True: 250, False: 1.35k]
  |  Branch (276:42): [True: 250, False: 0]
  ------------------
  277|    250|            return; // silently ignore floatX > floatY conversions
  278|       |
  279|  1.35k|        auto srcType = elem->getType();
  280|  1.35k|        auto vbuf = vertexBufferBinding->getBuffer(elem->getSource());
  281|       |
  282|  1.35k|        uint32 newElemSize = VertexElement::getTypeSize(dstType);
  283|  1.35k|        size_t newVertexSize = vbuf->getVertexSize() - elem->getSize() + newElemSize;
  284|  1.35k|        auto newVBuf = vbuf->getManager()->createVertexBuffer(newVertexSize, vbuf->getNumVertices(), vbuf->getUsage(),
  285|  1.35k|                                                              vbuf->hasShadowBuffer());
  286|       |
  287|  1.35k|        {
  288|  1.35k|            HardwareBufferLockGuard dst(newVBuf, HardwareBuffer::HBL_DISCARD);
  289|  1.35k|            auto pDst = static_cast<uint8*>(dst.pData);
  290|       |
  291|  1.35k|            if(dstType == VET_INT_10_10_10_2_NORM)
  ------------------
  |  Branch (291:16): [True: 0, False: 1.35k]
  ------------------
  292|      0|            {
  293|      0|                if(srcType == VET_FLOAT3)
  ------------------
  |  Branch (293:20): [True: 0, False: 0]
  ------------------
  294|      0|                    spliceElement(elem, vbuf, pDst, pDst, newElemSize, pack_10_10_10_2<false>);
  295|      0|                else
  296|      0|                {
  297|      0|                    OgreAssert(srcType == VET_FLOAT4, "unsupported conversion");
  ------------------
  |  Branch (297:21): [True: 0, False: 0]
  ------------------
  298|      0|                    spliceElement(elem, vbuf, pDst, pDst, newElemSize, pack_10_10_10_2<true>);
  299|      0|                }
  300|      0|            }
  301|  1.35k|            else if(dstType == VET_FLOAT3)
  ------------------
  |  Branch (301:21): [True: 555, False: 797]
  ------------------
  302|    555|            {
  303|    555|                OgreAssert(srcType == VET_INT_10_10_10_2_NORM, "unsupported conversion");
  ------------------
  |  Branch (303:17): [True: 13, False: 542]
  ------------------
  304|    542|                spliceElement(elem, vbuf, pDst, pDst, newElemSize, unpack_10_10_10_2<false>);
  305|    542|            }
  306|    797|            else if(dstType == VET_FLOAT4)
  ------------------
  |  Branch (306:21): [True: 752, False: 45]
  ------------------
  307|    752|            {
  308|    752|                OgreAssert(srcType == VET_INT_10_10_10_2_NORM, "unsupported conversion");
  ------------------
  |  Branch (308:17): [True: 34, False: 718]
  ------------------
  309|    718|                spliceElement(elem, vbuf, pDst, pDst, newElemSize, unpack_10_10_10_2<true>);
  310|    718|            }
  311|     45|            else if(dstType == VET_HALF3)
  ------------------
  |  Branch (311:21): [True: 0, False: 45]
  ------------------
  312|      0|            {
  313|      0|                OgreAssert(srcType == VET_FLOAT3, "unsupported conversion");
  ------------------
  |  Branch (313:17): [True: 0, False: 0]
  ------------------
  314|      0|                spliceElement(elem, vbuf, pDst, pDst, newElemSize, float_to_half_3);
  315|      0|            }
  316|     45|            else if(dstType == VET_HALF4 || dstType == VET_SHORT4 || dstType == VET_USHORT4)
  ------------------
  |  Branch (316:21): [True: 45, False: 0]
  |  Branch (316:45): [True: 0, False: 0]
  |  Branch (316:70): [True: 0, False: 0]
  ------------------
  317|      0|            {
  318|       |                // pad 16x3 formats to 16x4
  319|      0|                OgreAssert(srcType == VET_HALF3 || srcType == VET_SHORT3 || srcType == VET_USHORT3, "unsupported conversion");
  ------------------
  |  Branch (319:17): [True: 0, False: 0]
  |  Branch (319:17): [True: 0, False: 0]
  |  Branch (319:17): [True: 0, False: 0]
  ------------------
  320|      0|                spliceElement(elem, vbuf, pDst, pDst, newElemSize, pad_16x3);
  321|      0|            }
  322|     45|            else
  323|     45|            {
  324|     45|                OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "unsupported dstType");
  325|     45|            }
  326|  1.35k|        }
  327|       |
  328|       |        // Bind the new buffer
  329|  1.26k|        vertexBufferBinding->setBinding(elem->getSource(), newVBuf);
  330|  1.26k|        updateVertexDeclaration(vertexDeclaration, elem, dstType, elem->getSource());
  331|  1.26k|    }
_ZN4Ogre10VertexData19convertPackedColourENS_17VertexElementTypeES1_:
  645|   144k|    {
  646|   144k|        OgreAssert(destType == VET_UBYTE4_NORM, "Not supported");
  ------------------
  |  Branch (646:9): [True: 0, False: 144k]
  ------------------
  647|       |
  648|   144k|        const VertexBufferBinding::VertexBufferBindingMap& bindMap = 
  649|   144k|            vertexBufferBinding->getBindings();
  650|   144k|        for (auto& m : bindMap)
  ------------------
  |  Branch (650:22): [True: 8.32k, False: 144k]
  ------------------
  651|  8.32k|        {
  652|  8.32k|            const auto& elems =
  653|  8.32k|                vertexDeclaration->findElementsBySource(m.first);
  654|  8.32k|            bool conversionNeeded = false;
  655|  8.32k|            for (auto& e : elems)
  ------------------
  |  Branch (655:26): [True: 11.3k, False: 8.32k]
  ------------------
  656|  11.3k|            {
  657|  11.3k|                if (e.getType() == _DETAIL_SWAP_RB)
  ------------------
  |  Branch (657:21): [True: 1.43k, False: 9.92k]
  ------------------
  658|  1.43k|                {
  659|  1.43k|                    conversionNeeded = true;
  660|  1.43k|                }
  661|  11.3k|            }
  662|       |
  663|  8.32k|            if (conversionNeeded)
  ------------------
  |  Branch (663:17): [True: 1.11k, False: 7.21k]
  ------------------
  664|  1.11k|            {
  665|  1.11k|                void* pBase = m.second->lock(HardwareBuffer::HBL_NORMAL);
  666|       |
  667|  5.74k|                for (size_t v = 0; v < m.second->getNumVertices(); ++v)
  ------------------
  |  Branch (667:36): [True: 4.63k, False: 1.11k]
  ------------------
  668|  4.63k|                {
  669|       |
  670|  4.63k|                    for (auto& e : elems)
  ------------------
  |  Branch (670:34): [True: 10.4k, False: 4.63k]
  ------------------
  671|  10.4k|                    {
  672|  10.4k|                        if (e.getType() == _DETAIL_SWAP_RB)
  ------------------
  |  Branch (672:29): [True: 4.76k, False: 5.64k]
  ------------------
  673|  4.76k|                        {
  674|  4.76k|                            uint32* pRGBA;
  675|  4.76k|                            e.baseVertexPointerToElement(pBase, &pRGBA);
  676|  4.76k|                            swapPackedRB(pRGBA);
  677|  4.76k|                        }
  678|  10.4k|                    }
  679|  4.63k|                    pBase = static_cast<void*>(
  680|  4.63k|                        static_cast<char*>(pBase) + m.second->getVertexSize());
  681|  4.63k|                }
  682|  1.11k|                m.second->unlock();
  683|       |
  684|       |                // Modify the elements to reflect the changed type
  685|  1.11k|                const VertexDeclaration::VertexElementList& allelems = 
  686|  1.11k|                    vertexDeclaration->getElements();
  687|  1.11k|                unsigned short elemIndex = 0;
  688|  1.11k|                for (auto& e : allelems)
  ------------------
  |  Branch (688:30): [True: 6.04k, False: 1.11k]
  ------------------
  689|  6.04k|                {
  690|  6.04k|                    if (e.getType() == _DETAIL_SWAP_RB)
  ------------------
  |  Branch (690:25): [True: 4.01k, False: 2.02k]
  ------------------
  691|  4.01k|                    {
  692|  4.01k|                        vertexDeclaration->modifyElement(elemIndex,
  693|  4.01k|                            e.getSource(), e.getOffset(), destType,
  694|  4.01k|                            e.getSemantic(), e.getIndex());
  695|  4.01k|                    }
  696|  6.04k|                    ++elemIndex;
  697|  6.04k|                }
  698|  1.11k|            }
  699|  8.32k|        } // each buffer
  700|   144k|    }
_ZN4Ogre9IndexDataC2Ev:
  770|   199k|    {
  771|   199k|        indexCount = 0;
  772|   199k|        indexStart = 0;
  773|       |        
  774|   199k|    }
_ZN4Ogre9IndexDataD2Ev:
  777|   199k|    {
  778|   199k|    }
OgreVertexIndexData.cpp:_ZN4OgreL13spliceElementEPKNS_13VertexElementERKNS_9SharedPtrINS_20HardwareVertexBufferEEEPhS8_jPFvS8_S8_iE:
  103|  1.26k|    {
  104|  1.26k|        auto vertexSize = srcBuf->getVertexSize();
  105|  1.26k|        auto numVerts = srcBuf->getNumVertices();
  106|       |
  107|  1.26k|        auto elemSize = elem->getSize();
  108|  1.26k|        int elemOffset = elem->getOffset();
  109|       |
  110|  1.26k|        auto postVertexOffset = elemOffset + elemSize;
  111|  1.26k|        auto postVertexSize = vertexSize - postVertexOffset;
  112|       |
  113|  1.26k|        auto elemDstSize = pDst == pElemDst ? newElemSize : 0;
  ------------------
  |  Branch (113:28): [True: 1.26k, False: 0]
  ------------------
  114|  1.26k|        size_t newVertexSize = vertexSize - elemSize + elemDstSize;
  115|  1.26k|        auto elemDstStep = pDst == pElemDst ? newVertexSize : newElemSize;
  ------------------
  |  Branch (115:28): [True: 1.26k, False: 0]
  ------------------
  116|       |
  117|  1.26k|        HardwareBufferLockGuard srcLock(srcBuf, HardwareBuffer::HBL_READ_ONLY);
  118|  1.26k|        uint8* pSrc = static_cast<uint8*>(srcLock.pData);
  119|       |
  120|  5.79k|        for (uint32 v = 0; v < numVerts; ++v)
  ------------------
  |  Branch (120:28): [True: 4.53k, False: 1.26k]
  ------------------
  121|  4.53k|        {
  122|       |            // copy and convert element from vertex
  123|  4.53k|            elemConvert(pElemDst, pSrc, elemOffset);
  124|  4.53k|            pElemDst += elemDstStep;
  125|       |
  126|       |            // copy over other data
  127|  4.53k|            if (elemOffset)
  ------------------
  |  Branch (127:17): [True: 3.49k, False: 1.03k]
  ------------------
  128|  3.49k|                memcpy(pDst, pSrc, elemOffset);
  129|  4.53k|            if (postVertexSize)
  ------------------
  |  Branch (129:17): [True: 1.43k, False: 3.09k]
  ------------------
  130|  1.43k|                memcpy(pDst + elemOffset + elemDstSize, pSrc + postVertexOffset, postVertexSize);
  131|       |
  132|  4.53k|            pSrc += vertexSize;
  133|  4.53k|            pDst += newVertexSize;
  134|  4.53k|        }
  135|  1.26k|    }
OgreVertexIndexData.cpp:_ZN4OgreL23updateVertexDeclarationEPNS_17VertexDeclarationEPKNS_13VertexElementENS_17VertexElementTypeEt:
  138|  1.26k|    {
  139|  1.26k|        auto elemSize = elem->getSize();
  140|  1.26k|        auto oldElemOffset = elem->getOffset();
  141|  1.26k|        auto newElemOffset = oldElemOffset;
  142|       |
  143|  1.26k|        auto newElemSize = VertexElement::getTypeSize(newType);
  144|  1.26k|        auto oldSource = elem->getSource();
  145|       |
  146|  1.26k|        if(newSource != oldSource)
  ------------------
  |  Branch (146:12): [True: 0, False: 1.26k]
  ------------------
  147|      0|        {
  148|      0|            newElemOffset = 0;
  149|      0|            newElemSize = 0;
  150|      0|        }
  151|       |
  152|  1.26k|        uint16 idx = 0;
  153|  1.26k|        for (const auto& e : decl->getElements())
  ------------------
  |  Branch (153:28): [True: 3.74k, False: 1.26k]
  ------------------
  154|  3.74k|        {
  155|  3.74k|            if (&e == elem)
  ------------------
  |  Branch (155:17): [True: 1.26k, False: 2.48k]
  ------------------
  156|  1.26k|            {
  157|       |                // Modify element
  158|  1.26k|                decl->modifyElement(idx, newSource, newElemOffset, newType, elem->getSemantic(), elem->getIndex());
  159|  1.26k|            }
  160|  2.48k|            else if (e.getSource() == oldSource && e.getOffset() > oldElemOffset)
  ------------------
  |  Branch (160:22): [True: 1.26k, False: 1.22k]
  |  Branch (160:52): [True: 569, False: 691]
  ------------------
  161|    569|            {
  162|       |                // shift elements after this one
  163|    569|                decl->modifyElement(idx, e.getSource(), e.getOffset() - elemSize + newElemSize, e.getType(),
  164|    569|                                    e.getSemantic(), e.getIndex());
  165|    569|            }
  166|  3.74k|            idx++;
  167|  3.74k|        }
  168|  1.26k|    }
OgreVertexIndexData.cpp:_ZN4OgreL12swapPackedRBEPj:
   36|  4.76k|    {
   37|  4.76k|        auto cptr = (uint8*)ptr;
   38|  4.76k|        std::swap(cptr[0], cptr[2]);
   39|  4.76k|    }
OgreVertexIndexData.cpp:_ZN4OgreL17unpack_10_10_10_2ILi0EEEvPhS1_i:
   61|  1.10k|    {
   62|  1.10k|        int_10_10_10_2* pPacked = (int_10_10_10_2*)(pSrc + elemOffset);
   63|  1.10k|        float* pFloat = (float*)(pDst + elemOffset);
   64|       |
   65|  1.10k|        pFloat[0] = float(pPacked->x) / INT10_MAX;
  ------------------
  |  |   32|  1.10k|#define INT10_MAX ((1 << 9) - 1)
  ------------------
   66|  1.10k|        pFloat[1] = float(pPacked->y) / INT10_MAX;
  ------------------
  |  |   32|  1.10k|#define INT10_MAX ((1 << 9) - 1)
  ------------------
   67|  1.10k|        pFloat[2] = float(pPacked->z) / INT10_MAX;
  ------------------
  |  |   32|  1.10k|#define INT10_MAX ((1 << 9) - 1)
  ------------------
   68|  1.10k|        if(INCLUDE_W)
  ------------------
  |  Branch (68:12): [Folded, False: 1.10k]
  ------------------
   69|      0|            pFloat[3] = pPacked->w;
   70|  1.10k|    }
OgreVertexIndexData.cpp:_ZN4OgreL17unpack_10_10_10_2ILi1EEEvPhS1_i:
   61|  3.42k|    {
   62|  3.42k|        int_10_10_10_2* pPacked = (int_10_10_10_2*)(pSrc + elemOffset);
   63|  3.42k|        float* pFloat = (float*)(pDst + elemOffset);
   64|       |
   65|  3.42k|        pFloat[0] = float(pPacked->x) / INT10_MAX;
  ------------------
  |  |   32|  3.42k|#define INT10_MAX ((1 << 9) - 1)
  ------------------
   66|  3.42k|        pFloat[1] = float(pPacked->y) / INT10_MAX;
  ------------------
  |  |   32|  3.42k|#define INT10_MAX ((1 << 9) - 1)
  ------------------
   67|  3.42k|        pFloat[2] = float(pPacked->z) / INT10_MAX;
  ------------------
  |  |   32|  3.42k|#define INT10_MAX ((1 << 9) - 1)
  ------------------
   68|  3.42k|        if(INCLUDE_W)
  ------------------
  |  Branch (68:12): [True: 3.42k, Folded]
  ------------------
   69|  3.42k|            pFloat[3] = pPacked->w;
   70|  3.42k|    }

LLVMFuzzerTestOneInput:
  167|  8.64k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
  168|  8.64k|  if (size < 2)
  ------------------
  |  Branch (168:7): [True: 1, False: 8.64k]
  ------------------
  169|      1|    return 0;
  170|       |
  171|  8.64k|  global_init();
  172|       |
  173|  8.64k|  FuzzedDataProvider provider(data, size);
  174|  8.64k|  uint8_t target = provider.ConsumeIntegral<uint8_t>() % FUZZ_TARGET_COUNT;
  175|  8.64k|  auto remaining = provider.ConsumeRemainingBytes<uint8_t>();
  176|       |
  177|  8.64k|  if (remaining.empty())
  ------------------
  |  Branch (177:7): [True: 0, False: 8.64k]
  ------------------
  178|      0|    return 0;
  179|       |
  180|  8.64k|  switch (target) {
  ------------------
  |  Branch (180:11): [True: 8.64k, False: 0]
  ------------------
  181|  5.79k|  case FUZZ_MESH:
  ------------------
  |  Branch (181:3): [True: 5.79k, False: 2.84k]
  ------------------
  182|  5.79k|    fuzz_mesh(remaining.data(), remaining.size());
  183|  5.79k|    break;
  184|  1.32k|  case FUZZ_SKELETON:
  ------------------
  |  Branch (184:3): [True: 1.32k, False: 7.31k]
  ------------------
  185|  1.32k|    fuzz_skeleton(remaining.data(), remaining.size());
  186|  1.32k|    break;
  187|  1.08k|  case FUZZ_CONFIG:
  ------------------
  |  Branch (187:3): [True: 1.08k, False: 7.55k]
  ------------------
  188|  1.08k|    fuzz_config(remaining.data(), remaining.size());
  189|  1.08k|    break;
  190|    436|  case FUZZ_STREAM_SERIALISER:
  ------------------
  |  Branch (190:3): [True: 436, False: 8.20k]
  ------------------
  191|    436|    fuzz_stream_serialiser(remaining.data(), remaining.size());
  192|    436|    break;
  193|  8.64k|  }
  194|       |
  195|  8.64k|  return 0;
  196|  8.64k|}
ogre_deep_fuzz.cpp:_ZL11global_initv:
   57|  8.64k|static void global_init() {
   58|  8.64k|  if (g_initialized)
  ------------------
  |  Branch (58:7): [True: 8.63k, False: 1]
  ------------------
   59|  8.63k|    return;
   60|       |
   61|       |  /* Suppress all log output */
   62|      1|  auto *logMgr = new Ogre::LogManager();
   63|      1|  logMgr->createLog("fuzz.log", true, false, true); /* suppressFileOutput */
   64|      1|  logMgr->setMinLogLevel(Ogre::LML_CRITICAL);
   65|       |
   66|       |  /* Create singletons needed for Mesh/Skeleton operations */
   67|      1|  new Ogre::ResourceGroupManager();
   68|      1|  new Ogre::LodStrategyManager();
   69|      1|  new Ogre::DefaultHardwareBufferManager();
   70|      1|  new Ogre::MeshManager();
   71|      1|  new Ogre::SkeletonManager();
   72|      1|  auto *matMgr = new Ogre::MaterialManager();
   73|      1|  matMgr->initialise();
   74|       |
   75|      1|  g_initialized = true;
   76|      1|}
ogre_deep_fuzz.cpp:_ZL9fuzz_meshPKhm:
   78|  5.79k|static void fuzz_mesh(const uint8_t *data, size_t size) {
   79|       |  // manual, so we can load it from memory without a file
   80|  5.79k|  auto mesh = Ogre::MeshManager::getSingleton().create("fuzz.mesh", "General", true);
   81|  5.79k|  mesh->load(); // ensure cleanup runs
   82|       |
   83|  5.79k|  Ogre::DataStreamPtr stream(
   84|  5.79k|      new Ogre::MemoryDataStream(const_cast<uint8_t *>(data), size, false, true));
   85|       |
   86|  5.79k|  Ogre::MeshSerializer serializer;
   87|  5.79k|  try {
   88|  5.79k|    serializer.importMesh(stream, mesh.get());
   89|  5.79k|  } catch (std::exception &) {
   90|  2.01k|  }
   91|       |
   92|  5.79k|  Ogre::MeshManager::getSingleton().remove(mesh);
   93|  5.79k|}
ogre_deep_fuzz.cpp:_ZL13fuzz_skeletonPKhm:
   95|  1.32k|static void fuzz_skeleton(const uint8_t *data, size_t size) {
   96|       |  // manual, so we can load it from memory without a file
   97|  1.32k|  auto skeleton = Ogre::SkeletonManager::getSingleton().create("fuzz.skeleton", "General", true);
   98|  1.32k|  skeleton->prepare();   // ensure cleanup runs
   99|       |
  100|  1.32k|  Ogre::DataStreamPtr stream(
  101|  1.32k|      new Ogre::MemoryDataStream(const_cast<uint8_t *>(data), size, false, true));
  102|       |
  103|  1.32k|  Ogre::SkeletonSerializer serializer;
  104|  1.32k|  try {
  105|  1.32k|    serializer.importSkeleton(stream, skeleton.get());
  106|  1.32k|  } catch (std::exception &) {
  107|    596|  }
  108|       |
  109|  1.32k|  Ogre::SkeletonManager::getSingleton().remove(skeleton);
  110|  1.32k|}
ogre_deep_fuzz.cpp:_ZL11fuzz_configPKhm:
  112|  1.08k|static void fuzz_config(const uint8_t *data, size_t size) {
  113|  1.08k|  Ogre::DataStreamPtr stream(new Ogre::MemoryDataStream(
  114|  1.08k|      "fuzz.cfg", const_cast<uint8_t *>(data), size, false, true));
  115|       |
  116|  1.08k|  Ogre::ConfigFile cf;
  117|  1.08k|  try {
  118|  1.08k|    cf.load(stream);
  119|       |
  120|       |    /* Exercise iteration over parsed sections and settings */
  121|  6.10k|    for (auto &sec : cf.getSettingsBySection()) {
  ------------------
  |  Branch (121:20): [True: 6.10k, False: 1.08k]
  ------------------
  122|  16.0k|      for (auto &kv : sec.second) {
  ------------------
  |  Branch (122:21): [True: 16.0k, False: 6.10k]
  ------------------
  123|  16.0k|        volatile const char *k = kv.first.c_str();
  124|  16.0k|        volatile const char *v = kv.second.c_str();
  125|  16.0k|        (void)k;
  126|  16.0k|        (void)v;
  127|  16.0k|      }
  128|  6.10k|    }
  129|  1.08k|  } catch (Ogre::Exception &) {
  130|      0|  } catch (std::exception &) {
  131|      0|  }
  132|  1.08k|}
ogre_deep_fuzz.cpp:_ZL22fuzz_stream_serialiserPKhm:
  134|    436|static void fuzz_stream_serialiser(const uint8_t *data, size_t size) {
  135|    436|  Ogre::DataStreamPtr stream(
  136|    436|      new Ogre::MemoryDataStream(const_cast<uint8_t *>(data), size, false, true));
  137|       |
  138|    436|  try {
  139|    436|    Ogre::StreamSerialiser serialiser(stream);
  140|       |
  141|       |    /* Try to read multiple chunks, exercising the chunk state machine */
  142|  1.53k|    for (int i = 0; i < 32; i++) {
  ------------------
  |  Branch (142:21): [True: 1.52k, False: 6]
  ------------------
  143|  1.52k|      const Ogre::StreamSerialiser::Chunk *c = serialiser.readChunkBegin();
  144|  1.52k|      if (!c)
  ------------------
  |  Branch (144:11): [True: 0, False: 1.52k]
  ------------------
  145|      0|        break;
  146|       |
  147|       |      /* Try reading various data types from the chunk */
  148|  1.52k|      Ogre::String str;
  149|  1.52k|      try { serialiser.read(&str); } catch (...) {}
  150|       |
  151|  1.52k|      Ogre::Real r;
  152|  1.09k|      try { serialiser.read(&r); } catch (...) {}
  153|       |
  154|  1.09k|      Ogre::Vector3 v3;
  155|  1.09k|      try { serialiser.read(&v3); } catch (...) {}
  156|       |
  157|  1.09k|      Ogre::Vector4 v4;
  158|  1.09k|      try { serialiser.read(&v4); } catch (...) {}
  159|       |
  160|  1.09k|      serialiser.readChunkEnd(c->id);
  161|  1.09k|    }
  162|    436|  } catch (Ogre::Exception &) {
  163|    430|  } catch (std::exception &) {
  164|      0|  }
  165|    436|}

