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

_ZN4Ogre28DefaultHardwareBufferManagerC2Ev:
   88|      1|        DefaultHardwareBufferManager() : mImpl(new DefaultHardwareBufferManagerBase()) {}

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

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

_ZN4Ogre9SharedPtrINS_10DataStreamEEC2INS_16MemoryDataStreamEEEPT_:
   50|  3.62k|        explicit SharedPtr(Y* ptr) : shared_ptr<T>(ptr) {}
_ZN4Ogre9SharedPtrINS_8ResourceEEC2INS_4MeshEEERKNS0_IT_EE:
   55|  1.82k|        SharedPtr(const SharedPtr<Y>& r) : shared_ptr<T>(r) {}
_ZN4Ogre9SharedPtrINS_8ResourceEEC2INS_8SkeletonEEERKNS0_IT_EE:
   55|    734|        SharedPtr(const SharedPtr<Y>& r) : shared_ptr<T>(r) {}

_ZN4Ogre16StreamSerialiser5ChunkC2Ev:
  105|     49|            Chunk() : id(0), version(1), length(0), offset(0) {}
_ZN4Ogre16StreamSerialiser4readIjEEvPT_m:
  301|    140|        {
  302|    140|            readData(pT, sizeof(T), count);
  303|    140|        }
_ZN4Ogre16StreamSerialiser4readItEEvPT_m:
  301|     49|        {
  302|     49|            readData(pT, sizeof(T), count);
  303|     49|        }
_ZN4Ogre16StreamSerialiser4readIcEEvPT_m:
  301|      1|        {
  302|      1|            readData(pT, sizeof(T), count);
  303|      1|        }

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

_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|    }

_ZN4Ogre10ConfigFileC2Ev:
   38|    936|    {
   39|    936|    }
_ZN4Ogre10ConfigFile5clearEv:
   42|    936|    {
   43|    936|        mSettings.clear();
   44|    936|        mSettingsPtr.clear();
   45|    936|    }
_ZN4Ogre10ConfigFile4loadERKNS_9SharedPtrINS_10DataStreamEEERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEb:
   74|    936|    {
   75|       |        /* Clear current settings map */
   76|    936|        clear();
   77|       |
   78|    936|        String currentSection = BLANKSTRING;
   79|    936|        SettingsMultiMap* currentSettings = &mSettings[currentSection];
   80|    936|        mSettingsPtr[currentSection] = currentSettings;
   81|       |
   82|       |
   83|       |        /* Process the file line for line */
   84|    936|        String line, optName, optVal;
   85|  35.3k|        while (!stream->eof())
  ------------------
  |  Branch (85:16): [True: 34.4k, False: 936]
  ------------------
   86|  34.4k|        {
   87|  34.4k|            line = stream->getLine();
   88|       |            /* Ignore comments & blanks */
   89|  34.4k|            if (line.length() > 0 && line.at(0) != '#' && line.at(0) != '@')
  ------------------
  |  Branch (89:17): [True: 30.2k, False: 4.22k]
  |  Branch (89:38): [True: 29.8k, False: 378]
  |  Branch (89:59): [True: 29.4k, False: 405]
  ------------------
   90|  29.4k|            {
   91|  29.4k|                if (line.at(0) == '[' && line.at(line.length()-1) == ']')
  ------------------
  |  Branch (91:21): [True: 9.35k, False: 20.0k]
  |  Branch (91:42): [True: 7.08k, False: 2.27k]
  ------------------
   92|  7.08k|                {
   93|       |                    // Section
   94|  7.08k|                    currentSection = line.substr(1, line.length() - 2);
   95|  7.08k|                    currentSettings = &mSettings[currentSection];
   96|  7.08k|                    mSettingsPtr[currentSection] = currentSettings;
   97|  7.08k|                }
   98|  22.3k|                else
   99|  22.3k|                {
  100|       |                    /* Find the first separator character and split the string there */
  101|  22.3k|                    Ogre::String::size_type separator_pos = line.find_first_of(separators, 0);
  102|  22.3k|                    if (separator_pos != Ogre::String::npos)
  ------------------
  |  Branch (102:25): [True: 17.0k, False: 5.28k]
  ------------------
  103|  17.0k|                    {
  104|  17.0k|                        optName = line.substr(0, separator_pos);
  105|       |                        /* Find the first non-separator character following the name */
  106|  17.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|  17.0k|                        optVal = (nonseparator_pos == Ogre::String::npos) ? "" : line.substr(nonseparator_pos);
  ------------------
  |  Branch (109:34): [True: 3.66k, False: 13.4k]
  ------------------
  110|  17.0k|                        if (trimWhitespace)
  ------------------
  |  Branch (110:29): [True: 17.0k, False: 0]
  ------------------
  111|  17.0k|                        {
  112|  17.0k|                            StringUtil::trim(optVal);
  113|  17.0k|                            StringUtil::trim(optName);
  114|  17.0k|                        }
  115|  17.0k|                        currentSettings->emplace(optName, optVal);
  116|  17.0k|                    }
  117|  22.3k|                }
  118|  29.4k|            }
  119|  34.4k|        }
  120|    936|    }

_ZN4Ogre10DataStream7getLineEb:
   41|  38.6k|    {
   42|  38.6k|        char tmpBuf[OGRE_STREAM_TEMP_SIZE];
   43|  38.6k|        String retString;
   44|  38.6k|        size_t readCount;
   45|       |        // Keep looping while not hitting delimiter
   46|   219k|        while ((readCount = read(tmpBuf, OGRE_STREAM_TEMP_SIZE-1)) != 0)
  ------------------
  |  Branch (46:16): [True: 218k, False: 997]
  ------------------
   47|   218k|        {
   48|       |            // Terminate string
   49|   218k|            tmpBuf[readCount] = '\0';
   50|       |
   51|   218k|            char* p = strchr(tmpBuf, '\n');
   52|   218k|            if (p != 0)
  ------------------
  |  Branch (52:17): [True: 37.6k, False: 180k]
  ------------------
   53|  37.6k|            {
   54|       |                // Reposition backwards
   55|  37.6k|                skip((long)(p + 1 - tmpBuf - readCount));
   56|  37.6k|                *p = '\0';
   57|  37.6k|            }
   58|       |
   59|   218k|            retString += tmpBuf;
   60|       |
   61|   218k|            if (p != 0)
  ------------------
  |  Branch (61:17): [True: 37.6k, False: 180k]
  ------------------
   62|  37.6k|            {
   63|       |                // Trim off trailing CR if this was a CR/LF entry
   64|  37.6k|                if (retString.length() && retString[retString.length()-1] == '\r')
  ------------------
  |  Branch (64:21): [True: 35.2k, False: 2.45k]
  |  Branch (64:43): [True: 7.90k, False: 27.3k]
  ------------------
   65|  7.90k|                {
   66|  7.90k|                    retString.erase(retString.length()-1, 1);
   67|  7.90k|                }
   68|       |
   69|       |                // Found terminator, break out
   70|  37.6k|                break;
   71|  37.6k|            }
   72|   218k|        }
   73|       |
   74|  38.6k|        if (trimAfter)
  ------------------
  |  Branch (74:13): [True: 34.4k, False: 4.24k]
  ------------------
   75|  34.4k|        {
   76|  34.4k|            StringUtil::trim(retString);
   77|  34.4k|        }
   78|       |
   79|  38.6k|        return retString;
   80|  38.6k|    }
_ZN4Ogre16MemoryDataStreamC2EPvmbb:
  190|  2.69k|        : DataStream(static_cast<uint16>(readOnly ? READ : (READ | WRITE)))
  ------------------
  |  Branch (190:42): [True: 2.69k, False: 0]
  ------------------
  191|  2.69k|    {
  192|  2.69k|        mData = mPos = static_cast<uchar*>(pMem);
  193|  2.69k|        mSize = inSize;
  194|  2.69k|        mEnd = mData + mSize;
  195|  2.69k|        mFreeOnClose = freeOnClose;
  196|       |        assert(mEnd >= mPos);
  197|  2.69k|    }
_ZN4Ogre16MemoryDataStreamC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPvmbb:
  201|    936|        : DataStream(name, static_cast<uint16>(readOnly ? READ : (READ | WRITE)))
  ------------------
  |  Branch (201:48): [True: 936, False: 0]
  ------------------
  202|    936|    {
  203|    936|        mData = mPos = static_cast<uchar*>(pMem);
  204|    936|        mSize = inSize;
  205|    936|        mEnd = mData + mSize;
  206|    936|        mFreeOnClose = freeOnClose;
  207|       |        assert(mEnd >= mPos);
  208|    936|    }
_ZN4Ogre16MemoryDataStreamD2Ev:
  338|  3.62k|    {
  339|  3.62k|        close();
  340|  3.62k|    }
_ZN4Ogre16MemoryDataStream4readEPvm:
  343|   233k|    {
  344|       |        // Read over end of memory?
  345|   233k|        if (mPos >= mEnd)
  ------------------
  |  Branch (345:13): [True: 1.02k, False: 232k]
  ------------------
  346|  1.02k|            return 0;
  347|   232k|        size_t cnt = std::min(count, static_cast<size_t>(mEnd - mPos));
  348|   232k|        if (cnt == 0)
  ------------------
  |  Branch (348:13): [True: 0, False: 232k]
  ------------------
  349|      0|            return 0;
  350|       |
  351|   232k|        assert (cnt<=count);
  352|       |
  353|   232k|        memcpy(buf, mPos, cnt);
  354|   232k|        mPos += cnt;
  355|   232k|        return cnt;
  356|   232k|    }
_ZN4Ogre16MemoryDataStream4skipEl:
  435|  42.1k|    {
  436|  42.1k|        size_t newpos = (size_t)( ( mPos - mData ) + count );
  437|  42.1k|        assert( mData + newpos <= mEnd );        
  438|       |
  439|  42.1k|        mPos = mData + newpos;
  440|  42.1k|    }
_ZN4Ogre16MemoryDataStream4seekEm:
  443|  1.79k|    {
  444|       |        assert( mData + pos <= mEnd );
  445|  1.79k|        mPos = mData + pos;
  446|  1.79k|    }
_ZNK4Ogre16MemoryDataStream4tellEv:
  449|  6.71k|    {
  450|       |        //mData is start, mPos is current location
  451|  6.71k|        return mPos - mData;
  452|  6.71k|    }
_ZNK4Ogre16MemoryDataStream3eofEv:
  455|  37.9k|    {
  456|  37.9k|        return mPos >= mEnd;
  457|  37.9k|    }
_ZN4Ogre16MemoryDataStream5closeEv:
  460|  3.62k|    {
  461|  3.62k|        mAccess = 0;
  462|  3.62k|        if (mFreeOnClose && mData)
  ------------------
  |  Branch (462:13): [True: 0, False: 3.62k]
  |  Branch (462:29): [True: 0, False: 0]
  ------------------
  463|      0|        {
  464|       |            OGRE_FREE(mData, MEMCATEGORY_GENERAL);
  465|      0|            mData = 0;
  466|      0|        }
  467|  3.62k|    }

_ZN4Ogre32DefaultHardwareBufferManagerBaseC2Ev:
   72|      1|    {
   73|      1|    }

_ZN4Ogre23DistanceLodStrategyBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   37|      2|        : LodStrategy(name)
   38|      2|        , mReferenceViewEnabled(false)
   39|      2|        , mReferenceViewValue(-1)
   40|      2|    { }
_ZNK4Ogre23DistanceLodStrategyBase12getBaseValueEv:
   76|  1.82k|    {
   77|  1.82k|        return Real(0);
   78|  1.82k|    }
_ZN4Ogre25DistanceLodSphereStrategyC2Ev:
  161|      1|        : DistanceLodStrategyBase("distance_sphere")
  162|      1|    { }
_ZN4Ogre22DistanceLodBoxStrategyC2Ev:
  192|      1|        : DistanceLodStrategyBase("distance_box")
  193|      1|    { }

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

_ZN4Ogre21HardwareBufferManager15getSingletonPtrEv:
   36|  1.82k|    {
   37|  1.82k|        return msSingleton;
   38|  1.82k|    }
_ZN4Ogre21HardwareBufferManagerC2Ev:
   45|      1|    {
   46|      1|    }
_ZN4Ogre25HardwareBufferManagerBaseC2Ev:
   58|      2|        : mUnderUsedFrameCount(0)
   59|      2|    {
   60|      2|    }

_ZN4Ogre11LodStrategyC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   35|      4|        : mName(name)
   36|      4|    { }

_ZN4Ogre18LodStrategyManager12getSingletonEv:
   43|  1.82k|    {
   44|       |        assert( msSingleton );  return ( *msSingleton );
   45|  1.82k|    }
_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|    }
_ZN4Ogre18LodStrategyManager18setDefaultStrategyEPNS_11LodStrategyE:
  131|      1|    {
  132|      1|        mDefaultStrategy = strategy;
  133|      1|    }
_ZN4Ogre18LodStrategyManager18getDefaultStrategyEv:
  142|  1.82k|    {
  143|  1.82k|        return mDefaultStrategy;
  144|  1.82k|    }

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

_ZN4Ogre10LogManager12getSingletonEv:
   39|     15|    {  
   40|       |        assert( msSingleton );  return ( *msSingleton );  
   41|     15|    }
_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|      6|    {
  126|      6|        OGRE_LOCK_AUTO_MUTEX;
  127|      6|        if (mDefaultLog)
  ------------------
  |  Branch (127:13): [True: 6, False: 0]
  ------------------
  128|      6|        {
  129|      6|            mDefaultLog->logMessage(message, lml, maskDebug);
  130|      6|        }
  131|      6|    }
_ZN4Ogre10LogManager10logWarningERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
  139|      8|    {
  140|      8|        stream(LML_WARNING, maskDebug) << "Warning: " << message;
  141|      8|    }
_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|      9|    {
  165|      9|            OGRE_LOCK_AUTO_MUTEX;
  166|      9|        OgreAssert(mDefaultLog, "Default log not found");
  ------------------
  |  Branch (166:9): [True: 0, False: 9]
  ------------------
  167|      9|        return mDefaultLog->stream(lml, maskDebug);
  168|      9|    }

_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|      5|    {
   45|       |        assert( msSingleton );  return ( *msSingleton );
   46|      5|    }
_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|    }
_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|	}

_ZN4Ogre4MeshC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE:
   45|  1.82k|        : Resource(creator, name, handle, group, isManual, loader),
   46|  1.82k|        mBoundRadius(0.0f),
   47|  1.82k|        mBoneBoundingRadius(0.0f),
   48|  1.82k|        mBoneAssignmentsOutOfDate(false),
   49|  1.82k|        mLodStrategy(LodStrategyManager::getSingleton().getDefaultStrategy()),
   50|  1.82k|        mHasManualLodLevel(false),
   51|  1.82k|        mNumLods(1),
   52|  1.82k|        mBufferManager(0),
   53|  1.82k|        mVertexBufferUsage(HBU_GPU_ONLY),
   54|  1.82k|        mIndexBufferUsage(HBU_GPU_ONLY),
   55|  1.82k|        mVertexBufferShadowBuffer(false),
   56|  1.82k|        mIndexBufferShadowBuffer(false),
   57|  1.82k|        mPreparedForShadowVolumes(false),
   58|  1.82k|        mEdgeListsBuilt(false),
   59|  1.82k|        mAutoBuildEdgeLists(false), // will be set to true by serializers of 1.20 and below
   60|  1.82k|        mSharedVertexDataAnimationType(VAT_NONE),
   61|  1.82k|        mSharedVertexDataAnimationIncludesNormals(false),
   62|  1.82k|        mAnimationTypesDirty(true),
   63|  1.82k|        mPosesIncludeNormals(false),
   64|  1.82k|        sharedVertexData(0)
   65|  1.82k|    {
   66|       |        // Init first (manual) lod
   67|  1.82k|        MeshLodUsage lod;
   68|  1.82k|        lod.userValue = 0; // User value not used for base LOD level
   69|  1.82k|        lod.value = getLodStrategy()->getBaseValue();
   70|       |        lod.edgeData = NULL;
   71|  1.82k|        lod.manualMesh.reset();
   72|  1.82k|        mMeshLodUsageList.push_back(lod);
   73|  1.82k|    }
_ZN4Ogre4MeshD2Ev:
   76|  1.82k|    {
   77|  1.82k|        if (!HardwareBufferManager::getSingletonPtr()) // LogManager might be also gone already
  ------------------
  |  Branch (77:13): [True: 0, False: 1.82k]
  ------------------
   78|      0|        {
   79|      0|            printf("ERROR: '%s' is being destroyed after HardwareBufferManager. This is a bug in user code.\n", mName.c_str());
   80|      0|            OgreAssertDbg(false,  "Mesh destroyed after HardwareBufferManager"); // assert in debug mode
   81|      0|            return; // try not to crash
   82|      0|        }
   83|       |        // have to call this here reather than in Resource destructor
   84|       |        // since calling virtual methods in base destructors causes crash
   85|  1.82k|        unload();
   86|  1.82k|    }
_ZNK4Ogre4Mesh14getLodStrategyEv:
 2340|  1.82k|    {
 2341|  1.82k|        return mLodStrategy;
 2342|  1.82k|    }
_ZN4Ogre4Mesh21_convertVertexElementENS_21VertexElementSemanticENS_17VertexElementTypeE:
 2361|     18|    {
 2362|     18|        if (sharedVertexData)
  ------------------
  |  Branch (2362:13): [True: 0, False: 18]
  ------------------
 2363|      0|            sharedVertexData->convertVertexElement(semantic, dstType);
 2364|       |
 2365|     18|        for (auto s : getSubMeshes())
  ------------------
  |  Branch (2365:21): [True: 0, False: 18]
  ------------------
 2366|      0|            if (s->vertexData)
  ------------------
  |  Branch (2366:17): [True: 0, False: 0]
  ------------------
 2367|      0|                s->vertexData->convertVertexElement(semantic, dstType);
 2368|     18|    }

_ZN4Ogre11MeshManager12getSingletonEv:
   58|  3.64k|    {  
   59|       |        assert( msSingleton );  return ( *msSingleton );  
   60|  3.64k|    }
_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|  1.82k|    {
  148|  1.82k|        return static_pointer_cast<Mesh>(createResource(name,group,isManual,loader,createParams));
  149|  1.82k|    }
_ZN4Ogre11MeshManager10createImplERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmS9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
  363|  1.82k|    {
  364|       |        // no use for createParams here
  365|       |        return OGRE_NEW Mesh(this, name, handle, group, isManual, loader);
  366|  1.82k|    }
_ZNK4Ogre9MeshCodec7getTypeEv:
   39|      1|        String getType() const override { return "mesh"; }

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

_ZN4Ogre18MeshSerializerImplC2Ev:
   58|  12.7k|    {
   59|       |        // Version number
   60|  12.7k|        mVersion = "[MeshSerializer_v1.100]";
   61|  12.7k|    }
_ZN4Ogre18MeshSerializerImplD2Ev:
   64|  12.7k|    {
   65|  12.7k|    }
_ZN4Ogre18MeshSerializerImpl10importMeshERKNS_9SharedPtrINS_10DataStreamEEEPNS_4MeshEPNS_22MeshSerializerListenerE:
  104|  1.72k|    {
  105|       |        // Determine endianness (must be the first thing we do!)
  106|  1.72k|        determineEndianness(stream);
  107|       |
  108|       |#if OGRE_SERIALIZER_VALIDATE_CHUNKSIZE
  109|       |        enableValidation();
  110|       |#endif
  111|       |        // Check header
  112|  1.72k|        readFileHeader(stream);
  113|  1.72k|        pushInnerChunk(stream);
  114|  1.72k|        unsigned short streamID = readChunk(stream);
  115|       |
  116|  1.73k|        while(!stream->eof())
  ------------------
  |  Branch (116:15): [True: 11, False: 1.72k]
  ------------------
  117|     11|        {
  118|     11|            switch (streamID)
  ------------------
  |  Branch (118:21): [True: 0, False: 11]
  ------------------
  119|     11|            {
  120|      0|            case M_MESH:
  ------------------
  |  Branch (120:13): [True: 0, False: 11]
  ------------------
  121|      0|                readMesh(stream, pMesh, listener);
  122|      0|                break;
  123|     11|            }
  124|       |
  125|     11|            streamID = readChunk(stream);
  126|     11|        }
  127|  1.72k|        popInnerChunk(stream);
  128|  1.72k|    }
_ZN4Ogre23MeshSerializerImpl_v1_8C2Ev:
 2627|  10.9k|    {
 2628|       |        // Version number
 2629|  10.9k|        mVersion = "[MeshSerializer_v1.8]";
 2630|  10.9k|    }
_ZN4Ogre24MeshSerializerImpl_v1_41C2Ev:
 3067|  9.11k|    {
 3068|       |        // Version number
 3069|  9.11k|        mVersion = "[MeshSerializer_v1.41]";
 3070|  9.11k|    }
_ZN4Ogre23MeshSerializerImpl_v1_4C2Ev:
 3221|  7.28k|    {
 3222|       |        // Version number
 3223|  7.28k|        mVersion = "[MeshSerializer_v1.40]";
 3224|  7.28k|    }
_ZN4Ogre23MeshSerializerImpl_v1_3C2Ev:
 3446|  5.46k|    {
 3447|       |        // Version number
 3448|  5.46k|        mVersion = "[MeshSerializer_v1.30]";
 3449|  5.46k|    }
_ZN4Ogre23MeshSerializerImpl_v1_2C2Ev:
 3869|  3.64k|    {
 3870|       |        // Version number
 3871|  3.64k|        mVersion = "[MeshSerializer_v1.20]";
 3872|  3.64k|    }
_ZN4Ogre23MeshSerializerImpl_v1_1C2Ev:
 4015|  1.82k|    {
 4016|       |        // Version number
 4017|  1.82k|        mVersion = "[MeshSerializer_v1.10]";
 4018|  1.82k|    }

_ZN4Ogre4NodeC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   35|      1|        :mParent(0),
   36|      1|        mName(name),
   37|      1|        mNeedParentUpdate(false),
   38|      1|        mNeedChildUpdate(false),
   39|      1|        mParentNotified(false),
   40|      1|        mQueuedForUpdate(false),
   41|      1|        mInheritOrientation(true),
   42|      1|        mInheritScale(true),
   43|      1|        mCachedTransformOutOfDate(true),
   44|      1|        mOrientation(Quaternion::IDENTITY),
   45|      1|        mPosition(Vector3::ZERO),
   46|      1|        mScale(Vector3::UNIT_SCALE),
   47|      1|        mDerivedOrientation(Quaternion::IDENTITY),
   48|      1|        mDerivedPosition(Vector3::ZERO),
   49|      1|        mDerivedScale(Vector3::UNIT_SCALE),
   50|      1|        mInitialPosition(Vector3::ZERO),
   51|      1|        mInitialOrientation(Quaternion::IDENTITY),
   52|      1|        mInitialScale(Vector3::UNIT_SCALE),
   53|      1|        mListener(0)
   54|      1|    {
   55|      1|        needUpdate();
   56|      1|    }
_ZNK4Ogre4Node17_updateFromParentEv:
  196|      1|    {
  197|      1|        updateFromParentImpl();
  198|       |
  199|       |        // Call listener (note, this method only called if there's something to do)
  200|      1|        if (mListener)
  ------------------
  |  Branch (200:13): [True: 0, False: 1]
  ------------------
  201|      0|        {
  202|      0|            mListener->nodeUpdated(this);
  203|      0|        }
  204|      1|    }
_ZNK4Ogre4Node20updateFromParentImplEv:
  207|      1|    {
  208|      1|        mCachedTransformOutOfDate = true;
  209|       |
  210|      1|        if (mParent)
  ------------------
  |  Branch (210:13): [True: 0, False: 1]
  ------------------
  211|      0|        {
  212|       |#if OGRE_NODE_INHERIT_TRANSFORM
  213|       |            // Decompose full transform to position, orientation and scale, shear is lost here.
  214|       |            _getFullTransform().decomposition(mDerivedPosition, mDerivedScale, mDerivedOrientation);
  215|       |#else
  216|       |            // Update orientation
  217|      0|            const Quaternion& parentOrientation = mParent->_getDerivedOrientation();
  218|      0|            if (mInheritOrientation)
  ------------------
  |  Branch (218:17): [True: 0, False: 0]
  ------------------
  219|      0|            {
  220|       |                // Combine orientation with that of parent
  221|      0|                mDerivedOrientation = parentOrientation * mOrientation;
  222|      0|            }
  223|      0|            else
  224|      0|            {
  225|       |                // No inheritance
  226|      0|                mDerivedOrientation = mOrientation;
  227|      0|            }
  228|       |
  229|       |            // Update scale
  230|      0|            const Vector3& parentScale = mParent->_getDerivedScale();
  231|      0|            if (mInheritScale)
  ------------------
  |  Branch (231:17): [True: 0, False: 0]
  ------------------
  232|      0|            {
  233|       |                // Scale own position by parent scale, NB just combine
  234|       |                // as equivalent axes, no shearing
  235|      0|                mDerivedScale = parentScale * mScale;
  236|      0|            }
  237|      0|            else
  238|      0|            {
  239|       |                // No inheritance
  240|      0|                mDerivedScale = mScale;
  241|      0|            }
  242|       |
  243|       |            // Change position vector based on parent's orientation & scale
  244|      0|            mDerivedPosition = parentOrientation * (parentScale * mPosition);
  245|       |
  246|       |            // Add altered position vector to parents
  247|      0|            mDerivedPosition += mParent->_getDerivedPosition();
  248|      0|#endif
  249|      0|        }
  250|      1|        else
  251|      1|        {
  252|       |            // Root node, no parent
  253|      1|            mDerivedOrientation = mOrientation;
  254|      1|            mDerivedPosition = mPosition;
  255|      1|            mDerivedScale = mScale;
  256|      1|        }
  257|       |
  258|      1|        mNeedParentUpdate = false;
  259|       |
  260|      1|    }
_ZN4Ogre4Node14setOrientationERKNS_10QuaternionE:
  343|      1|    {
  344|      1|#ifndef OGRE_FAST_MATH
  345|      1|        OgreAssertDbg(!q.isNaN(), "Invalid orientation supplied as parameter");
  346|      1|#endif
  347|      1|        mOrientation = q;
  348|      1|        mOrientation.normalise();
  349|      1|        needUpdate();
  350|      1|    }
_ZN4Ogre4Node11setPositionERKNS_6VectorILi3EfEE:
  365|      1|    {
  366|      1|#ifndef OGRE_FAST_MATH
  367|       |        assert(!pos.isNaN() && "Invalid vector supplied as parameter");
  368|      1|#endif
  369|      1|        mPosition = pos;
  370|      1|        needUpdate();
  371|      1|    }
_ZNK4Ogre4Node22_getDerivedOrientationEv:
  452|      1|    {
  453|      1|        if (mNeedParentUpdate)
  ------------------
  |  Branch (453:13): [True: 0, False: 1]
  ------------------
  454|      0|        {
  455|      0|            _updateFromParent();
  456|      0|        }
  457|      1|        return mDerivedOrientation;
  458|      1|    }
_ZNK4Ogre4Node19_getDerivedPositionEv:
  461|      1|    {
  462|      1|        if (mNeedParentUpdate)
  ------------------
  |  Branch (462:13): [True: 1, False: 0]
  ------------------
  463|      1|        {
  464|      1|            _updateFromParent();
  465|      1|        }
  466|      1|        return mDerivedPosition;
  467|      1|    }
_ZNK4Ogre4Node16_getDerivedScaleEv:
  470|      1|    {
  471|      1|        if (mNeedParentUpdate)
  ------------------
  |  Branch (471:13): [True: 0, False: 1]
  ------------------
  472|      0|        {
  473|      0|            _updateFromParent();
  474|      0|        }
  475|      1|        return mDerivedScale;
  476|      1|    }
_ZN4Ogre4Node15setInitialStateEv:
  600|      1|    {
  601|      1|        mInitialPosition = mPosition;
  602|      1|        mInitialOrientation = mOrientation;
  603|      1|        mInitialScale = mScale;
  604|      1|    }
_ZN4Ogre4Node10needUpdateEb:
  680|      3|    {
  681|       |
  682|      3|        mNeedParentUpdate = true;
  683|      3|        mNeedChildUpdate = true;
  684|      3|        mCachedTransformOutOfDate = true;
  685|       |
  686|       |        // Make sure we're not root and parent hasn't been notified before
  687|      3|        if (mParent && (!mParentNotified || forceParentUpdate))
  ------------------
  |  Branch (687:13): [True: 0, False: 3]
  |  Branch (687:25): [True: 0, False: 0]
  |  Branch (687:45): [True: 0, False: 0]
  ------------------
  688|      0|        {
  689|      0|            mParent->requestUpdate(this, forceParentUpdate);
  690|      0|            mParentNotified = true ;
  691|      0|        }
  692|       |
  693|       |        // all children will be updated
  694|      3|        mChildrenToUpdate.clear();
  695|      3|    }

_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:
 1040|      2|        : mPreferGeneralVersionForSharedBuffers(false)
 1041|      2|    {
 1042|       |        // For AMD Athlon XP (but not that for Althon 64), it's prefer to never use
 1043|       |        // unrolled version for shared buffers at all, I guess because that version
 1044|       |        // run out of usable CPU registers, or L1/L2 cache related problem, causing
 1045|       |        // slight performance loss than general version.
 1046|       |        //
 1047|      2|#if __OGRE_HAVE_NEON == 0
 1048|      2|        if (PlatformInformation::getCpuIdentifier().find("AuthenticAMD") != String::npos)
  ------------------
  |  Branch (1048:13): [True: 2, False: 0]
  ------------------
 1049|      2|        {
 1050|       |            // How can I check it's an Athlon XP but not Althon 64?
 1051|       |            // Ok, just test whether supports SSE2/SSE3 or not, if not,
 1052|       |            // assume general version faster than unrolled version :)
 1053|       |            //
 1054|      2|            if (!(PlatformInformation::getCpuFeatures() &
  ------------------
  |  Branch (1054:17): [True: 0, False: 2]
  ------------------
 1055|      2|                (PlatformInformation::CPU_FEATURE_SSE2 | PlatformInformation::CPU_FEATURE_SSE3)))
 1056|      0|            {
 1057|      0|                mPreferGeneralVersionForSharedBuffers = true;
 1058|      0|            }
 1059|      2|        }
 1060|      2|#endif
 1061|      2|    }
_ZN4Ogre20_getOptimisedUtilSSEEv:
 2141|      2|    {
 2142|      2|        static OptimisedUtilSSE msOptimisedUtilSSE;
 2143|       |#if defined(__OGRE_SIMD_ALIGN_STACK)
 2144|       |        static OptimisedUtilWithStackAlign msOptimisedUtilWithStackAlign(&msOptimisedUtilSSE);
 2145|       |        return &msOptimisedUtilWithStackAlign;
 2146|       |#else
 2147|      2|        return &msOptimisedUtilSSE;
 2148|      2|#endif
 2149|      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|    { }
_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|      4|    {
  662|      4|        static const uint sFeatures = _detectCpuFeatures();
  663|      4|        return sFeatures;
  664|      4|    }
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|     70|                for (uint i=0x80000000; i<=nExIds; ++i)
  ------------------
  |  Branch (458:41): [True: 68, False: 2]
  ------------------
  459|     68|                {
  460|     68|                    _performCpuid(i, result);
  461|       |
  462|       |                    // Interpret CPU brand string and cache information.
  463|     68|                    if  (i == 0x80000002)
  ------------------
  |  Branch (463:26): [True: 2, False: 66]
  ------------------
  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|     66|                    else if  (i == 0x80000003)
  ------------------
  |  Branch (470:31): [True: 2, False: 64]
  ------------------
  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|     64|                    else if  (i == 0x80000004)
  ------------------
  |  Branch (477:31): [True: 2, False: 62]
  ------------------
  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|     68|                }
  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|     82|    {
  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|     82|        __asm__
  163|     82|        (
  164|     82|            "cpuid": "=a" (result._eax), "=b" (result._ebx), "=c" (result._ecx), "=d" (result._edx) : "a" (query)
  165|     82|        );
  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|     82|        return result._eax;
  178|       |
  179|       |#else
  180|       |        // TODO: Supports other compiler
  181|       |        return 0;
  182|       |#endif
  183|     82|    }
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: 0, False: 2]
  ------------------
  309|      0|                {
  310|      0|                    if (result._eax > 2)
  ------------------
  |  Branch (310:25): [True: 0, False: 0]
  ------------------
  311|      0|                        features |= PlatformInformation::CPU_FEATURE_PRO;
  312|       |
  313|       |                    // Check standard feature
  314|      0|                    _performCpuid(CPUID_FUNC_STANDARD_FEATURES, result);
  ------------------
  |  |  269|      0|#define CPUID_FUNC_STANDARD_FEATURES         0x1
  ------------------
  315|       |
  316|      0|                    if (result._edx & CPUID_STD_FPU)
  ------------------
  |  |  274|      0|#define CPUID_STD_FPU               (1<<0)
  ------------------
  |  Branch (316:25): [True: 0, False: 0]
  ------------------
  317|      0|                        features |= PlatformInformation::CPU_FEATURE_FPU;
  318|      0|                    if (result._edx & CPUID_STD_TSC)
  ------------------
  |  |  275|      0|#define CPUID_STD_TSC               (1<<4)
  ------------------
  |  Branch (318:25): [True: 0, False: 0]
  ------------------
  319|      0|                        features |= PlatformInformation::CPU_FEATURE_TSC;
  320|      0|                    if (result._edx & CPUID_STD_CMOV)
  ------------------
  |  |  276|      0|#define CPUID_STD_CMOV              (1<<15)
  ------------------
  |  Branch (320:25): [True: 0, False: 0]
  ------------------
  321|      0|                        features |= PlatformInformation::CPU_FEATURE_CMOV;
  322|      0|                    if (result._edx & CPUID_STD_MMX)
  ------------------
  |  |  277|      0|#define CPUID_STD_MMX               (1<<23)
  ------------------
  |  Branch (322:25): [True: 0, False: 0]
  ------------------
  323|      0|                        features |= PlatformInformation::CPU_FEATURE_MMX;
  324|      0|                    if (result._edx & CPUID_STD_SSE)
  ------------------
  |  |  278|      0|#define CPUID_STD_SSE               (1<<25)
  ------------------
  |  Branch (324:25): [True: 0, False: 0]
  ------------------
  325|      0|                        features |= PlatformInformation::CPU_FEATURE_MMXEXT | PlatformInformation::CPU_FEATURE_SSE;
  326|      0|                    if (result._edx & CPUID_STD_SSE2)
  ------------------
  |  |  279|      0|#define CPUID_STD_SSE2              (1<<26)
  ------------------
  |  Branch (326:25): [True: 0, False: 0]
  ------------------
  327|      0|                        features |= PlatformInformation::CPU_FEATURE_SSE2;
  328|      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 (328:25): [True: 0, False: 0]
  ------------------
  329|      0|                        features |= PlatformInformation::CPU_FEATURE_SSE3;
  330|      0|                    if (result._ecx & CPUID_STD_SSE41)
  ------------------
  |  |  283|      0|#define CPUID_STD_SSE41             (1<<19)     // ECX[19] - Bit 0 of standard function 1 indicate SSE41 supported
  ------------------
  |  Branch (330:25): [True: 0, False: 0]
  ------------------
  331|      0|                        features |= PlatformInformation::CPU_FEATURE_SSE41;
  332|      0|                    if (result._ecx & CPUID_STD_SSE42)
  ------------------
  |  |  284|      0|#define CPUID_STD_SSE42             (1<<20)     // ECX[20] - Bit 0 of standard function 1 indicate SSE42 supported
  ------------------
  |  Branch (332:25): [True: 0, False: 0]
  ------------------
  333|      0|                        features |= PlatformInformation::CPU_FEATURE_SSE42;
  334|       |
  335|       |                    // Check to see if this is a Pentium 4 or later processor
  336|      0|                    if ((result._eax & CPUID_EXT_FAMILY_ID_MASK) ||
  ------------------
  |  |  287|      0|#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: 0]
  ------------------
  337|      0|                        (result._eax & CPUID_FAMILY_ID_MASK) == CPUID_PENTIUM4_ID)
  ------------------
  |  |  286|      0|#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|      0|#define CPUID_PENTIUM4_ID           0x0F00      // Pentium 4 family processor id
  ------------------
  |  Branch (337:25): [True: 0, False: 0]
  ------------------
  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|      0|                    const uint maxExtensionFunctionSupport = _performCpuid(CPUID_FUNC_EXTENSION_QUERY, result);
  ------------------
  |  |  270|      0|#define CPUID_FUNC_EXTENSION_QUERY           0x80000000
  ------------------
  346|      0|                    if (maxExtensionFunctionSupport >= CPUID_FUNC_ADVANCED_POWER_MANAGEMENT)
  ------------------
  |  |  272|      0|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007
  ------------------
  |  Branch (346:25): [True: 0, False: 0]
  ------------------
  347|      0|                    {
  348|      0|                        _performCpuid(CPUID_FUNC_ADVANCED_POWER_MANAGEMENT, result);
  ------------------
  |  |  272|      0|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007
  ------------------
  349|       |
  350|      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 (350:29): [True: 0, False: 0]
  ------------------
  351|      0|                            features |= PlatformInformation::CPU_FEATURE_INVARIANT_TSC;
  352|      0|                    }
  353|      0|                }
  354|      2|                else if (memcmp(&result._ebx, "AuthenticAMD", 12) == 0)
  ------------------
  |  Branch (354:26): [True: 2, False: 0]
  ------------------
  355|      2|                {
  356|      2|                    features |= PlatformInformation::CPU_FEATURE_PRO;
  357|       |
  358|       |                    // Check standard feature
  359|      2|                    _performCpuid(CPUID_FUNC_STANDARD_FEATURES, result);
  ------------------
  |  |  269|      2|#define CPUID_FUNC_STANDARD_FEATURES         0x1
  ------------------
  360|       |
  361|      2|                    if (result._edx & CPUID_STD_FPU)
  ------------------
  |  |  274|      2|#define CPUID_STD_FPU               (1<<0)
  ------------------
  |  Branch (361:25): [True: 2, False: 0]
  ------------------
  362|      2|                        features |= PlatformInformation::CPU_FEATURE_FPU;
  363|      2|                    if (result._edx & CPUID_STD_TSC)
  ------------------
  |  |  275|      2|#define CPUID_STD_TSC               (1<<4)
  ------------------
  |  Branch (363:25): [True: 2, False: 0]
  ------------------
  364|      2|                        features |= PlatformInformation::CPU_FEATURE_TSC;
  365|      2|                    if (result._edx & CPUID_STD_CMOV)
  ------------------
  |  |  276|      2|#define CPUID_STD_CMOV              (1<<15)
  ------------------
  |  Branch (365:25): [True: 2, False: 0]
  ------------------
  366|      2|                        features |= PlatformInformation::CPU_FEATURE_CMOV;
  367|      2|                    if (result._edx & CPUID_STD_MMX)
  ------------------
  |  |  277|      2|#define CPUID_STD_MMX               (1<<23)
  ------------------
  |  Branch (367:25): [True: 2, False: 0]
  ------------------
  368|      2|                        features |= PlatformInformation::CPU_FEATURE_MMX;
  369|      2|                    if (result._edx & CPUID_STD_SSE)
  ------------------
  |  |  278|      2|#define CPUID_STD_SSE               (1<<25)
  ------------------
  |  Branch (369:25): [True: 2, False: 0]
  ------------------
  370|      2|                        features |= PlatformInformation::CPU_FEATURE_SSE;
  371|      2|                    if (result._edx & CPUID_STD_SSE2)
  ------------------
  |  |  279|      2|#define CPUID_STD_SSE2              (1<<26)
  ------------------
  |  Branch (371:25): [True: 2, False: 0]
  ------------------
  372|      2|                        features |= PlatformInformation::CPU_FEATURE_SSE2;
  373|       |
  374|      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 (374:25): [True: 2, False: 0]
  ------------------
  375|      2|                        features |= PlatformInformation::CPU_FEATURE_SSE3;
  376|       |
  377|       |                    // Has extended feature ?
  378|      2|                    const uint maxExtensionFunctionSupport = _performCpuid(CPUID_FUNC_EXTENSION_QUERY, result);
  ------------------
  |  |  270|      2|#define CPUID_FUNC_EXTENSION_QUERY           0x80000000
  ------------------
  379|      2|                    if (maxExtensionFunctionSupport >= CPUID_FUNC_EXTENDED_FEATURES)
  ------------------
  |  |  271|      2|#define CPUID_FUNC_EXTENDED_FEATURES         0x80000001
  ------------------
  |  Branch (379:25): [True: 2, False: 0]
  ------------------
  380|      2|                    {
  381|       |                        // Check extended feature
  382|      2|                        _performCpuid(CPUID_FUNC_EXTENDED_FEATURES, result);
  ------------------
  |  |  271|      2|#define CPUID_FUNC_EXTENDED_FEATURES         0x80000001
  ------------------
  383|       |
  384|      2|                        if (result._edx & CPUID_EXT_3DNOW)
  ------------------
  |  |  290|      2|#define CPUID_EXT_3DNOW             (1<<31)
  ------------------
  |  Branch (384:29): [True: 0, False: 2]
  ------------------
  385|      0|                            features |= PlatformInformation::CPU_FEATURE_3DNOW;
  386|      2|                        if (result._edx & CPUID_EXT_AMD_3DNOWEXT)
  ------------------
  |  |  291|      2|#define CPUID_EXT_AMD_3DNOWEXT      (1<<30)
  ------------------
  |  Branch (386:29): [True: 0, False: 2]
  ------------------
  387|      0|                            features |= PlatformInformation::CPU_FEATURE_3DNOWEXT;
  388|      2|                        if (result._edx & CPUID_EXT_AMD_MMXEXT)
  ------------------
  |  |  292|      2|#define CPUID_EXT_AMD_MMXEXT        (1<<22)
  ------------------
  |  Branch (388:29): [True: 2, False: 0]
  ------------------
  389|      2|                            features |= PlatformInformation::CPU_FEATURE_MMXEXT;
  390|      2|                    }
  391|       |
  392|       |
  393|      2|                    if (maxExtensionFunctionSupport >= CPUID_FUNC_ADVANCED_POWER_MANAGEMENT)
  ------------------
  |  |  272|      2|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007
  ------------------
  |  Branch (393:25): [True: 2, False: 0]
  ------------------
  394|      2|                    {
  395|      2|                        _performCpuid(CPUID_FUNC_ADVANCED_POWER_MANAGEMENT, result);
  ------------------
  |  |  272|      2|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007
  ------------------
  396|       |
  397|      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 (397:29): [True: 2, False: 0]
  ------------------
  398|      2|                            features |= PlatformInformation::CPU_FEATURE_INVARIANT_TSC;
  399|      2|                    }
  400|      2|                }
  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|    }

_ZNK4Ogre10Quaternion7InverseEv:
  275|      1|    {
  276|      1|        Real fNorm = w*w+x*x+y*y+z*z;
  277|      1|        if ( fNorm > 0.0 )
  ------------------
  |  Branch (277:14): [True: 1, False: 0]
  ------------------
  278|      1|        {
  279|      1|            Real fInvNorm = 1.0f/fNorm;
  280|      1|            return Quaternion(w*fInvNorm,-x*fInvNorm,-y*fInvNorm,-z*fInvNorm);
  281|      1|        }
  282|      0|        else
  283|      0|        {
  284|       |            // return an invalid result to flag the error
  285|      0|            return ZERO;
  286|      0|        }
  287|      1|    }

_ZN4Ogre8ResourceC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE:
   36|  2.55k|        : mCreator(creator), mName(name), mGroup(group), mHandle(handle), 
   37|  2.55k|        mLoadingState(LOADSTATE_UNLOADED), mIsBackgroundLoaded(false),
   38|  2.55k|        mIsManual(isManual), mSize(0),  mLoader(loader), mStateCount(0)
   39|  2.55k|    {
   40|  2.55k|    }
_ZN4Ogre8ResourceD2Ev:
   43|  2.55k|    { 
   44|  2.55k|    }
_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|    }
_ZN4Ogre8Resource6unloadEv:
  333|  2.55k|    { 
  334|       |        // Early-out without lock (mitigate perf cost of ensuring unloaded)
  335|  2.55k|        LoadingState old = mLoadingState.load();
  336|  2.55k|        if (old!=LOADSTATE_LOADED && old!=LOADSTATE_PREPARED) return;
  ------------------
  |  Branch (336:13): [True: 2.55k, False: 0]
  |  Branch (336:38): [True: 2.55k, False: 0]
  ------------------
  337|       |
  338|       |
  339|      0|        if (!mLoadingState.compare_exchange_strong(old,LOADSTATE_UNLOADING)) return;
  ------------------
  |  Branch (339:13): [True: 0, False: 0]
  ------------------
  340|       |
  341|       |        // Scope lock for actual unload
  342|      0|        {
  343|      0|                    OGRE_LOCK_AUTO_MUTEX;
  344|      0|            if (old==LOADSTATE_PREPARED) {
  ------------------
  |  Branch (344:17): [True: 0, False: 0]
  ------------------
  345|      0|                unprepareImpl();
  346|      0|            } else {
  347|      0|                preUnloadImpl();
  348|      0|                unloadImpl();
  349|      0|                postUnloadImpl();
  350|      0|            }
  351|      0|        }
  352|       |
  353|      0|        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|      0|        if(old==LOADSTATE_LOADED && mCreator)
  ------------------
  |  Branch (358:12): [True: 0, False: 0]
  |  Branch (358:37): [True: 0, False: 0]
  ------------------
  359|      0|            mCreator->_notifyResourceUnloaded(this);
  360|       |
  361|      0|        _fireUnloadingComplete();
  362|       |
  363|       |
  364|      0|    }

_ZN4Ogre20ResourceGroupManager12getSingletonEv:
   40|  12.7k|    {  
   41|       |        assert( msSingleton );  return ( *msSingleton );  
   42|  12.7k|    }
_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|    }
_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:
  869|  2.55k|    {
  870|  2.55k|        if (mCurrentGroup && res->getGroup() == mCurrentGroup->name)
  ------------------
  |  Branch (870:13): [True: 0, False: 2.55k]
  |  Branch (870:30): [True: 0, False: 0]
  ------------------
  871|      0|        {
  872|       |            // Use current group (batch loading)
  873|      0|            addCreatedResource(res, *mCurrentGroup);
  874|      0|        }
  875|  2.55k|        else
  876|  2.55k|        {
  877|       |            // Find group
  878|  2.55k|            ResourceGroup* grp = getResourceGroup(res->getGroup());
  879|  2.55k|            if (grp)
  ------------------
  |  Branch (879:17): [True: 2.55k, False: 0]
  ------------------
  880|  2.55k|            {
  881|  2.55k|                addCreatedResource(res, *grp);
  882|  2.55k|            }
  883|  2.55k|        }
  884|       |
  885|  2.55k|        fireResourceCreated(res);
  886|  2.55k|    }
_ZNK4Ogre20ResourceGroupManager22_notifyResourceRemovedERKNS_9SharedPtrINS_8ResourceEEE:
  889|  2.55k|    {
  890|  2.55k|        fireResourceRemove(res);
  891|       |
  892|  2.55k|        if (mCurrentGroup && res->getGroup() == mCurrentGroup->name)
  ------------------
  |  Branch (892:13): [True: 0, False: 2.55k]
  |  Branch (892:30): [True: 0, False: 0]
  ------------------
  893|      0|        {
  894|       |            // Do nothing - we're batch unloading so list will be cleared
  895|      0|        }
  896|  2.55k|        else
  897|  2.55k|        {
  898|       |            // Find group
  899|  2.55k|            ResourceGroup* grp = getResourceGroup(res->getGroup());
  900|  2.55k|            if (grp)
  ------------------
  |  Branch (900:17): [True: 2.55k, False: 0]
  ------------------
  901|  2.55k|            {
  902|  2.55k|                            OGRE_LOCK_MUTEX(grp->OGRE_AUTO_MUTEX_NAME); // lock group mutex
  903|  2.55k|                ResourceGroup::LoadResourceOrderMap::iterator i = 
  904|  2.55k|                    grp->loadResourceOrderMap.find(
  905|  2.55k|                        res->getCreator()->getLoadingOrder());
  906|  2.55k|                if (i != grp->loadResourceOrderMap.end())
  ------------------
  |  Branch (906:21): [True: 2.55k, False: 0]
  ------------------
  907|  2.55k|                {
  908|       |                    // Iterate over the resource list and remove
  909|  2.55k|                    LoadUnloadResourceList& resList = i->second;
  910|  2.55k|                    for (LoadUnloadResourceList::iterator l = resList.begin();
  911|  2.55k|                        l != resList.end(); ++ l)
  ------------------
  |  Branch (911:25): [True: 2.55k, False: 0]
  ------------------
  912|  2.55k|                    {
  913|  2.55k|                        if ((*l).get() == res.get())
  ------------------
  |  Branch (913:29): [True: 2.55k, False: 0]
  ------------------
  914|  2.55k|                        {
  915|       |                            // this is the one
  916|  2.55k|                            resList.erase(l);
  917|  2.55k|                            break;
  918|  2.55k|                        }
  919|  2.55k|                    }
  920|  2.55k|                }
  921|  2.55k|            }
  922|  2.55k|        }
  923|  2.55k|    }
_ZNK4Ogre20ResourceGroupManager18addCreatedResourceERNS_9SharedPtrINS_8ResourceEEERNS0_13ResourceGroupE:
  996|  2.55k|    {
  997|  2.55k|            OGRE_LOCK_MUTEX(grp.OGRE_AUTO_MUTEX_NAME);
  998|  2.55k|        Real order = res->getCreator()->getLoadingOrder();
  999|       |
 1000|  2.55k|        ResourceGroup::LoadResourceOrderMap::iterator i = grp.loadResourceOrderMap.find(order);
 1001|  2.55k|        LoadUnloadResourceList& loadList =
 1002|  2.55k|            i == grp.loadResourceOrderMap.end() ? grp.loadResourceOrderMap[order] : i->second;
  ------------------
  |  Branch (1002:13): [True: 3, False: 2.55k]
  ------------------
 1003|       |
 1004|  2.55k|        loadList.push_back(res);
 1005|  2.55k|    }
_ZNK4Ogre20ResourceGroupManager16getResourceGroupERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
 1009|  10.2k|    {
 1010|  10.2k|        OGRE_LOCK_AUTO_MUTEX;
 1011|  10.2k|        ResourceGroupMap::const_iterator i = mResourceGroupMap.find(name);
 1012|       |
 1013|  10.2k|        if (i == mResourceGroupMap.end())
  ------------------
  |  Branch (1013:13): [True: 3, False: 10.2k]
  ------------------
 1014|      3|        {
 1015|      3|            if (throwOnFailure)
  ------------------
  |  Branch (1015:17): [True: 0, False: 3]
  ------------------
 1016|      3|                OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Cannot locate a resource group called '" + name + "'");
 1017|       |
 1018|      3|            return nullptr;
 1019|      3|        }
 1020|       |
 1021|  10.2k|        return i->second;
 1022|  10.2k|    }
_ZNK4Ogre20ResourceGroupManager19fireResourceCreatedERKNS_9SharedPtrINS_8ResourceEEE:
 1209|  2.55k|    {
 1210|  2.55k|        OGRE_LOCK_AUTO_MUTEX;
 1211|  2.55k|        for (auto l : mResourceGroupListenerList)
  ------------------
  |  Branch (1211:21): [True: 0, False: 2.55k]
  ------------------
 1212|      0|        {
 1213|      0|            l->resourceCreated(resource);
 1214|      0|        }
 1215|  2.55k|    }
_ZNK4Ogre20ResourceGroupManager18fireResourceRemoveERKNS_9SharedPtrINS_8ResourceEEE:
 1218|  2.55k|    {
 1219|  2.55k|        OGRE_LOCK_AUTO_MUTEX;
 1220|  2.55k|        for (auto l : mResourceGroupListenerList)
  ------------------
  |  Branch (1220:21): [True: 0, False: 2.55k]
  ------------------
 1221|      0|        {
 1222|      0|            l->resourceRemove(resource);
 1223|      0|        }
 1224|  2.55k|    }
_ZNK4Ogre20ResourceGroupManager27isResourceGroupInGlobalPoolERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1468|  5.11k|    {
 1469|  5.11k|        return getResourceGroup(name, true)->inGlobalPool;
 1470|  5.11k|    }
_ZNK4Ogre20ResourceGroupManager18getLoadingListenerEv:
 1501|  2.55k|    {
 1502|  2.55k|        return mLoadingListener;
 1503|  2.55k|    }

_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|  2.55k|    {
   54|  2.55k|        OgreAssert(!name.empty(), "resource name must not be empty");
  ------------------
  |  Branch (54:9): [True: 0, False: 2.55k]
  ------------------
   55|       |
   56|       |        // Call creation implementation
   57|  2.55k|        ResourcePtr ret = ResourcePtr(
   58|  2.55k|            createImpl(name, getNextHandle(), group, isManual, loader, params));
   59|  2.55k|        if (params)
  ------------------
  |  Branch (59:13): [True: 0, False: 2.55k]
  ------------------
   60|      0|            ret->setParameterList(*params);
   61|       |
   62|  2.55k|        addImpl(ret);
   63|       |        // Tell resource group manager
   64|  2.55k|        if(ret)
  ------------------
  |  Branch (64:12): [True: 2.55k, False: 0]
  ------------------
   65|  2.55k|            ResourceGroupManager::getSingleton()._notifyResourceCreated(ret);
   66|  2.55k|        return ret;
   67|       |
   68|  2.55k|    }
_ZN4Ogre15ResourceManager7addImplERNS_9SharedPtrINS_8ResourceEEE:
  112|  2.55k|    {
  113|  2.55k|            OGRE_LOCK_AUTO_MUTEX;
  114|       |
  115|  2.55k|            std::pair<ResourceMap::iterator, bool> result;
  116|  2.55k|        if(ResourceGroupManager::getSingleton().isResourceGroupInGlobalPool(res->getGroup()))
  ------------------
  |  Branch (116:12): [True: 2.55k, False: 0]
  ------------------
  117|  2.55k|        {
  118|  2.55k|            result = mResources.emplace(res->getName(), res);
  119|  2.55k|        }
  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|  2.55k|        ResourceLoadingListener* listener = ResourceGroupManager::getSingleton().getLoadingListener();
  129|  2.55k|        if (!result.second && listener)
  ------------------
  |  Branch (129:13): [True: 0, False: 2.55k]
  |  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|  2.55k|        if (!result.second)
  ------------------
  |  Branch (150:13): [True: 0, False: 2.55k]
  ------------------
  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|  2.55k|        std::pair<ResourceHandleMap::iterator, bool> resultHandle = mResourcesByHandle.emplace(res->getHandle(), res);
  158|  2.55k|        if (!resultHandle.second)
  ------------------
  |  Branch (158:13): [True: 0, False: 2.55k]
  ------------------
  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|  2.55k|    }
_ZN4Ogre15ResourceManager10removeImplERKNS_9SharedPtrINS_8ResourceEEE:
  167|  2.55k|    {
  168|  2.55k|        OgreAssert(res, "attempting to remove nullptr");
  ------------------
  |  Branch (168:9): [True: 0, False: 2.55k]
  ------------------
  169|       |
  170|  2.55k|#if OGRE_RESOURCEMANAGER_STRICT
  171|  2.55k|        if (res->getCreator() != this)
  ------------------
  |  Branch (171:13): [True: 0, False: 2.55k]
  ------------------
  172|  2.55k|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Resource '" + res->getName() + "' was not created by the '" +
  173|  2.55k|                                                          getResourceType() + "' ResourceManager");
  174|  2.55k|#endif
  175|       |
  176|  2.55k|        OGRE_LOCK_AUTO_MUTEX;
  177|       |
  178|  2.55k|        if(ResourceGroupManager::getSingleton().isResourceGroupInGlobalPool(res->getGroup()))
  ------------------
  |  Branch (178:12): [True: 2.55k, False: 0]
  ------------------
  179|  2.55k|        {
  180|  2.55k|            ResourceMap::iterator nameIt = mResources.find(res->getName());
  181|  2.55k|            if (nameIt != mResources.end())
  ------------------
  |  Branch (181:17): [True: 2.55k, False: 0]
  ------------------
  182|  2.55k|            {
  183|  2.55k|                mResources.erase(nameIt);
  184|  2.55k|            }
  185|  2.55k|        }
  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|  2.55k|        ResourceHandleMap::iterator handleIt = mResourcesByHandle.find(res->getHandle());
  205|  2.55k|        if (handleIt != mResourcesByHandle.end())
  ------------------
  |  Branch (205:13): [True: 2.55k, False: 0]
  ------------------
  206|  2.55k|        {
  207|  2.55k|            mResourcesByHandle.erase(handleIt);
  208|  2.55k|        }
  209|       |        // Tell resource group manager
  210|  2.55k|        ResourceGroupManager::getSingleton()._notifyResourceRemoved(res);
  211|  2.55k|    }
_ZN4Ogre15ResourceManager6removeERKNS_9SharedPtrINS_8ResourceEEE:
  298|  2.55k|    {
  299|  2.55k|        removeImpl(res);
  300|  2.55k|    }
_ZN4Ogre15ResourceManager13getNextHandleEv:
  431|  2.55k|    {
  432|       |        // This is an atomic operation and hence needs no locking
  433|  2.55k|        return mNextHandle++;
  434|  2.55k|    }

_ZN4Ogre4Root15getSingletonPtrEv:
   86|      9|    {
   87|      9|        return msSingleton;
   88|      9|    }

_ZN4Ogre10SerializerC2Ev:
   36|  15.3k|        mVersion("[Serializer_v1.00]"), // Version number
   37|  15.3k|        mFlipEndian(false)
   38|       |#if OGRE_SERIALIZER_VALIDATE_CHUNKSIZE
   39|       |        , mReportChunkErrors(true)
   40|       |#endif
   41|  15.3k|    {
   42|  15.3k|    }
_ZN4Ogre10SerializerD2Ev:
   46|  15.3k|    {
   47|  15.3k|    }
_ZN4Ogre10Serializer19determineEndiannessERKNS_9SharedPtrINS_10DataStreamEEE:
   50|  4.28k|    {
   51|  4.28k|        if (stream->tell() != 0)
  ------------------
  |  Branch (51:13): [True: 0, False: 4.28k]
  ------------------
   52|      0|        {
   53|      0|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
   54|      0|                "Can only determine the endianness of the input stream if it "
   55|      0|                "is at the start", "Serializer::determineEndianness");
   56|      0|        }
   57|       |                
   58|  4.28k|        uint16 dest;
   59|       |        // read header id manually (no conversion)
   60|  4.28k|        size_t actually_read = stream->read(&dest, sizeof(uint16));
   61|       |        // skip back
   62|  4.28k|        stream->skip(0 - (long)actually_read);
   63|  4.28k|        if (actually_read != sizeof(uint16))
  ------------------
  |  Branch (63:13): [True: 4, False: 4.27k]
  ------------------
   64|      4|        {
   65|       |            // end of file?
   66|      4|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
   67|      4|                        "Couldn't read 16 bit header value from input stream.",
   68|      4|                        "Serializer::determineEndianness");
   69|      4|        }
   70|  4.27k|        if (dest == HEADER_STREAM_ID)
  ------------------
  |  Branch (70:13): [True: 1.26k, False: 3.01k]
  ------------------
   71|  1.26k|        {
   72|  1.26k|            mFlipEndian = false;
   73|  1.26k|        }
   74|  3.01k|        else if (dest == OTHER_ENDIAN_HEADER_STREAM_ID)
  ------------------
  |  Branch (74:18): [True: 2.98k, False: 35]
  ------------------
   75|  2.98k|        {
   76|  2.98k|            mFlipEndian = true;
   77|  2.98k|        }
   78|     35|        else
   79|     35|        {
   80|       |            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
   81|     35|                "Header chunk didn't match either endian: Corrupted stream?",
   82|     35|                "Serializer::determineEndianness");
   83|     35|        }
   84|  4.27k|    }
_ZN4Ogre10Serializer14readFileHeaderERKNS_9SharedPtrINS_10DataStreamEEE:
  235|  1.72k|    {
  236|  1.72k|        unsigned short headerID;
  237|       |        
  238|       |        // Read header ID
  239|  1.72k|        readShorts(stream, &headerID, 1);
  240|       |        
  241|  1.72k|        if (headerID == HEADER_STREAM_ID)
  ------------------
  |  Branch (241:13): [True: 1.72k, False: 0]
  ------------------
  242|  1.72k|        {
  243|       |            // Read version
  244|  1.72k|            String ver = readString(stream);
  245|  1.72k|            if (ver != mVersion)
  ------------------
  |  Branch (245:17): [True: 0, False: 1.72k]
  ------------------
  246|      0|            {
  247|      0|                OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, 
  248|      0|                    "Invalid file: version incompatible, file reports " + String(ver) +
  249|      0|                    " Serializer is version " + mVersion,
  250|      0|                    "Serializer::readFileHeader");
  251|      0|            }
  252|  1.72k|        }
  253|      0|        else
  254|      0|        {
  255|      0|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Invalid file: no header", 
  256|      0|                "Serializer::readFileHeader");
  257|      0|        }
  258|       |
  259|  1.72k|    }
_ZN4Ogre10Serializer9readChunkERKNS_9SharedPtrINS_10DataStreamEEE:
  262|  2.38k|    {
  263|  2.38k|        size_t pos = stream->tell();
  264|  2.38k|        unsigned short id;
  265|  2.38k|        readShorts(stream, &id, 1);
  266|       |        
  267|  2.38k|        readInts(stream, &mCurrentstreamLen, 1);
  268|       |
  269|  2.38k|        if (!stream->eof())
  ------------------
  |  Branch (269:13): [True: 2.37k, False: 13]
  ------------------
  270|  2.37k|        {
  271|       |            // chunk size cant be smaller than the header size, and must fit within the stream
  272|  2.37k|            if (mCurrentstreamLen < calcChunkHeaderSize() || pos + mCurrentstreamLen > stream->size())
  ------------------
  |  Branch (272:17): [True: 16, False: 2.35k]
  |  Branch (272:62): [True: 2.34k, False: 13]
  ------------------
  273|  2.37k|                OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR, "Corrupt chunk length");
  274|  2.37k|        }
  275|       |
  276|       |#if OGRE_SERIALIZER_VALIDATE_CHUNKSIZE
  277|       |        if (!mChunkSizeStack.empty() && !stream->eof()){
  278|       |            if (pos != static_cast<size_t>(mChunkSizeStack.back()) && mReportChunkErrors){
  279|       |                LogManager::getSingleton().logMessage("Corrupted chunk detected! Stream name: '" + stream->getName() + "' Chunk id: " + StringConverter::toString(id));
  280|       |            }
  281|       |            mChunkSizeStack.back() = pos + mCurrentstreamLen;
  282|       |        }
  283|       |#endif
  284|     26|        return id;
  285|  2.38k|    }
_ZN4Ogre10Serializer10readFloatsERKNS_9SharedPtrINS_10DataStreamEEEPfm:
  294|      2|    {
  295|      2|        stream->read(pDest, sizeof(float) * count);
  296|      2|        flipFromLittleEndian(pDest, sizeof(float), count);
  297|      2|    }
_ZN4Ogre10Serializer10readShortsERKNS_9SharedPtrINS_10DataStreamEEEPtm:
  315|  6.62k|    {
  316|  6.62k|        stream->read(pDest, sizeof(unsigned short) * count);
  317|  6.62k|        flipFromLittleEndian(pDest, sizeof(unsigned short), count);
  318|  6.62k|    }
_ZN4Ogre10Serializer8readIntsERKNS_9SharedPtrINS_10DataStreamEEEPjm:
  321|  2.38k|    {
  322|  2.38k|        stream->read(pDest, sizeof(uint32) * count);
  323|  2.38k|        flipFromLittleEndian(pDest, sizeof(uint32), count);
  324|  2.38k|    }
_ZN4Ogre10Serializer10readStringERKNS_9SharedPtrINS_10DataStreamEEE:
  327|  4.24k|    {
  328|  4.24k|        return stream->getLine(false);
  329|  4.24k|    }
_ZN4Ogre10Serializer10readObjectERKNS_9SharedPtrINS_10DataStreamEEERNS_6VectorILi3EfEE:
  348|      1|    {
  349|      1|        readFloats(stream, pDest.ptr(), 3);
  350|      1|    }
_ZN4Ogre10Serializer10readObjectERKNS_9SharedPtrINS_10DataStreamEEERNS_10QuaternionE:
  353|      1|    {
  354|      1|        float tmp[4];
  355|      1|        readFloats(stream, tmp, 4);
  356|      1|        pDest.x = tmp[0];
  357|      1|        pDest.y = tmp[1];
  358|      1|        pDest.z = tmp[2];
  359|      1|        pDest.w = tmp[3];
  360|      1|    }
_ZN4Ogre10Serializer20flipFromLittleEndianEPvmm:
  373|  9.01k|    {
  374|  9.01k|        if(mFlipEndian)
  ------------------
  |  Branch (374:12): [True: 5.91k, False: 3.09k]
  ------------------
  375|  5.91k|        {
  376|  5.91k|	        Bitwise::bswapChunks(pData, size, count);
  377|  5.91k|        }
  378|  9.01k|    }
_ZN4Ogre10Serializer14pushInnerChunkERKNS_9SharedPtrINS_10DataStreamEEE:
  381|  2.37k|    {
  382|       |#if OGRE_SERIALIZER_VALIDATE_CHUNKSIZE
  383|       |        mChunkSizeStack.push_back(stream->tell());
  384|       |#endif
  385|  2.37k|    }
_ZN4Ogre10Serializer13popInnerChunkERKNS_9SharedPtrINS_10DataStreamEEE:
  396|     13|    {
  397|       |#if OGRE_SERIALIZER_VALIDATE_CHUNKSIZE
  398|       |        if (!mChunkSizeStack.empty()){
  399|       |            size_t pos = stream->tell();
  400|       |            if (pos != static_cast<size_t>(mChunkSizeStack.back()) && !stream->eof() && mReportChunkErrors){
  401|       |                LogManager::getSingleton().logMessage("Corrupted chunk detected! Stream name: " + stream->getName());
  402|       |            }
  403|       |
  404|       |            mChunkSizeStack.pop_back();
  405|       |        }
  406|       |#endif
  407|     13|    }

_ZN4Ogre8SkeletonC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE:
   49|    734|        : Resource(creator, name, handle, group, isManual, loader), 
   50|    734|        mBlendState(ANIMBLEND_AVERAGE)
   51|       |        // set animation blending to weighted, not cumulative
   52|    734|    {
   53|    734|        if (createParamDictionary("Skeleton"))
  ------------------
  |  Branch (53:13): [True: 1, False: 733]
  ------------------
   54|      1|        {
   55|       |            // no custom params
   56|      1|        }
   57|    734|    }
_ZN4Ogre8SkeletonD2Ev:
   60|    734|    {
   61|       |        // have to call this here reather than in Resource destructor
   62|       |        // since calling virtual methods in base destructors causes crash
   63|    734|        unload(); 
   64|    734|    }
_ZN4Ogre8Skeleton10createBoneERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEt:
  125|      1|    {
  126|      1|        OgreAssert(handle < OGRE_MAX_NUM_BONES, "Exceeded the maximum number of bones per skeleton");
  ------------------
  |  Branch (126:9): [True: 0, False: 1]
  ------------------
  127|       |        // Check handle not used
  128|      1|        if (handle < mBoneList.size() && mBoneList[handle] != NULL)
  ------------------
  |  Branch (128:13): [True: 0, False: 1]
  |  Branch (128:42): [True: 0, False: 0]
  ------------------
  129|      0|        {
  130|      0|            OGRE_EXCEPT(
  131|      0|                Exception::ERR_DUPLICATE_ITEM,
  132|      0|                "A bone with the handle " + StringConverter::toString(handle) + " already exists",
  133|      0|                "Skeleton::createBone" );
  134|      0|        }
  135|       |        // Check name not used
  136|      1|        if (mBoneListByName.find(name) != mBoneListByName.end())
  ------------------
  |  Branch (136:13): [True: 0, False: 1]
  ------------------
  137|      0|        {
  138|      0|            OGRE_EXCEPT(
  139|      0|                Exception::ERR_DUPLICATE_ITEM,
  140|      0|                "A bone with the name " + name + " already exists",
  141|      0|                "Skeleton::createBone" );
  142|      0|        }
  143|      1|        Bone* ret = OGRE_NEW Bone(name, handle, this);
  144|      1|        if (mBoneList.size() <= handle)
  ------------------
  |  Branch (144:13): [True: 1, False: 0]
  ------------------
  145|      1|        {
  146|      1|            mBoneList.resize(handle+1);
  147|      1|        }
  148|      1|        mBoneList[handle] = ret;
  149|      1|        mBoneListByName[name] = ret;
  150|      1|        return ret;
  151|      1|    }
_ZN4Ogre8Skeleton14setBindingPoseEv:
  223|      4|    {
  224|       |        // Update the derived transforms
  225|      4|        _updateTransforms();
  226|       |
  227|      4|        for (auto *b : mBoneList)
  ------------------
  |  Branch (227:22): [True: 1, False: 4]
  ------------------
  228|      1|        {            
  229|      1|            b->setBindingPose();
  230|      1|        }
  231|      4|    }
_ZN4Ogre8Skeleton17_updateTransformsEv:
  548|      4|    {
  549|      4|        for (auto *b : mRootBones)
  ------------------
  |  Branch (549:22): [True: 0, False: 4]
  ------------------
  550|      0|        {
  551|      0|            b->_update(true, false);
  552|      0|        }
  553|      4|        mManualBonesDirty = false;
  554|      4|    }

_ZN4Ogre15SkeletonManager12getSingletonEv:
   40|  1.46k|    {  
   41|       |        assert( msSingleton );  return ( *msSingleton );  
   42|  1.46k|    }
_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|    734|    {
   61|    734|        return static_pointer_cast<Skeleton>(createResource(name,group,isManual,loader,createParams));
   62|    734|    }
_ZN4Ogre15SkeletonManager10createImplERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmS9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
   72|    734|    {
   73|       |        return OGRE_NEW Skeleton(this, name, handle, group, isManual, loader);
   74|    734|    }

_ZN4Ogre18SkeletonSerializerC2Ev:
   42|    734|    {
   43|       |        // Version number
   44|       |        // NB changed to include bone names in 1.1
   45|    734|        mVersion = "[Unknown]";
   46|    734|    }
_ZN4Ogre18SkeletonSerializer14importSkeletonERNS_9SharedPtrINS_10DataStreamEEEPNS_8SkeletonE:
  105|    734|    {
  106|       |        // Determine endianness (must be the first thing we do!)
  107|    734|        determineEndianness(stream);
  108|       |
  109|       |        // Check header
  110|    734|        unsigned short headerID;
  111|    734|        readShorts(stream, &headerID, 1);
  112|    734|        if (headerID != HEADER_STREAM_ID_EXT)
  ------------------
  |  Branch (112:13): [True: 0, False: 734]
  ------------------
  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|    734|        String ver = readString(stream);
  120|    734|        if ((ver != "[Serializer_v1.10]") &&
  ------------------
  |  Branch (120:13): [True: 712, False: 22]
  ------------------
  121|    712|            (ver != "[Serializer_v1.80]"))
  ------------------
  |  Branch (121:13): [True: 74, False: 638]
  ------------------
  122|     74|        {
  123|     74|            OGRE_EXCEPT(Exception::ERR_INTERNAL_ERROR,
  124|     74|                "Invalid file: version incompatible, file reports " + String(ver),
  125|     74|                "SkeletonSerializer::importSkeleton");
  126|     74|        }
  127|    660|        mVersion = ver;
  128|       |
  129|    660|        pushInnerChunk(stream);
  130|    660|        unsigned short streamID = readChunk(stream);
  131|       |
  132|    662|        while(!stream->eof())
  ------------------
  |  Branch (132:15): [True: 2, False: 660]
  ------------------
  133|      2|        {
  134|      2|            switch (streamID)
  135|      2|            {
  136|      0|            case SKELETON_BLENDMODE:
  ------------------
  |  Branch (136:13): [True: 0, False: 2]
  ------------------
  137|      0|            {
  138|       |                // Optional blend mode
  139|      0|                uint16 blendMode;
  140|      0|                readShorts(stream, &blendMode, 1);
  141|      0|                pSkel->setBlendMode(static_cast<SkeletonAnimationBlendMode>(blendMode));
  142|      0|                break;
  143|      0|            }
  144|      1|            case SKELETON_BONE:
  ------------------
  |  Branch (144:13): [True: 1, False: 1]
  ------------------
  145|      1|                readBone(stream, pSkel);
  146|      1|                break;
  147|      0|            case SKELETON_BONE_PARENT:
  ------------------
  |  Branch (147:13): [True: 0, False: 2]
  ------------------
  148|      0|                readBoneParent(stream, pSkel);
  149|      0|                break;
  150|      0|            case SKELETON_ANIMATION:
  ------------------
  |  Branch (150:13): [True: 0, False: 2]
  ------------------
  151|      0|                readAnimation(stream, pSkel);
  152|      0|                break;
  153|      0|            case SKELETON_ANIMATION_LINK:
  ------------------
  |  Branch (153:13): [True: 0, False: 2]
  ------------------
  154|      0|                readSkeletonAnimationLink(stream, pSkel);
  155|      0|                break;
  156|      1|            default:
  ------------------
  |  Branch (156:13): [True: 1, False: 1]
  ------------------
  157|      1|                break;
  158|      2|            }
  159|       |
  160|      2|            streamID = readChunk(stream);
  161|      2|        }
  162|       |        // Assume bones are stored in the binding pose
  163|    660|        pSkel->setBindingPose();
  164|    660|        popInnerChunk(stream);
  165|       |
  166|    660|    }
_ZN4Ogre18SkeletonSerializer24calcBoneSizeWithoutScaleEPKNS_8SkeletonEPKNS_4BoneE:
  337|      1|    {
  338|      1|        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|      1|        size += sizeof(unsigned short);
  346|       |
  347|       |        // position
  348|      1|        size += sizeof(float) * 3;
  349|       |
  350|       |        // orientation
  351|      1|        size += sizeof(float) * 4;
  352|       |
  353|      1|        return size;
  354|      1|    }
_ZN4Ogre18SkeletonSerializer8readBoneERNS_9SharedPtrINS_10DataStreamEEEPNS_8SkeletonE:
  446|      1|    {
  447|       |        // char* name
  448|      1|        String name = readString(stream);
  449|       |        // unsigned short handle            : handle of the bone, should be contiguous & start at 0
  450|      1|        unsigned short handle;
  451|      1|        readShorts(stream, &handle, 1);
  452|       |
  453|      1|        if (handle > pSkel->getNumBones())
  ------------------
  |  Branch (453:13): [True: 0, False: 1]
  ------------------
  454|      1|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Bone handles must be contiguous");
  455|       |
  456|       |        // Create new bone
  457|      1|        Bone* pBone = pSkel->createBone(name, handle);
  458|       |
  459|       |        // Vector3 position                 : position of this bone relative to parent 
  460|      1|        Vector3 pos;
  461|      1|        readObject(stream, pos);
  462|      1|        pBone->setPosition(pos);
  463|       |        // Quaternion orientation           : orientation of this bone relative to parent 
  464|      1|        Quaternion q;
  465|      1|        readObject(stream, q);
  466|      1|        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|      1|        if (mCurrentstreamLen > calcBoneSizeWithoutScale(pSkel, pBone))
  ------------------
  |  Branch (475:13): [True: 0, False: 1]
  ------------------
  476|      0|        {
  477|      0|            Vector3 scale;
  478|      0|            readObject(stream, scale);
  479|      0|            pBone->setScale(scale);
  480|      0|        }
  481|       |        
  482|      1|    }

_ZN4Ogre16StreamSerialiserC2ERKNS_9SharedPtrINS_10DataStreamEEENS0_6EndianEbNS0_17RealStorageFormatE:
  109|    137|        : mStream(stream)
  110|    137|        , mEndian(endianMode)
  111|    137|        , mFlipEndian(false)
  112|    137|        , mReadWriteHeader(autoHeader)
  113|    137|        , mRealFormat(realFormat)
  114|    137|    {
  115|    137|        if (mEndian != ENDIAN_AUTO)
  ------------------
  |  Branch (115:13): [True: 0, False: 137]
  ------------------
  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: 137]
  ------------------
  128|    137|    }
_ZN4Ogre16StreamSerialiserD2Ev:
  131|    137|    {
  132|       |        // really this should be empty if read/write was complete, but be tidy
  133|    137|        if (!mChunkStack.empty())
  ------------------
  |  Branch (133:13): [True: 1, False: 136]
  ------------------
  134|      1|        {
  135|      1|            LogManager::getSingleton().stream(LML_WARNING) <<
  136|      1|                "Warning: stream " << mStream->getName() << " was not fully read / written; " <<
  137|      1|                mChunkStack.size() << " chunks remain unterminated.";
  138|      1|        }
  139|    137|        for (auto & i : mChunkStack)
  ------------------
  |  Branch (139:23): [True: 1, False: 137]
  ------------------
  140|      1|            delete i;
  141|    137|        mChunkStack.clear();
  142|       |
  143|    137|    }
_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|    186|    {
  166|       |        // Have we figured out the endian mode yet?
  167|    186|        if (mReadWriteHeader)
  ------------------
  |  Branch (167:13): [True: 137, False: 49]
  ------------------
  168|    137|            readHeader();
  169|       |
  170|    186|        OgreAssert(mEndian != ENDIAN_AUTO,
  ------------------
  |  Branch (170:9): [True: 0, False: 186]
  ------------------
  171|    186|                   "Endian mode has not been determined, did you disable header without setting?");
  172|       |
  173|    186|        Chunk* chunk = readChunkImpl();
  174|    186|        mChunkStack.push_back(chunk);
  175|       |
  176|    186|        return chunk;
  177|       |
  178|    186|    }
_ZN4Ogre16StreamSerialiser12readChunkEndEj:
  239|      1|    {
  240|      1|        Chunk* c = popChunk(id);
  241|       |
  242|      1|        OgreAssert(mStream, "Stream is null");
  ------------------
  |  Branch (242:9): [True: 0, False: 1]
  ------------------
  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|        if (mStream->tell() < (c->offset + CHUNK_HEADER_SIZE + c->length))
  ------------------
  |  Branch (247:13): [True: 0, False: 1]
  ------------------
  248|      0|            mStream->seek(c->offset + CHUNK_HEADER_SIZE + c->length);
  249|       |
  250|       |        OGRE_DELETE c;
  251|      1|    }
_ZN4Ogre16StreamSerialiser10readHeaderEv:
  261|    137|    {
  262|    137|        uint32 headerid = 0;
  263|    137|        size_t actually_read = mStream->read(&headerid, sizeof(uint32));
  264|       |        // skip back
  265|    137|        mStream->skip(0 - (long)actually_read);
  266|       |        // validate that this is a header chunk
  267|    137|        if (headerid == REVERSE_HEADER_ID)
  ------------------
  |  Branch (267:13): [True: 15, False: 122]
  ------------------
  268|     15|        {
  269|     15|            mFlipEndian = true;
  270|     15|        }
  271|    122|        else if (headerid == HEADER_ID)
  ------------------
  |  Branch (271:18): [True: 34, False: 88]
  ------------------
  272|     34|        {
  273|     34|            mFlipEndian = false;
  274|     34|        }
  275|     88|        else
  276|     88|        {
  277|       |            // no good
  278|     88|            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 
  279|     88|                "Cannot determine endian mode because header is missing", 
  280|     88|                "StreamSerialiser::readHeader");
  281|     88|        }
  282|     49|        determineEndianness();
  283|       |
  284|     49|        mReadWriteHeader = false;
  285|       |
  286|     49|        const Chunk* c = readChunkBegin();
  287|       |        // endian should be flipped now
  288|     49|        assert(c->id == HEADER_ID);
  289|     49|        (void)c; // Silence warning
  290|       |
  291|       |        // read real storage format
  292|     49|        bool realIsDouble;
  293|     49|        read(&realIsDouble);
  294|     49|        mRealFormat = realIsDouble? REAL_DOUBLE : REAL_FLOAT;
  ------------------
  |  Branch (294:23): [True: 0, False: 49]
  ------------------
  295|       |
  296|     49|        readChunkEnd(HEADER_ID);
  297|       |
  298|     49|    }
_ZN4Ogre16StreamSerialiser19determineEndiannessEv:
  301|     49|    {
  302|       |#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
  303|       |        if (mFlipEndian)
  304|       |            mEndian = ENDIAN_LITTLE;
  305|       |        else
  306|       |            mEndian = ENDIAN_BIG;
  307|       |#else
  308|     49|        if (mFlipEndian)
  ------------------
  |  Branch (308:13): [True: 15, False: 34]
  ------------------
  309|     15|            mEndian = ENDIAN_BIG;
  310|     34|        else
  311|     34|            mEndian = ENDIAN_LITTLE;
  312|     49|#endif
  313|     49|    }
_ZNK4Ogre16StreamSerialiser11checkStreamEbbb:
  330|    190|    {
  331|    190|        OgreAssert(mStream, "Stream is null");
  ------------------
  |  Branch (331:9): [True: 0, False: 190]
  ------------------
  332|       |
  333|    190|        if (failOnEof && mStream->eof())
  ------------------
  |  Branch (333:13): [True: 190, False: 0]
  |  Branch (333:26): [True: 8, False: 182]
  ------------------
  334|    190|            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "Invalid operation, end of file on stream");
  335|       |
  336|    182|        if (validateReadable && !mStream->isReadable())
  ------------------
  |  Branch (336:13): [True: 182, False: 0]
  |  Branch (336:33): [True: 0, False: 182]
  ------------------
  337|    182|            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "Invalid operation, file is not readable");
  338|       |
  339|    182|        if (validateWriteable && !mStream->isWriteable())
  ------------------
  |  Branch (339:13): [True: 0, False: 182]
  |  Branch (339:34): [True: 0, False: 0]
  ------------------
  340|       |            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, "Invalid operation, file is not writeable");
  341|    182|    }
_ZN4Ogre16StreamSerialiser13readChunkImplEv:
  421|     49|    {
  422|     49|        auto chunk = std::make_unique<Chunk>();
  423|     49|        chunk->offset = static_cast<uint32>(mStream->tell());
  424|     49|        read(&chunk->id);
  425|     49|        read(&chunk->version);
  426|     49|        read(&chunk->length);
  427|       |        
  428|     49|        uint32 checksum;
  429|     49|        read(&checksum);
  430|       |        
  431|     49|        if (checksum != calculateChecksum(chunk.get()))
  ------------------
  |  Branch (431:13): [True: 40, False: 9]
  ------------------
  432|     40|        {
  433|       |            // no good, this is an invalid chunk
  434|     40|            uint32 off = chunk->offset;
  435|     40|            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 
  436|     40|                "Corrupt chunk detected in stream " + mStream->getName() + " at byte "
  437|     40|                + StringConverter::toString(off), 
  438|     40|                "StreamSerialiser::readChunkImpl");
  439|     40|        }
  440|       |
  441|      9|        return chunk.release();
  442|       |
  443|       |
  444|     49|    }
_ZN4Ogre16StreamSerialiser8readDataEPvmm:
  614|    190|    {
  615|    190|        checkStream(true, true, false);
  616|       |
  617|    190|        size_t totSize = size * count;
  618|    190|        mStream->read(buf, totSize);
  619|       |
  620|    190|        if (mFlipEndian)
  ------------------
  |  Branch (620:13): [True: 54, False: 136]
  ------------------
  621|     54|			Bitwise::bswapChunks(buf, size, count);
  622|       |
  623|    190|    }
_ZN4Ogre16StreamSerialiser4readEPbm:
  776|      1|    {
  777|      2|        for (size_t i = 0; i < count; ++i, ++val)
  ------------------
  |  Branch (777:28): [True: 1, False: 1]
  ------------------
  778|      1|        {
  779|      1|            char c;
  780|      1|            read(&c);
  781|      1|            *val = (c == 1);
  782|      1|        }
  783|      1|    }
_ZN4Ogre16StreamSerialiser17calculateChecksumEPNS0_5ChunkE:
  810|     41|    {
  811|       |        // Always calculate checksums in little endian to make sure they match 
  812|       |        // Otherwise checksums for the same data on different endians will not match
  813|     41|        uint32 id = c->id;
  814|     41|        uint16 version = c->version;
  815|     41|        uint32 length = c->length;
  816|       |#if OGRE_ENDIAN == OGRE_ENDIAN_BIG
  817|       |		Bitwise::bswapBuffer(&id, sizeof(uint32));
  818|       |		Bitwise::bswapBuffer(&version, sizeof(uint16));
  819|       |		Bitwise::bswapBuffer(&length, sizeof(uint32));
  820|       |#endif
  821|       |
  822|       |		// we cannot switch to murmur3 like everywhere else to allow loading legacy files
  823|     41|        uint32 hashVal = SuperFastHash((const char*)&id, sizeof(uint32), 0);
  824|     41|        hashVal = SuperFastHash((const char*)&version, sizeof(uint16), hashVal);
  825|     41|        hashVal = SuperFastHash((const char*)&length, sizeof(uint32), hashVal);
  826|       |
  827|     41|        return hashVal;
  828|     41|    }
_ZN4Ogre16StreamSerialiser8popChunkEj:
  831|      1|    {
  832|      1|        OgreAssert(!mChunkStack.empty(), "No active chunk!");
  ------------------
  |  Branch (832:9): [True: 0, False: 1]
  ------------------
  833|       |
  834|      1|        const Chunk* chunk = mChunkStack.back();
  835|      1|        OgreAssert(chunk->id == id, "Incorrect chunk id!");
  ------------------
  |  Branch (835:9): [True: 1, False: 0]
  ------------------
  836|       |
  837|      0|        Chunk* c = mChunkStack.back();
  838|      0|        mChunkStack.pop_back();
  839|      0|        return c;
  840|       |
  841|      1|    }
OgreStreamSerialiser.cpp:_ZN4OgreL13SuperFastHashEPKcij:
   40|    123|    {
   41|    123|#if OGRE_ENDIAN == OGRE_ENDIAN_LITTLE
   42|    123|#  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|    123|        uint32 hash;
   49|    123|        int rem;
   50|       |
   51|    123|        if (hashSoFar)
  ------------------
  |  Branch (51:13): [True: 82, False: 41]
  ------------------
   52|     82|            hash = hashSoFar;
   53|     41|        else
   54|     41|            hash = len;
   55|       |
   56|    123|        if (len <= 0 || data == NULL) return 0;
  ------------------
  |  Branch (56:13): [True: 0, False: 123]
  |  Branch (56:25): [True: 0, False: 123]
  ------------------
   57|       |
   58|    123|        rem = len & 3;
   59|    123|        len >>= 2;
   60|       |
   61|       |        /* Main loop */
   62|    205|        for (;len > 0; len--) {
  ------------------
  |  Branch (62:15): [True: 82, False: 123]
  ------------------
   63|     82|            hash  += OGRE_GET16BITS (data);
  ------------------
  |  |   42|     82|#  define OGRE_GET16BITS(d) (*((const uint16 *) (d)))
  ------------------
   64|     82|            uint32 tmp    = (OGRE_GET16BITS (data+2) << 11) ^ hash;
  ------------------
  |  |   42|     82|#  define OGRE_GET16BITS(d) (*((const uint16 *) (d)))
  ------------------
   65|     82|            hash   = (hash << 16) ^ tmp;
   66|     82|            data  += 2*sizeof (uint16);
   67|     82|            hash  += hash >> 11;
   68|     82|        }
   69|       |
   70|       |        /* Handle end cases */
   71|    123|        switch (rem) {
  ------------------
  |  Branch (71:17): [True: 41, False: 82]
  ------------------
   72|      0|        case 3: hash += OGRE_GET16BITS (data);
  ------------------
  |  |   42|      0|#  define OGRE_GET16BITS(d) (*((const uint16 *) (d)))
  ------------------
  |  Branch (72:9): [True: 0, False: 123]
  ------------------
   73|      0|            hash ^= hash << 16;
   74|      0|            hash ^= data[sizeof (uint16)] << 18;
   75|      0|            hash += hash >> 11;
   76|      0|            break;
   77|     41|        case 2: hash += OGRE_GET16BITS (data);
  ------------------
  |  |   42|     41|#  define OGRE_GET16BITS(d) (*((const uint16 *) (d)))
  ------------------
  |  Branch (77:9): [True: 41, False: 82]
  ------------------
   78|     41|            hash ^= hash << 11;
   79|     41|            hash += hash >> 17;
   80|     41|            break;
   81|      0|        case 1: hash += *data;
  ------------------
  |  Branch (81:9): [True: 0, False: 123]
  ------------------
   82|      0|            hash ^= hash << 10;
   83|      0|            hash += hash >> 1;
   84|    123|        }
   85|       |
   86|       |        /* Force "avalanching" of final 127 bits */
   87|    123|        hash ^= hash << 3;
   88|    123|        hash += hash >> 5;
   89|    123|        hash ^= hash << 4;
   90|    123|        hash += hash >> 17;
   91|    123|        hash ^= hash << 25;
   92|    123|        hash += hash >> 6;
   93|       |
   94|    123|        return hash;
   95|    123|#undef OGRE_GET16BITS
   96|    123|    }

_ZN4Ogre10StringUtil4trimERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbb:
   42|  68.5k|    {
   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|  68.5k|        static const String delims = " \t\r\n";
   67|  68.5k|        if(right)
  ------------------
  |  Branch (67:12): [True: 68.5k, False: 0]
  ------------------
   68|  68.5k|            str.erase(str.find_last_not_of(delims)+1); // trim right
   69|  68.5k|        if(left)
  ------------------
  |  Branch (69:12): [True: 68.5k, False: 0]
  ------------------
   70|  68.5k|            str.erase(0, str.find_first_not_of(delims)); // trim left
   71|  68.5k|    }

_ZN4Ogre15ParamDictionaryC2Ev:
   36|      2|    ParamDictionary::ParamDictionary() {}
_ZN4Ogre15ParamDictionaryD2Ev:
   37|      4|    ParamDictionary::~ParamDictionary() {}
_ZN4Ogre15StringInterface21createParamDictionaryERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   72|    737|    {
   73|    737|        OGRE_LOCK_MUTEX( msDictionaryMutex );
   74|       |
   75|    737|        ParamDictionaryMap::iterator it = msDictionary.find(className);
   76|       |
   77|    737|        if ( it == msDictionary.end() )
  ------------------
  |  Branch (77:14): [True: 2, False: 735]
  ------------------
   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|    735|        else
   84|    735|        {
   85|    735|            mParamDict = &it->second;
   86|    735|            mParamDictName = className;
   87|    735|            return false;
   88|    735|        }
   89|    737|    }

_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|    }

LLVMFuzzerTestOneInput:
  167|  3.63k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
  168|  3.63k|  if (size < 2)
  ------------------
  |  Branch (168:7): [True: 1, False: 3.62k]
  ------------------
  169|      1|    return 0;
  170|       |
  171|  3.62k|  global_init();
  172|       |
  173|  3.62k|  FuzzedDataProvider provider(data, size);
  174|  3.62k|  uint8_t target = provider.ConsumeIntegral<uint8_t>() % FUZZ_TARGET_COUNT;
  175|  3.62k|  auto remaining = provider.ConsumeRemainingBytes<uint8_t>();
  176|       |
  177|  3.62k|  if (remaining.empty())
  ------------------
  |  Branch (177:7): [True: 0, False: 3.62k]
  ------------------
  178|      0|    return 0;
  179|       |
  180|  3.62k|  switch (target) {
  ------------------
  |  Branch (180:11): [True: 3.62k, False: 0]
  ------------------
  181|  1.82k|  case FUZZ_MESH:
  ------------------
  |  Branch (181:3): [True: 1.82k, False: 1.80k]
  ------------------
  182|  1.82k|    fuzz_mesh(remaining.data(), remaining.size());
  183|  1.82k|    break;
  184|    734|  case FUZZ_SKELETON:
  ------------------
  |  Branch (184:3): [True: 734, False: 2.89k]
  ------------------
  185|    734|    fuzz_skeleton(remaining.data(), remaining.size());
  186|    734|    break;
  187|    936|  case FUZZ_CONFIG:
  ------------------
  |  Branch (187:3): [True: 936, False: 2.69k]
  ------------------
  188|    936|    fuzz_config(remaining.data(), remaining.size());
  189|    936|    break;
  190|    137|  case FUZZ_STREAM_SERIALISER:
  ------------------
  |  Branch (190:3): [True: 137, False: 3.49k]
  ------------------
  191|    137|    fuzz_stream_serialiser(remaining.data(), remaining.size());
  192|    137|    break;
  193|  3.62k|  }
  194|       |
  195|  3.62k|  return 0;
  196|  3.62k|}
ogre_deep_fuzz.cpp:_ZL11global_initv:
   57|  3.62k|static void global_init() {
   58|  3.62k|  if (g_initialized)
  ------------------
  |  Branch (58:7): [True: 3.62k, False: 1]
  ------------------
   59|  3.62k|    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|  1.82k|static void fuzz_mesh(const uint8_t *data, size_t size) {
   79|  1.82k|  Ogre::MeshPtr mesh =
   80|  1.82k|      Ogre::MeshManager::getSingleton().create("fuzz.mesh", "General");
   81|       |
   82|  1.82k|  Ogre::DataStreamPtr stream(
   83|  1.82k|      new Ogre::MemoryDataStream(const_cast<uint8_t *>(data), size, false, true));
   84|       |
   85|  1.82k|  Ogre::MeshSerializer serializer;
   86|  1.82k|  try {
   87|  1.82k|    serializer.importMesh(stream, mesh.get());
   88|  1.82k|  } catch (Ogre::Exception &) {
   89|  1.81k|  } catch (std::exception &) {
   90|      0|  }
   91|       |
   92|  1.82k|  Ogre::MeshManager::getSingleton().remove(mesh);
   93|  1.82k|}
ogre_deep_fuzz.cpp:_ZL13fuzz_skeletonPKhm:
   95|    734|static void fuzz_skeleton(const uint8_t *data, size_t size) {
   96|    734|  Ogre::SkeletonPtr skeleton =
   97|    734|      Ogre::SkeletonManager::getSingleton().create("fuzz.skeleton", "General");
   98|       |
   99|    734|  Ogre::DataStreamPtr stream(
  100|    734|      new Ogre::MemoryDataStream(const_cast<uint8_t *>(data), size, false, true));
  101|       |
  102|    734|  Ogre::SkeletonSerializer serializer;
  103|    734|  try {
  104|    734|    serializer.importSkeleton(stream, skeleton.get());
  105|    734|  } catch (Ogre::Exception &) {
  106|    730|  } catch (std::exception &) {
  107|      0|  }
  108|       |
  109|    734|  Ogre::SkeletonManager::getSingleton().remove(skeleton);
  110|    734|}
ogre_deep_fuzz.cpp:_ZL11fuzz_configPKhm:
  112|    936|static void fuzz_config(const uint8_t *data, size_t size) {
  113|    936|  Ogre::DataStreamPtr stream(new Ogre::MemoryDataStream(
  114|    936|      "fuzz.cfg", const_cast<uint8_t *>(data), size, false, true));
  115|       |
  116|    936|  Ogre::ConfigFile cf;
  117|    936|  try {
  118|    936|    cf.load(stream);
  119|       |
  120|       |    /* Exercise iteration over parsed sections and settings */
  121|  3.29k|    for (auto &sec : cf.getSettingsBySection()) {
  ------------------
  |  Branch (121:20): [True: 3.29k, False: 936]
  ------------------
  122|  17.0k|      for (auto &kv : sec.second) {
  ------------------
  |  Branch (122:21): [True: 17.0k, False: 3.29k]
  ------------------
  123|  17.0k|        volatile const char *k = kv.first.c_str();
  124|  17.0k|        volatile const char *v = kv.second.c_str();
  125|  17.0k|        (void)k;
  126|  17.0k|        (void)v;
  127|  17.0k|      }
  128|  3.29k|    }
  129|    936|  } catch (Ogre::Exception &) {
  130|      0|  } catch (std::exception &) {
  131|      0|  }
  132|    936|}
ogre_deep_fuzz.cpp:_ZL22fuzz_stream_serialiserPKhm:
  134|    137|static void fuzz_stream_serialiser(const uint8_t *data, size_t size) {
  135|    137|  Ogre::DataStreamPtr stream(
  136|    137|      new Ogre::MemoryDataStream(const_cast<uint8_t *>(data), size, false, true));
  137|       |
  138|    137|  try {
  139|    137|    Ogre::StreamSerialiser serialiser(stream);
  140|       |
  141|       |    /* Try to read multiple chunks, exercising the chunk state machine */
  142|    137|    for (int i = 0; i < 32; i++) {
  ------------------
  |  Branch (142:21): [True: 137, False: 0]
  ------------------
  143|    137|      const Ogre::StreamSerialiser::Chunk *c = serialiser.readChunkBegin();
  144|    137|      if (!c)
  ------------------
  |  Branch (144:11): [True: 0, False: 137]
  ------------------
  145|      0|        break;
  146|       |
  147|       |      /* Try reading various data types from the chunk */
  148|    137|      Ogre::String str;
  149|    137|      try { serialiser.read(&str); } catch (...) {}
  150|       |
  151|    137|      Ogre::Real r;
  152|      0|      try { serialiser.read(&r); } catch (...) {}
  153|       |
  154|      0|      Ogre::Vector3 v3;
  155|      0|      try { serialiser.read(&v3); } catch (...) {}
  156|       |
  157|      0|      Ogre::Vector4 v4;
  158|      0|      try { serialiser.read(&v4); } catch (...) {}
  159|       |
  160|      0|      serialiser.readChunkEnd(c->id);
  161|      0|    }
  162|    137|  } catch (Ogre::Exception &) {
  163|    137|  } catch (std::exception &) {
  164|      0|  }
  165|    137|}