_ZN4Ogre15CompositionPass15setThreadGroupsERKNS_6VectorILi3EiEE:
  315|    681|        void setThreadGroups(const Vector3i& g) { mThreadGroups = g; }
_ZN4Ogre15CompositionPass13setCameraNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  318|  2.77k|        void setCameraName(const String& name) { mRenderScene.cameraName = name; }
_ZN4Ogre15CompositionPass20setAlignCameraToFaceEb:
  321|    294|        void setAlignCameraToFace(bool val) { mRenderScene.alignCameraToFace = val; }
_ZN4Ogre15CompositionPass8InputTexC2Ev:
  240|   261k|            InputTex() : mrtIndex(0) {}
_ZN4Ogre15CompositionPass8InputTexC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEm:
  242|  2.65k|                : name(_name), mrtIndex(_mrtIndex) {}
_ZN4Ogre15CompositionPass12MaterialDataC2Ev:
  340|  16.3k|            MaterialData() : identifier(0) {}
_ZN4Ogre15CompositionPass15RenderSceneDataC2Ev:
  358|  16.3k|                : firstRenderQueue(RENDER_QUEUE_BACKGROUND), lastRenderQueue(RENDER_QUEUE_TRANSPARENTS),
  359|  16.3k|                  alignCameraToFace(false)
  360|  16.3k|            {
  361|  16.3k|            }
_ZN4Ogre15CompositionPass9ClearDataC2Ev:
  379|  16.3k|                : buffers(FBT_COLOUR | FBT_DEPTH), colour(ColourValue::ZERO), automaticColour(false),
  380|  16.3k|                  depth(1.0f), stencil(0)
  381|  16.3k|            {
  382|  16.3k|            }
_ZN4Ogre15CompositionPass8QuadDataC2Ev:
  401|  16.3k|                : cornerModified(false), rect(-1, 1, 1, -1), farCorners(false), farCornersViewSpace(false)
  402|  16.3k|            {
  403|  16.3k|            }

_ZN4Ogre21CompositionTargetPass14setOutputSliceEi:
   75|  17.0k|        void setOutputSlice(int slice) { mOutputSlice = slice; }
_ZNK4Ogre21CompositionTargetPass9getPassesEv:
  141|    723|        const Passes& getPasses() const {
  142|    723|            return mPasses;
  143|    723|        }

_ZNK4Ogre28ExternalTextureSourceManager16getCurrentPlugInEv:
   67|    527|        ExternalTextureSource* getCurrentPlugIn( void ) const { return mCurrExternalTextureSource; }

_ZN4Ogre17GpuProgramManager16createParametersEv:
  163|  54.8k|        static GpuProgramParametersPtr createParameters(void) { return std::make_shared<GpuProgramParameters>(); }

_ZNK4Ogre15GpuProgramUsage7getTypeEv:
  102|  1.20M|        GpuProgramType getType(void) const { return mType; }
_ZNK4Ogre15GpuProgramUsage14getProgramNameEv:
  125|  1.18M|        const String& getProgramName(void) const { return mProgram->getName(); }

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

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

_ZN4Ogre34RenderSystemCapabilitiesSerializer22addCapabilitiesMappingERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_12CapabilitiesE:
  100|     43|        {
  101|     43|            mCapabilitiesMap.emplace(name, cap);
  102|     43|        }
_ZN4Ogre34RenderSystemCapabilitiesSerializer14addKeywordTypeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS0_21CapabilityKeywordTypeE:
  117|     31|        {
  118|     31|            mKeywordTypeMap.emplace(keyword, type);
  119|     31|        }
_ZN4Ogre34RenderSystemCapabilitiesSerializer18addSetStringMethodERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEMNS_24RenderSystemCapabilitiesEFvS9_E:
  132|      4|        {
  133|      4|            mSetStringMethodDispatchTable.emplace(keyword, method);
  134|      4|        }
_ZN4Ogre34RenderSystemCapabilitiesSerializer15addSetIntMethodERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEMNS_24RenderSystemCapabilitiesEFvtE:
  152|     10|        {
  153|     10|            mSetIntMethodDispatchTable.emplace(keyword, method);
  154|     10|        }
_ZN4Ogre34RenderSystemCapabilitiesSerializer16addSetBoolMethodERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEMNS_24RenderSystemCapabilitiesEFvbE:
  172|      1|        {
  173|      1|            mSetBoolMethodDispatchTable.emplace(keyword, method);
  174|      1|        }
_ZN4Ogre34RenderSystemCapabilitiesSerializer16addSetRealMethodERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEMNS_24RenderSystemCapabilitiesEFvfE:
  192|      1|        {
  193|      1|            mSetRealMethodDispatchTable.emplace(keyword, method);
  194|      1|        }

_ZNK4Ogre15ResourceManager15getLoadingOrderEv:
  383|  15.9M|        Real getLoadingOrder(void) const override { return mLoadOrder; }

_ZN4Ogre22ScriptCompilerListenerD2Ev:
  383|      1|        virtual ~ScriptCompilerListener() {}

_ZN4Ogre16ScriptTranslator7getRealERKNS_9SharedPtrINS_12AbstractNodeEEEPf:
   72|   154k|        {
   73|   154k|#if OGRE_DOUBLE_PRECISION == 0
   74|   154k|            return getFloat(node, result);
   75|       |#else
   76|       |            return getDouble(node, result);
   77|       |#endif
   78|   154k|        }

_ZN4Ogre9SharedPtrINSt3__14listINS0_INS_12ConcreteNodeEEENS1_9allocatorIS4_EEEEEC2IS7_EERKNS1_10shared_ptrIT_EE:
   59|  9.45k|        SharedPtr(const shared_ptr<Y>& r) : shared_ptr<T>(r) {}
_ZN4Ogre9SharedPtrINS_10DataStreamEEC2INS_16MemoryDataStreamEEEPT_:
   50|  15.8k|        explicit SharedPtr(Y* ptr) : shared_ptr<T>(ptr) {}

_ZN4Ogre7TextureD2Ev:
  144|  15.8M|        virtual ~Texture() {}

_ZN4Ogre21DefaultTextureManager10createImplERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmS9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
  446|  15.8M|        {
  447|  15.8M|            return new NullTexture(this, name, handle, group);
  448|  15.8M|        }
_ZN4Ogre21DefaultTextureManager11NullTextureC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmSC_:
  435|  15.8M|                : Texture(creator, name, handle, group)
  436|  15.8M|            {
  437|  15.8M|            }
_ZN4Ogre14TextureManager20getDefaultNumMipmapsEv:
  399|  15.9M|        {
  400|  15.9M|            return mDefaultNumMipmaps;
  401|  15.9M|        }
_ZN4Ogre14TextureManager18_createSamplerImplEv:
  416|  8.18k|        virtual SamplerPtr _createSamplerImpl() { return std::make_shared<Sampler>(); }

_ZN4Ogre9ASTCCodec7startupEv:
  165|      1|	{
  166|      1|		if (!msInstance)
  ------------------
  |  Branch (166:7): [True: 1, False: 0]
  ------------------
  167|      1|		{
  168|      1|			msInstance = OGRE_NEW ASTCCodec();
  169|      1|			Codec::registerCodec(msInstance);
  170|      1|		}
  171|       |
  172|      1|        LogManager::getSingleton().logMessage(LML_NORMAL,
  173|      1|                                              "ASTC codec registering");
  174|      1|	}
_ZN4Ogre9ASTCCodecC2Ev:
  187|      1|        mType("astc")
  188|      1|    { 
  189|      1|    }
_ZNK4Ogre9ASTCCodec7getTypeEv:
  273|      1|    {
  274|      1|        return mType;
  275|      1|    }

_ZN4Ogre14ArchiveManager12getSingletonEv:
   40|      3|    {  
   41|       |        assert( msSingleton );  return ( *msSingleton );  
   42|      3|    }
_ZN4Ogre14ArchiveManagerC2Ev:
   45|      1|    {
   46|      1|    }
_ZN4Ogre14ArchiveManager17addArchiveFactoryEPNS_14ArchiveFactoryE:
  126|      3|    {
  127|      3|        mArchFactories.emplace(factory->getType(), factory);
  128|      3|        LogManager::getSingleton().logMessage("ArchiveFactory for type '" + factory->getType() + "' registered");
  129|      3|    }

_ZNK4Ogre21BillboardChainFactory7getTypeEv:
  710|      3|    {
  711|      3|        return MOT_BILLBOARD_CHAIN;
  712|      3|    }

_ZNK4Ogre19BillboardSetFactory7getTypeEv:
 1035|      3|    {
 1036|      3|        return MOT_BILLBOARD_SET;
 1037|      3|    }

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

_ZN4Ogre15CompositionPassC2EPNS_21CompositionTargetPassE:
   35|  16.3k|    mParent(parent),
   36|  16.3k|    mType(PT_RENDERQUAD)
   37|  16.3k|{
   38|  16.3k|}
_ZN4Ogre15CompositionPassD2Ev:
   41|  16.3k|{
   42|  16.3k|}
_ZN4Ogre15CompositionPass7setTypeENS0_8PassTypeE:
   45|  16.3k|{
   46|  16.3k|    mType = type;
   47|  16.3k|}
_ZNK4Ogre15CompositionPass7getTypeEv:
   50|  16.3k|{
   51|  16.3k|    return mType;
   52|  16.3k|}
_ZN4Ogre15CompositionPass13setIdentifierEj:
   55|    221|{
   56|    221|    mMaterial.identifier = id;
   57|    221|}
_ZN4Ogre15CompositionPass11setMaterialERKNS_9SharedPtrINS_8MaterialEEE:
   65|  7.28k|{
   66|  7.28k|    mMaterial.material = mat;
   67|  7.28k|}
_ZN4Ogre15CompositionPass15setClearBuffersEj:
   80|  1.95k|{
   81|  1.95k|    mClear.buffers = val;
   82|  1.95k|}
_ZN4Ogre15CompositionPass14setClearColourERKNS_11ColourValueE:
   90|    582|{
   91|    582|    mClear.colour = val;
   92|    582|}
_ZN4Ogre15CompositionPass8setInputEmRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEm:
  110|  2.65k|{
  111|       |    assert(id < OGRE_MAX_TEXTURE_LAYERS);
  112|  2.65k|    mMaterial.inputs[id] = InputTex(input, mrtIndex);
  113|  2.65k|}
_ZN4Ogre15CompositionPass19setFirstRenderQueueEh:
  146|  1.35k|{
  147|  1.35k|    mRenderScene.firstRenderQueue = id;
  148|  1.35k|}
_ZN4Ogre15CompositionPass18setLastRenderQueueEh:
  156|    917|{
  157|    917|    mRenderScene.lastRenderQueue = id;
  158|    917|}
_ZN4Ogre15CompositionPass17setMaterialSchemeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  166|    692|{
  167|    692|    mRenderScene.materialScheme = schemeName;
  168|    692|}
_ZN4Ogre15CompositionPass13setClearDepthEf:
  176|    249|{
  177|    249|    mClear.depth = depth;
  178|    249|}
_ZN4Ogre15CompositionPass15setClearStencilEt:
  184|    332|{
  185|    332|    mClear.stencil = value;
  186|    332|}
_ZN4Ogre15CompositionPass15setStencilCheckEb:
  193|    239|{
  194|    239|    mStencilState.enabled = value;
  195|    239|}
_ZN4Ogre15CompositionPass14setStencilFuncENS_15CompareFunctionE:
  201|    223|{
  202|    223|    mStencilState.compareOp = value;
  203|    223|}
_ZN4Ogre15CompositionPass18setStencilRefValueEj:
  209|    257|{
  210|    257|    mStencilState.referenceValue = value;
  211|    257|}
_ZN4Ogre15CompositionPass14setStencilMaskEj:
  217|    210|{
  218|    210|    mStencilState.compareMask = value;
  219|    210|}
_ZN4Ogre15CompositionPass16setStencilFailOpENS_16StencilOperationE:
  225|    702|{
  226|    702|    mStencilState.stencilFailOp = value;
  227|    702|}
_ZN4Ogre15CompositionPass21setStencilDepthFailOpENS_16StencilOperationE:
  233|    425|{
  234|    425|    mStencilState.depthFailOp = value;
  235|    425|}
_ZN4Ogre15CompositionPass16setStencilPassOpENS_16StencilOperationE:
  241|    780|{
  242|    780|    mStencilState.depthStencilPassOp = value;
  243|    780|}
_ZN4Ogre15CompositionPass27setStencilTwoSidedOperationEb:
  249|    342|{
  250|    342|    mStencilState.twoSidedOperation = value;
  251|    342|}
_ZN4Ogre15CompositionPass17setQuadFarCornersEbb:
  257|    191|{
  258|    191|    mQuad.farCorners = farCorners;
  259|    191|    mQuad.farCornersViewSpace = farCornersViewSpace;
  260|    191|}
_ZN4Ogre15CompositionPass13setCustomTypeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  271|  1.23k|{
  272|  1.23k|    mCustomType = customType;
  273|  1.23k|}

_ZN4Ogre21CompositionTargetPassC2EPNS_20CompositionTechniqueE:
   35|  27.5k|    mParent(parent),
   36|  27.5k|    mInputMode(IM_NONE),
   37|  27.5k|    mOnlyInitial(false),
   38|  27.5k|    mVisibilityMask(0xFFFFFFFF),
   39|  27.5k|    mLodBias(1.0f),
   40|  27.5k|    mMaterialScheme(MaterialManager::DEFAULT_SCHEME_NAME), 
   41|  27.5k|    mShadowsEnabled(true),
   42|  27.5k|    mOutputSlice(0)
   43|  27.5k|{
   44|  27.5k|    if (Root::getSingleton().getRenderSystem())
  ------------------
  |  Branch (44:9): [True: 0, False: 27.5k]
  ------------------
   45|      0|    {
   46|      0|        mMaterialScheme = Root::getSingleton().getRenderSystem()->_getDefaultViewportMaterialScheme();
   47|      0|    }
   48|  27.5k|}
_ZN4Ogre21CompositionTargetPassD2Ev:
   51|  27.5k|{
   52|  27.5k|    removeAllPasses();
   53|  27.5k|}
_ZN4Ogre21CompositionTargetPass12setInputModeENS0_9InputModeE:
   56|  1.77k|{
   57|  1.77k|    mInputMode = mode;
   58|  1.77k|}
_ZNK4Ogre21CompositionTargetPass12getInputModeEv:
   61|    523|{
   62|    523|    return mInputMode;
   63|    523|}
_ZN4Ogre21CompositionTargetPass13setOutputNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   66|  20.2k|{
   67|  20.2k|    mOutputName = out;
   68|  20.2k|}
_ZN4Ogre21CompositionTargetPass14setOnlyInitialEb:
   76|    209|{
   77|    209|    mOnlyInitial = value;
   78|    209|}
_ZN4Ogre21CompositionTargetPass17setVisibilityMaskEj:
   86|  1.59k|{
   87|  1.59k|    mVisibilityMask = mask;
   88|  1.59k|}
_ZN4Ogre21CompositionTargetPass10setLodBiasEf:
   96|    213|{
   97|    213|    mLodBias = bias;
   98|    213|}
_ZN4Ogre21CompositionTargetPass17setMaterialSchemeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  106|    725|{
  107|    725|    mMaterialScheme = schemeName;
  108|    725|}
_ZN4Ogre21CompositionTargetPass17setShadowsEnabledEb:
  116|    406|{
  117|    406|    mShadowsEnabled = enabled;
  118|    406|}
_ZN4Ogre21CompositionTargetPass10createPassENS_15CompositionPass8PassTypeE:
  126|  16.3k|{
  127|       |    CompositionPass *t = OGRE_NEW CompositionPass(this);
  128|  16.3k|    t->setType(type);
  129|  16.3k|    mPasses.push_back(t);
  130|  16.3k|    return t;
  131|  16.3k|}
_ZN4Ogre21CompositionTargetPass15removeAllPassesEv:
  143|  27.5k|{
  144|  27.5k|    for (auto p : mPasses)
  ------------------
  |  Branch (144:17): [True: 16.3k, False: 27.5k]
  ------------------
  145|  16.3k|    {
  146|       |        OGRE_DELETE (p);
  147|  16.3k|    }
  148|  27.5k|    mPasses.clear();
  149|  27.5k|}

_ZN4Ogre20CompositionTechniqueC2EPNS_10CompositorE:
   34|  7.17k|    mParent(parent)
   35|  7.17k|{
   36|       |    mOutputTarget = OGRE_NEW CompositionTargetPass(this);
   37|  7.17k|}
_ZN4Ogre20CompositionTechniqueD2Ev:
   40|  7.17k|{
   41|  7.17k|    removeAllTextureDefinitions();
   42|  7.17k|    removeAllTargetPasses();
   43|       |    OGRE_DELETE  mOutputTarget;
   44|  7.17k|}
_ZN4Ogre20CompositionTechnique23createTextureDefinitionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   47|  6.60k|{
   48|  6.60k|    if(getTextureDefinition(name))
  ------------------
  |  Branch (48:8): [True: 3.80k, False: 2.80k]
  ------------------
   49|  6.60k|        OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, "Texture '"+name+"' already exists");
   50|       |
   51|  2.80k|    TextureDefinition *t = OGRE_NEW TextureDefinition();
   52|  2.80k|    t->name = name;
   53|  2.80k|    mTextureDefinitions.push_back(t);
   54|  2.80k|    return t;
   55|  6.60k|}
_ZNK4Ogre20CompositionTechnique20getTextureDefinitionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   67|  6.60k|{
   68|  6.60k|    for (auto *t : mTextureDefinitions)
  ------------------
  |  Branch (68:18): [True: 9.31k, False: 2.80k]
  ------------------
   69|  9.31k|    {
   70|  9.31k|        if (t->name == name)
  ------------------
  |  Branch (70:13): [True: 3.80k, False: 5.50k]
  ------------------
   71|  3.80k|            return t;
   72|  9.31k|    }
   73|  2.80k|    return 0;
   74|       |
   75|  6.60k|}
_ZN4Ogre20CompositionTechnique27removeAllTextureDefinitionsEv:
   78|  7.17k|{
   79|  7.17k|    for (auto *t : mTextureDefinitions)
  ------------------
  |  Branch (79:18): [True: 2.80k, False: 7.17k]
  ------------------
   80|  2.80k|    {
   81|       |        OGRE_DELETE t;
   82|  2.80k|    }
   83|  7.17k|    mTextureDefinitions.clear();
   84|  7.17k|}
_ZN4Ogre20CompositionTechnique16createTargetPassEv:
   93|  20.4k|{
   94|       |    CompositionTargetPass *t = OGRE_NEW CompositionTargetPass(this);
   95|  20.4k|    mTargetPasses.push_back(t);
   96|  20.4k|    return t;
   97|  20.4k|}
_ZN4Ogre20CompositionTechnique21removeAllTargetPassesEv:
  109|  7.17k|{
  110|  7.17k|    for (auto *t : mTargetPasses)
  ------------------
  |  Branch (110:18): [True: 20.4k, False: 7.17k]
  ------------------
  111|  20.4k|    {
  112|       |        OGRE_DELETE t;
  113|  20.4k|    }
  114|  7.17k|    mTargetPasses.clear();
  115|  7.17k|}
_ZN4Ogre20CompositionTechnique13setSchemeNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  201|    742|{
  202|    742|    mSchemeName = schemeName;
  203|    742|}

_ZN4Ogre10CompositorC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE:
   37|  2.32k|    Resource(creator, name, handle, group, isManual, loader),
   38|  2.32k|    mCompilationRequired(true)
   39|  2.32k|{
   40|  2.32k|}
_ZN4Ogre10CompositorD2Ev:
   44|  2.32k|{
   45|  2.32k|    removeAllTechniques();
   46|       |    // have to call this here reather than in Resource destructor
   47|       |    // since calling virtual methods in base destructors causes crash
   48|  2.32k|    unload();
   49|  2.32k|}
_ZN4Ogre10Compositor15createTechniqueEv:
   52|  7.17k|{
   53|       |    CompositionTechnique *t = OGRE_NEW CompositionTechnique(this);
   54|  7.17k|    mTechniques.push_back(t);
   55|  7.17k|    mCompilationRequired = true;
   56|  7.17k|    return t;
   57|  7.17k|}
_ZN4Ogre10Compositor19removeAllTechniquesEv:
   71|  4.58k|{
   72|  4.58k|    for (auto *t : mTechniques)
  ------------------
  |  Branch (72:18): [True: 7.17k, False: 4.58k]
  ------------------
   73|  7.17k|    {
   74|       |        OGRE_DELETE t;
   75|  7.17k|    }
   76|  4.58k|    mTechniques.clear();
   77|  4.58k|    mSupportedTechniques.clear();
   78|  4.58k|    mCompilationRequired = true;
   79|  4.58k|}

_ZN4Ogre17CompositorManager12getSingletonEv:
   44|  2.32k|{  
   45|       |    assert( msSingleton );  return ( *msSingleton );  
   46|  2.32k|}//-----------------------------------------------------------------------
_ZN4Ogre17CompositorManagerC2Ev:
   48|      1|    mRectangle(0)
   49|      1|{
   50|       |    // Loading order (just after materials)
   51|      1|    mLoadOrder = 110.0f;
   52|       |
   53|       |    // Resource type
   54|      1|    mResourceType = "Compositor";
   55|       |
   56|       |    // Register with resource group manager
   57|      1|    ResourceGroupManager::getSingleton()._registerResourceManager(mResourceType, this);
   58|       |
   59|      1|}
_ZN4Ogre17CompositorManager10createImplERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmS9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
   76|  2.32k|{
   77|       |    return OGRE_NEW Compositor(this, name, handle, group, isManual, loader);
   78|  2.32k|}
_ZN4Ogre17CompositorManager6createERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
   83|  2.32k|{
   84|  2.32k|    return static_pointer_cast<Compositor>(createResource(name,group,isManual,loader,createParams));
   85|  2.32k|}

_ZN4Ogre8DDSCodec7startupEv:
  169|      1|    {
  170|      1|        if (!msInstance)
  ------------------
  |  Branch (170:13): [True: 1, False: 0]
  ------------------
  171|      1|        {
  172|       |
  173|      1|            LogManager::getSingleton().logMessage(
  174|      1|                LML_NORMAL,
  175|      1|                "DDS codec registering");
  176|       |
  177|      1|            msInstance = OGRE_NEW DDSCodec();
  178|      1|            Codec::registerCodec(msInstance);
  179|      1|        }
  180|       |
  181|      1|    }
_ZN4Ogre8DDSCodecC2Ev:
  195|      1|        mType("dds"),
  196|      1|        mDecodeEnforce(false)
  197|      1|    { 
  198|      1|    }
_ZNK4Ogre8DDSCodec7getTypeEv:
 1056|      1|    {
 1057|      1|        return mType;
 1058|      1|    }

_ZN4Ogre10DataStream11getAsStringEv:
  169|  15.8k|    {
  170|       |        // Read the entire buffer - ideally in one read, but if the size of
  171|       |        // the buffer is unknown, do multiple fixed size reads.
  172|  15.8k|        size_t bufSize = (mSize > 0 ? mSize : 4096);
  ------------------
  |  Branch (172:27): [True: 15.8k, False: 0]
  ------------------
  173|  15.8k|        char* pBuf = OGRE_ALLOC_T(char, bufSize, MEMCATEGORY_GENERAL);
  174|       |        // Ensure read from begin of stream
  175|  15.8k|        seek(0);
  176|  15.8k|        String result;
  177|  31.7k|        while (!eof())
  ------------------
  |  Branch (177:16): [True: 15.8k, False: 15.8k]
  ------------------
  178|  15.8k|        {
  179|  15.8k|            size_t nr = read(pBuf, bufSize);
  180|  15.8k|            result.append(pBuf, nr);
  181|  15.8k|        }
  182|       |        OGRE_FREE(pBuf, MEMCATEGORY_GENERAL);
  183|  15.8k|        return result;
  184|  15.8k|    }
_ZN4Ogre16MemoryDataStreamC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPvmbb:
  199|  15.8k|        : DataStream(name, static_cast<uint16>(readOnly ? READ : (READ | WRITE)))
  ------------------
  |  Branch (199:48): [True: 15.8k, False: 0]
  ------------------
  200|  15.8k|    {
  201|  15.8k|        mData = mPos = static_cast<uchar*>(pMem);
  202|  15.8k|        mSize = inSize;
  203|  15.8k|        mEnd = mData + mSize;
  204|  15.8k|        mFreeOnClose = freeOnClose;
  205|       |        assert(mEnd >= mPos);
  206|  15.8k|    }
_ZN4Ogre16MemoryDataStreamD2Ev:
  336|  15.8k|    {
  337|  15.8k|        close();
  338|  15.8k|    }
_ZN4Ogre16MemoryDataStream4readEPvm:
  341|  15.8k|    {
  342|       |        // Read over end of memory?
  343|  15.8k|        if (mPos >= mEnd)
  ------------------
  |  Branch (343:13): [True: 0, False: 15.8k]
  ------------------
  344|      0|            return 0;
  345|  15.8k|        size_t cnt = std::min(count, static_cast<size_t>(mEnd - mPos));
  346|  15.8k|        if (cnt == 0)
  ------------------
  |  Branch (346:13): [True: 0, False: 15.8k]
  ------------------
  347|      0|            return 0;
  348|       |
  349|  15.8k|        assert (cnt<=count);
  350|       |
  351|  15.8k|        memcpy(buf, mPos, cnt);
  352|  15.8k|        mPos += cnt;
  353|  15.8k|        return cnt;
  354|  15.8k|    }
_ZN4Ogre16MemoryDataStream4seekEm:
  443|  15.8k|    {
  444|  15.8k|        if (mData + pos > mEnd)
  ------------------
  |  Branch (444:13): [True: 0, False: 15.8k]
  ------------------
  445|      0|            pos = static_cast<size_t>(mEnd - mData); // will trigger eof
  446|  15.8k|        mPos = mData + pos;
  447|  15.8k|    }
_ZNK4Ogre16MemoryDataStream3eofEv:
  456|  31.7k|    {
  457|  31.7k|        return mPos >= mEnd;
  458|  31.7k|    }
_ZN4Ogre16MemoryDataStream5closeEv:
  461|  15.8k|    {
  462|  15.8k|        mAccess = 0;
  463|  15.8k|        if (mFreeOnClose && mData)
  ------------------
  |  Branch (463:13): [True: 0, False: 15.8k]
  |  Branch (463:29): [True: 0, False: 0]
  ------------------
  464|      0|        {
  465|       |            OGRE_FREE(mData, MEMCATEGORY_GENERAL);
  466|      0|            mData = 0;
  467|      0|        }
  468|  15.8k|    }

_ZN4Ogre16DefaultWorkQueueC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   80|      1|    : DefaultWorkQueueBase(name), mNumThreadsRegisteredWithRS(0)
   81|      1|    {
   82|      1|    }

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

_ZN4Ogre13DynLibManagerC2Ev:
   48|      1|    {
   49|      1|    }

_ZN4Ogre8ETCCodec7startupEv:
   93|      1|    {
   94|      1|        if (!msPKMInstance)
  ------------------
  |  Branch (94:13): [True: 1, False: 0]
  ------------------
   95|      1|        {
   96|      1|            msPKMInstance = OGRE_NEW ETCCodec("pkm");
   97|      1|            Codec::registerCodec(msPKMInstance);
   98|      1|        }
   99|       |
  100|      1|        if (!msKTXInstance)
  ------------------
  |  Branch (100:13): [True: 1, False: 0]
  ------------------
  101|      1|        {
  102|      1|            msKTXInstance = OGRE_NEW ETCCodec("ktx");
  103|      1|            Codec::registerCodec(msKTXInstance);
  104|      1|        }
  105|       |
  106|      1|        LogManager::getSingleton().logMessage(LML_NORMAL,
  107|      1|                                              "ETC codec registering");
  108|      1|    }
_ZN4Ogre8ETCCodecC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  128|      2|        mType(type)
  129|      2|    {
  130|      2|    }
_ZNK4Ogre8ETCCodec7getTypeEv:
  140|      2|    {
  141|      2|        return mType;
  142|      2|    }

_ZNK4Ogre13EntityFactory7getTypeEv:
 2241|      3|    {
 2242|      3|        return MOT_ENTITY;
 2243|      3|    }

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

_ZN4Ogre28ExternalTextureSourceManager12getSingletonEv:
   51|  1.05k|    {  
   52|       |        assert( msSingleton );  return ( *msSingleton );  
   53|  1.05k|    }
_ZN4Ogre28ExternalTextureSourceManagerC2Ev:
   58|      1|    {
   59|      1|        mCurrExternalTextureSource = 0;
   60|      1|    }
_ZN4Ogre28ExternalTextureSourceManager16setCurrentPlugInERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   71|    527|    {
   72|    527|        TextureSystemList::iterator i;
   73|       |            
   74|    527|        for( i = mTextureSystems.begin(); i != mTextureSystems.end(); ++i )
  ------------------
  |  Branch (74:43): [True: 0, False: 527]
  ------------------
   75|      0|        {
   76|      0|            if( i->first == sTexturePlugInType )
  ------------------
  |  Branch (76:17): [True: 0, False: 0]
  ------------------
   77|      0|            {
   78|      0|                mCurrExternalTextureSource = i->second;
   79|      0|                mCurrExternalTextureSource->initialise();   //Now call overridden Init function
   80|      0|                return;
   81|      0|            }
   82|      0|        }
   83|    527|        mCurrExternalTextureSource = 0;
   84|    527|    }

_ZNK4Ogre24FileSystemArchiveFactory7getTypeEv:
  479|      2|    {
  480|      2|        static String name = "FileSystem";
  481|      2|        return name;
  482|      2|    }

_ZN4Ogre14FileSystemUtil14openOutputFileERNSt3__114basic_ofstreamIcNS1_11char_traitsIcEEEERKNS1_12basic_stringIcS4_NS1_9allocatorIcEEEEj:
   84|      1|    {
   85|       |#if OGRE_FILESYSTEM_USE_WIDECHAR
   86|       |        stream.open(toWide(path).c_str(), mode);
   87|       |#else
   88|      1|        stream.open(path.c_str(), mode);
   89|      1|#endif
   90|      1|    }

_ZN4Ogre10GpuProgramC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE:
   98|  3.71k|        : Resource(creator, name, handle, group, isManual, loader), mType(GPT_VERTEX_PROGRAM), mLoadFromFile(true),
   99|  3.71k|          mInstancing(false), mSkeletalAnimation(false), mMorphAnimation(false), mVertexTextureFetch(false),
  100|  3.71k|          mNeedsAdjacencyInfo(false), mCompileError(false), mLoadedManualNamedConstants(false), mPoseAnimation(0)
  101|  3.71k|    {
  102|  3.71k|        createParameterMappingStructures();
  103|  3.71k|    }
_ZN4Ogre10GpuProgram7setTypeENS_14GpuProgramTypeE:
  106|  3.71k|    {
  107|  3.71k|        mType = t;
  108|  3.71k|    }
_ZN4Ogre10GpuProgram13setSyntaxCodeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  111|  3.71k|    {
  112|  3.71k|        mSyntaxCode = syntax;
  113|  3.71k|    }
_ZN4Ogre10GpuProgram13setSourceFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  116|  1.14k|    {
  117|  1.14k|        OgreAssert(!filename.empty(), "invalid filename");
  ------------------
  |  Branch (117:9): [True: 0, False: 1.14k]
  ------------------
  118|       |
  119|  1.14k|        mFilename = filename;
  120|  1.14k|        mSource.clear();
  121|  1.14k|        mLoadFromFile = true;
  122|  1.14k|        mCompileError = false;
  123|  1.14k|    }
_ZN4Ogre10GpuProgram32createParameterMappingStructuresEb:
  261|  3.71k|    {
  262|  3.71k|        createLogicalParameterMappingStructures(recreateIfExists);
  263|  3.71k|        createNamedParameterMappingStructures(recreateIfExists);
  264|  3.71k|    }
_ZN4Ogre10GpuProgram39createLogicalParameterMappingStructuresEb:
  267|  3.71k|    {
  268|  3.71k|        if (recreateIfExists || !mLogicalToPhysical)
  ------------------
  |  Branch (268:13): [True: 3.71k, False: 0]
  |  Branch (268:33): [True: 0, False: 0]
  ------------------
  269|  3.71k|            mLogicalToPhysical = std::make_shared<GpuLogicalBufferStruct>();
  270|  3.71k|    }
_ZN4Ogre10GpuProgram37createNamedParameterMappingStructuresEb:
  273|  3.71k|    {
  274|  3.71k|        if (recreateIfExists || !mConstantDefs)
  ------------------
  |  Branch (274:13): [True: 3.71k, False: 0]
  |  Branch (274:33): [True: 0, False: 0]
  ------------------
  275|  3.71k|            mConstantDefs = std::make_shared<GpuNamedConstants>();
  276|  3.71k|    }
_ZN4Ogre10GpuProgram16createParametersEv:
  310|  54.4k|    {
  311|       |        // Default implementation simply returns standard parameters.
  312|  54.4k|        GpuProgramParametersSharedPtr ret =
  313|  54.4k|            GpuProgramManager::getSingleton().createParameters();
  314|       |
  315|       |
  316|       |        // optionally load manually supplied named constants
  317|  54.4k|        if (!mManualNamedConstantsFile.empty() && !mLoadedManualNamedConstants)
  ------------------
  |  Branch (317:13): [True: 0, False: 54.4k]
  |  Branch (317:51): [True: 0, False: 0]
  ------------------
  318|      0|        {
  319|      0|            try
  320|      0|            {
  321|      0|                GpuNamedConstants namedConstants;
  322|      0|                DataStreamPtr stream =
  323|      0|                    ResourceGroupManager::getSingleton().openResource(
  324|      0|                    mManualNamedConstantsFile, mGroup, this);
  325|      0|                namedConstants.load(stream);
  326|      0|                setManualNamedConstants(namedConstants);
  327|      0|            }
  328|      0|            catch(const Exception& e)
  329|      0|            {
  330|      0|                LogManager::getSingleton().stream() <<
  331|      0|                    "Unable to load manual named constants for GpuProgram " << mName <<
  332|      0|                    ": " << e.getDescription();
  333|      0|            }
  334|      0|            mLoadedManualNamedConstants = true;
  335|      0|        }
  336|       |
  337|       |
  338|       |        // set up named parameters, if any
  339|  54.4k|        if (mConstantDefs && !mConstantDefs->map.empty())
  ------------------
  |  Branch (339:13): [True: 54.4k, False: 0]
  |  Branch (339:30): [True: 0, False: 54.4k]
  ------------------
  340|      0|        {
  341|      0|            ret->_setNamedConstants(mConstantDefs);
  342|      0|        }
  343|       |        // link shared logical / physical map for low-level use
  344|  54.4k|        ret->_setLogicalIndexes(mLogicalToPhysical);
  345|       |
  346|       |        // Copy in default parameters if present
  347|  54.4k|        if (mDefaultParams)
  ------------------
  |  Branch (347:13): [True: 0, False: 54.4k]
  ------------------
  348|      0|            ret->copyConstantsFrom(*(mDefaultParams.get()));
  349|       |
  350|  54.4k|        return ret;
  351|  54.4k|    }
_ZN4Ogre10GpuProgram18getProgramTypeNameENS_14GpuProgramTypeE:
  363|     19|    {
  364|     19|        switch (programType)
  365|     19|        {
  366|      1|        case GPT_VERTEX_PROGRAM:
  ------------------
  |  Branch (366:9): [True: 1, False: 18]
  ------------------
  367|      1|            return "vertex";
  368|      3|        case GPT_GEOMETRY_PROGRAM:
  ------------------
  |  Branch (368:9): [True: 3, False: 16]
  ------------------
  369|      3|            return "geometry";
  370|      5|        case GPT_FRAGMENT_PROGRAM:
  ------------------
  |  Branch (370:9): [True: 5, False: 14]
  ------------------
  371|      5|            return "fragment";
  372|      2|        case GPT_DOMAIN_PROGRAM:
  ------------------
  |  Branch (372:9): [True: 2, False: 17]
  ------------------
  373|      2|            return "domain";
  374|      3|        case GPT_HULL_PROGRAM:
  ------------------
  |  Branch (374:9): [True: 3, False: 16]
  ------------------
  375|      3|            return "hull";
  376|      4|        case GPT_COMPUTE_PROGRAM:
  ------------------
  |  Branch (376:9): [True: 4, False: 15]
  ------------------
  377|      4|            return "compute";
  378|      1|        case GPT_MESH_PROGRAM:
  ------------------
  |  Branch (378:9): [True: 1, False: 18]
  ------------------
  379|      1|            return "mesh";
  380|      0|        case GPT_TASK_PROGRAM:
  ------------------
  |  Branch (380:9): [True: 0, False: 19]
  ------------------
  381|      0|            return "task";
  382|      0|        default:
  ------------------
  |  Branch (382:9): [True: 0, False: 19]
  ------------------
  383|       |            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
  384|     19|                "Unexpected GPU program type",
  385|     19|                "GpuProgram::GetName");
  386|     19|        }
  387|     19|    }
_ZN4Ogre10GpuProgram24setupBaseParamDictionaryEv:
  390|      1|    {
  391|      1|        ParamDictionary* dict = getParamDictionary();
  392|       |
  393|      1|        dict->addParameter(
  394|      1|            ParameterDef("type", "'vertex_program', 'geometry_program', 'fragment_program', 'hull_program', 'domain_program', 'compute_program'",
  395|      1|                         PT_STRING), &msTypeCmd);
  396|      1|        dict->addParameter(
  397|      1|            ParameterDef("syntax", "Syntax code, e.g. vs_1_1", PT_STRING), &msSyntaxCmd);
  398|      1|        dict->addParameter("includes_instancing", &msInstancingCmd);
  399|      1|        dict->addParameter(
  400|      1|            ParameterDef("includes_skeletal_animation",
  401|      1|                         "Whether this vertex program includes skeletal animation", PT_BOOL),
  402|      1|            &msSkeletalCmd);
  403|      1|        dict->addParameter(
  404|      1|            ParameterDef("includes_morph_animation",
  405|      1|                         "Whether this vertex program includes morph animation", PT_BOOL),
  406|      1|            &msMorphCmd);
  407|      1|        dict->addParameter(
  408|      1|            ParameterDef("includes_pose_animation",
  409|      1|                         "The number of poses this vertex program supports for pose animation", PT_INT),
  410|      1|            &msPoseCmd);
  411|      1|        dict->addParameter(
  412|      1|            ParameterDef("uses_vertex_texture_fetch",
  413|      1|                         "Whether this vertex program requires vertex texture fetch support.", PT_BOOL),
  414|      1|            &msVTFCmd);
  415|      1|        dict->addParameter(
  416|      1|            ParameterDef("manual_named_constants",
  417|      1|                         "File containing named parameter mappings for low-level programs.", PT_BOOL),
  418|      1|            &msManNamedConstsFileCmd);
  419|      1|    }

_ZN4Ogre17GpuProgramManager12getSingletonEv:
  118|  7.57M|    {  
  119|       |        assert( msSingleton );  return ( *msSingleton );  
  120|  7.57M|    }
_ZNK4Ogre17GpuProgramManager9getByNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
  123|  7.44M|    {
  124|  7.44M|        return static_pointer_cast<GpuProgram>(getResourceByName(name, group));
  125|  7.44M|    }
_ZN4Ogre17GpuProgramManagerC2Ev:
  128|      1|    {
  129|       |        // Loading order
  130|      1|        mLoadOrder = 50.0f;
  131|       |        // Resource type
  132|      1|        mResourceType = "GpuProgram";
  133|      1|        mSaveMicrocodesToCache = false;
  134|      1|        mCacheDirty = false;
  135|       |
  136|      1|        mNullFactory = std::make_unique<NullProgramFactory>();
  137|      1|        addFactory(mNullFactory.get());
  138|      1|        mUnifiedFactory = std::make_unique<UnifiedHighLevelGpuProgramFactory>();
  139|      1|        addFactory(mUnifiedFactory.get());
  140|       |
  141|      1|        ResourceGroupManager::getSingleton()._registerResourceManager(mResourceType, this);
  142|      1|    }
_ZN4Ogre17GpuProgramManager6createERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_NS_14GpuProgramTypeES9_bPNS_20ManualResourceLoaderE:
  188|  3.71k|    {
  189|  3.71k|        auto prg = getFactory(syntaxCode)->create(this, name, getNextHandle(), group, isManual, loader);
  190|  3.71k|        prg->setType(gptype);
  191|  3.71k|        prg->setSyntaxCode(syntaxCode);
  192|       |
  193|  3.71k|        ResourcePtr ret(prg);
  194|  3.71k|        addImpl(ret);
  195|       |        // Tell resource group manager
  196|  3.71k|        if(ret)
  ------------------
  |  Branch (196:12): [True: 3.51k, False: 205]
  ------------------
  197|  3.51k|            ResourceGroupManager::getSingleton()._notifyResourceCreated(ret);
  198|  3.71k|        return static_pointer_cast<GpuProgram>(ret);
  199|  3.71k|    }
_ZN4Ogre17GpuProgramManager22createSharedParametersERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  239|  1.16k|    {
  240|  1.16k|        if (mSharedParametersMap.find(name) != mSharedParametersMap.end())
  ------------------
  |  Branch (240:13): [True: 118, False: 1.04k]
  ------------------
  241|    118|        {
  242|    118|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 
  243|    118|                "The shared parameter set '" + name + "' already exists!", 
  244|    118|                "GpuProgramManager::createSharedParameters");
  245|    118|        }
  246|  1.04k|        GpuSharedParametersPtr ret(OGRE_NEW GpuSharedParameters(name));
  247|  1.04k|        mSharedParametersMap[name] = ret;
  248|  1.04k|        return ret;
  249|  1.16k|    }
_ZN4Ogre17GpuProgramManager10addFactoryEPNS_17GpuProgramFactoryE:
  430|      2|    {
  431|       |        // deliberately allow later plugins to override earlier ones
  432|      2|        mFactories[factory->getLanguage()] = factory;
  433|      2|    }
_ZN4Ogre17GpuProgramManager10getFactoryERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  447|  3.71k|    {
  448|  3.71k|        FactoryMap::iterator i = mFactories.find(language);
  449|       |
  450|  3.71k|        if (i == mFactories.end())
  ------------------
  |  Branch (450:13): [True: 3.08k, False: 627]
  ------------------
  451|  3.08k|        {
  452|       |            // use the null factory to create programs that will never be supported
  453|  3.08k|            i = mFactories.find(sNullLang);
  454|  3.08k|        }
  455|  3.71k|        return i->second;
  456|  3.71k|    }
_ZNK4Ogre17GpuProgramManager19isLanguageSupportedERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  459|  76.9k|    {
  460|  76.9k|        return mFactories.find(lang) != mFactories.end();
  461|  76.9k|    }
OgreGpuProgramManager.cpp:_ZN4Ogre12_GLOBAL__N_118NullProgramFactoryC2Ev:
   73|      1|        NullProgramFactory() {}
OgreGpuProgramManager.cpp:_ZNK4Ogre12_GLOBAL__N_118NullProgramFactory11getLanguageEv:
   77|      1|        {
   78|      1|            return sNullLang;
   79|      1|        }
OgreGpuProgramManager.cpp:_ZN4Ogre12_GLOBAL__N_118NullProgramFactory6createEPNS_15ResourceManagerERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmSC_bPNS_20ManualResourceLoaderE:
   83|  3.09k|        {
   84|       |            return OGRE_NEW NullProgram(creator, name, handle, group, isManual, loader);
   85|  3.09k|        }
OgreGpuProgramManager.cpp:_ZN4Ogre12_GLOBAL__N_111NullProgramC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmSC_bPNS_20ManualResourceLoaderE:
   53|  3.09k|            : GpuProgram(creator, name, handle, group, isManual, loader){}
OgreGpuProgramManager.cpp:_ZNK4Ogre12_GLOBAL__N_111NullProgram11isSupportedEv:
   56|  52.0k|        bool isSupported(void) const override { return false; }
OgreGpuProgramManager.cpp:_ZNK4Ogre12_GLOBAL__N_111NullProgram11getLanguageEv:
   58|  1.70k|        const String& getLanguage(void) const override { return sNullLang; }

_ZN4Ogre17GpuNamedConstantsC2Ev:
  201|  4.76k|    GpuNamedConstants::GpuNamedConstants() : bufferSize(0), registerCount(0) {}
_ZN4Ogre17GpuNamedConstantsD2Ev:
  202|  3.71k|    GpuNamedConstants::~GpuNamedConstants() {}
_ZN4Ogre22GpuLogicalBufferStructC2Ev:
  204|  3.71k|    GpuLogicalBufferStruct::GpuLogicalBufferStruct() : bufferSize(0) {}
_ZN4Ogre22GpuLogicalBufferStructD2Ev:
  205|  3.71k|    GpuLogicalBufferStruct::~GpuLogicalBufferStruct() {}
_ZN4Ogre19GpuSharedParametersC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  329|  1.04k|        : mName(name), mVersion(0), mOffset(0), mDirty(false), mUseLinearColours(false)
  330|  1.04k|    {
  331|  1.04k|    }
_ZN4Ogre19GpuSharedParameters21addConstantDefinitionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_15GpuConstantTypeEj:
  344|  6.65k|    {
  345|  6.65k|        if (mNamedConstants.map.find(name) != mNamedConstants.map.end())
  ------------------
  |  Branch (345:13): [True: 5.15k, False: 1.49k]
  ------------------
  346|  5.15k|        {
  347|  5.15k|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
  348|  5.15k|                        "Constant entry with name '" + name + "' already exists. ",
  349|  5.15k|                        "GpuSharedParameters::addConstantDefinition");
  350|  5.15k|        }
  351|  1.49k|        GpuConstantDefinition def;
  352|  1.49k|        def.arraySize = arraySize;
  353|  1.49k|        def.constType = constType;
  354|       |
  355|       |		// here, we do not consider padding, but rather alignment
  356|  1.49k|        def.elementSize = GpuConstantDefinition::getElementSize(constType, false);
  357|       |
  358|       |		// we try to adhere to GLSL std140 packing rules
  359|       |		// handle alignment requirements
  360|  1.49k|        size_t align_size = std::min<size_t>(def.elementSize == 3 ? 4 : def.elementSize, 4); // vec3 is 16 byte aligned, which is max
  ------------------
  |  Branch (360:46): [True: 205, False: 1.29k]
  ------------------
  361|  1.49k|        align_size *= 4; // bytes
  362|       |
  363|  1.49k|        size_t nextAlignedOffset = ((mOffset + align_size - 1) / align_size) * align_size;
  364|       |
  365|       |        // abuse logical index to store offset
  366|  1.49k|        if (mOffset + align_size > nextAlignedOffset)
  ------------------
  |  Branch (366:13): [True: 1.49k, False: 0]
  ------------------
  367|  1.49k|        {
  368|  1.49k|            def.logicalIndex = nextAlignedOffset;
  369|  1.49k|        }
  370|      0|        else
  371|      0|        {
  372|      0|            def.logicalIndex = mOffset;
  373|      0|        }
  374|       |
  375|  1.49k|        mOffset = def.logicalIndex + (def.constType == GCT_MATRIX_4X3 ? 16 : def.elementSize) * 4; // mat4x3 have a size of 64 bytes
  ------------------
  |  Branch (375:39): [True: 20, False: 1.47k]
  ------------------
  376|       |
  377|  1.49k|        def.variability = (uint16)GPV_GLOBAL;
  378|       |
  379|  1.49k|        if (def.isFloat())
  ------------------
  |  Branch (379:13): [True: 446, False: 1.05k]
  ------------------
  380|    446|        {
  381|    446|            def.physicalIndex = mConstants.size();
  382|    446|            mConstants.resize(mConstants.size() + def.arraySize * def.elementSize*4);
  383|    446|        }
  384|  1.05k|        else if (def.isDouble())
  ------------------
  |  Branch (384:18): [True: 30, False: 1.02k]
  ------------------
  385|     30|        {
  386|     30|            def.physicalIndex = mConstants.size();
  387|     30|            mConstants.resize(mConstants.size() + def.arraySize * def.elementSize*8);
  388|     30|        }
  389|  1.02k|        else if (def.isInt() || def.isUnsignedInt() || def.isBool())
  ------------------
  |  Branch (389:18): [True: 916, False: 107]
  |  Branch (389:33): [True: 107, False: 0]
  |  Branch (389:56): [True: 0, False: 0]
  ------------------
  390|  1.02k|        {
  391|  1.02k|            def.physicalIndex = mConstants.size();
  392|  1.02k|            mConstants.resize(mConstants.size() + def.arraySize * def.elementSize*4);
  393|  1.02k|        }
  394|      0|        else 
  395|      0|        {
  396|       |            //FIXME Is this the right exception type?
  397|      0|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
  398|      0|                        "Constant entry with name '" + name + "' is not a known type.",
  399|      0|                        "GpuSharedParameters::addConstantDefinition");
  400|      0|        }
  401|       |
  402|  1.49k|        mNamedConstants.map[name] = def;
  403|       |
  404|  1.49k|        ++mVersion;
  405|  1.49k|    }
_ZN4Ogre19GpuSharedParameters15setAutoConstantERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_20GpuProgramParameters16AutoConstantTypeE:
  407|     81|    {
  408|     81|        auto& def = mNamedConstants.map[name];
  409|     81|        mAutoConstants.push_back({def.physicalIndex, acType, def.arraySize, def.elementSize});
  410|       |        // no version increment, as this is not a change to the buffer layout
  411|     81|    }
_ZN4Ogre19GpuSharedParameters16setNamedConstantERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKfj:
  606|    156|    {
  607|    156|        _setNamedConstant(name, val, count);
  608|    156|    }
_ZN4Ogre19GpuSharedParameters16setNamedConstantERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKdj:
  611|     26|    {
  612|     26|        _setNamedConstant(name, val, count);
  613|     26|    }
_ZN4Ogre19GpuSharedParameters16setNamedConstantERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKij:
  616|    663|    {
  617|    663|        _setNamedConstant(name, val, count);
  618|    663|    }
_ZN4Ogre19GpuSharedParameters16setNamedConstantERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKjj:
  621|     34|    {
  622|     34|        _setNamedConstant(name, val, count);
  623|     34|    }
_ZN4Ogre19GpuSharedParameters10_markDirtyEv:
  631|    879|    {
  632|    879|        mDirty = true;
  633|    879|    }
_ZN4Ogre20GpuProgramParametersC2Ev:
  740|  54.8k|        mCombinedVariability(GPV_GLOBAL)
  741|  54.8k|        , mTransposeMatrices(false)
  742|  54.8k|        , mIgnoreMissingParams(false)
  743|  54.8k|        , mActivePassIterationIndex(std::numeric_limits<size_t>::max())
  744|  54.8k|        , mUseLinearColours(false)
  745|  54.8k|    {
  746|  54.8k|        static_assert((sizeof(AutoConstantDictionary) / sizeof(AutoConstantDefinition) - 5) == ACT_FROXEL_RECORDS,
  747|  54.8k|                      "AutoConstantDictionary out of sync");
  748|  54.8k|    }
_ZN4Ogre20GpuProgramParametersD2Ev:
  749|  1.23M|    GpuProgramParameters::~GpuProgramParameters() {}
_ZN4Ogre20GpuProgramParametersC2ERKS0_:
  754|  1.18M|    {
  755|  1.18M|        *this = oth;
  756|  1.18M|    }
_ZN4Ogre20GpuProgramParametersaSERKS0_:
  760|  1.18M|    {
  761|       |        // let compiler perform shallow copies of structures
  762|       |        // AutoConstantEntry, RealConstantEntry, IntConstantEntry
  763|  1.18M|        mConstants = oth.mConstants;
  764|  1.18M|        mRegisters = oth.mRegisters;
  765|  1.18M|        mAutoConstants = oth.mAutoConstants;
  766|  1.18M|        mLogicalToPhysical = oth.mLogicalToPhysical;
  767|  1.18M|        mNamedConstants = oth.mNamedConstants;
  768|  1.18M|        copySharedParamSetUsage(oth.mSharedParamSets);
  769|       |
  770|  1.18M|        mCombinedVariability = oth.mCombinedVariability;
  771|  1.18M|        mTransposeMatrices = oth.mTransposeMatrices;
  772|  1.18M|        mIgnoreMissingParams  = oth.mIgnoreMissingParams;
  773|  1.18M|        mActivePassIterationIndex = oth.mActivePassIterationIndex;
  774|  1.18M|        mUseLinearColours = oth.mUseLinearColours;
  775|       |
  776|  1.18M|        return *this;
  777|  1.18M|    }
_ZN4Ogre20GpuProgramParameters23copySharedParamSetUsageERKNSt3__16vectorINS_24GpuSharedParametersUsageENS1_9allocatorIS3_EEEE:
  780|  1.18M|    {
  781|  1.18M|        mSharedParamSets.clear();
  782|  1.18M|        for (const auto& i : srcList)
  ------------------
  |  Branch (782:28): [True: 0, False: 1.18M]
  ------------------
  783|      0|        {
  784|      0|            mSharedParamSets.push_back(GpuSharedParametersUsage(i.getSharedParams(), this));
  785|      0|        }
  786|       |
  787|  1.18M|    }
_ZN4Ogre20GpuProgramParameters18_setLogicalIndexesERKNS_9SharedPtrINS_22GpuLogicalBufferStructEEE:
  822|  54.4k|    {
  823|  54.4k|        mLogicalToPhysical = indexMap;
  824|       |
  825|       |        // resize the internal buffers
  826|       |        // Note that these will only contain something after the first parameter
  827|       |        // set has set some parameters
  828|       |
  829|       |        // Size and reset buffer (fill with zero to make comparison later ok)
  830|  54.4k|        if (indexMap && indexMap->bufferSize*4 > mConstants.size())
  ------------------
  |  Branch (830:13): [True: 54.4k, False: 0]
  |  Branch (830:25): [True: 0, False: 54.4k]
  ------------------
  831|      0|        {
  832|      0|            mConstants.insert(mConstants.end(), indexMap->bufferSize * 4 - mConstants.size(), 0);
  833|      0|        }
  834|  54.4k|    }
_ZN4Ogre20GpuProgramParameters30copyMatchingNamedConstantsFromERKS0_:
 2462|  9.78k|    {
 2463|  9.78k|        if (mNamedConstants && source.mNamedConstants)
  ------------------
  |  Branch (2463:13): [True: 0, False: 9.78k]
  |  Branch (2463:32): [True: 0, False: 0]
  ------------------
 2464|      0|        {
 2465|      0|            std::map<size_t, String> srcToDestNamedMap;
 2466|      0|            for (auto& m : source.mNamedConstants->map)
  ------------------
  |  Branch (2466:26): [True: 0, False: 0]
  ------------------
 2467|      0|            {
 2468|      0|                const String& paramName = m.first;
 2469|      0|                const GpuConstantDefinition& olddef = m.second;
 2470|      0|                const GpuConstantDefinition* newdef = _findNamedConstantDefinition(paramName, false);
 2471|      0|                if (newdef)
  ------------------
  |  Branch (2471:21): [True: 0, False: 0]
  ------------------
 2472|      0|                {
 2473|       |                    // Copy data across, based on smallest common definition size
 2474|      0|                    size_t srcsz = olddef.elementSize * olddef.arraySize;
 2475|      0|                    size_t destsz = newdef->elementSize * newdef->arraySize;
 2476|      0|                    size_t sz = std::min(srcsz, destsz);
 2477|      0|                    if (newdef->isFloat() || newdef->isInt() || newdef->isUnsignedInt() || newdef->isBool())
  ------------------
  |  Branch (2477:25): [True: 0, False: 0]
  |  Branch (2477:46): [True: 0, False: 0]
  |  Branch (2477:65): [True: 0, False: 0]
  |  Branch (2477:92): [True: 0, False: 0]
  ------------------
 2478|      0|                    {
 2479|      0|                        OgreAssert(mConstants.size() >= (newdef->physicalIndex + sz * 4), "Invalid physical index or size");
  ------------------
  |  Branch (2479:25): [True: 0, False: 0]
  ------------------
 2480|      0|                        memcpy(getFloatPointer(newdef->physicalIndex),
 2481|      0|                               source.getFloatPointer(olddef.physicalIndex),
 2482|      0|                               sz * 4);
 2483|      0|                    }
 2484|      0|                    else if (newdef->isDouble())
  ------------------
  |  Branch (2484:30): [True: 0, False: 0]
  ------------------
 2485|      0|                    {
 2486|       |
 2487|      0|                        memcpy(getDoublePointer(newdef->physicalIndex),
 2488|      0|                               source.getDoublePointer(olddef.physicalIndex),
 2489|      0|                               sz * sizeof(double));
 2490|      0|                    }
 2491|      0|                    else if (newdef->isSampler())
  ------------------
  |  Branch (2491:30): [True: 0, False: 0]
  ------------------
 2492|      0|                    {
 2493|      0|                        *getRegPointer(newdef->physicalIndex) = *source.getRegPointer(olddef.physicalIndex);
 2494|      0|                    }
 2495|      0|                    else
 2496|      0|                    {
 2497|       |                        //TODO exception handling
 2498|      0|                    }
 2499|       |                    // we'll use this map to resolve autos later
 2500|       |                    // ignore the [0] aliases
 2501|      0|                    if (!StringUtil::endsWith(paramName, "[0]") && source.findAutoConstantEntry(paramName))
  ------------------
  |  Branch (2501:25): [True: 0, False: 0]
  |  Branch (2501:25): [True: 0, False: 0]
  |  Branch (2501:68): [True: 0, False: 0]
  ------------------
 2502|      0|                        srcToDestNamedMap[olddef.physicalIndex] = paramName;
 2503|      0|                }
 2504|      0|            }
 2505|       |
 2506|      0|            for (const auto& autoEntry : source.mAutoConstants)
  ------------------
  |  Branch (2506:40): [True: 0, False: 0]
  ------------------
 2507|      0|            {
 2508|       |                // find dest physical index
 2509|      0|                std::map<size_t, String>::iterator mi = srcToDestNamedMap.find(autoEntry.physicalIndex);
 2510|      0|                if (mi != srcToDestNamedMap.end())
  ------------------
  |  Branch (2510:21): [True: 0, False: 0]
  ------------------
 2511|      0|                {
 2512|      0|                    if (getAutoConstantDefinition(autoEntry.paramType)->dataType == ACDT_REAL)
  ------------------
  |  Branch (2512:25): [True: 0, False: 0]
  ------------------
 2513|      0|                    {
 2514|      0|                        setNamedAutoConstantReal(mi->second, autoEntry.paramType, autoEntry.fData);
 2515|      0|                    }
 2516|      0|                    else
 2517|      0|                    {
 2518|      0|                        setNamedAutoConstant(mi->second, autoEntry.paramType, autoEntry.data);
 2519|      0|                    }
 2520|      0|                }
 2521|       |
 2522|      0|            }
 2523|       |
 2524|       |            // Copy shared param sets
 2525|      0|            for (const auto& usage : source.mSharedParamSets)
  ------------------
  |  Branch (2525:36): [True: 0, False: 0]
  ------------------
 2526|      0|            {
 2527|      0|                if (!isUsingSharedParameters(usage.getName()))
  ------------------
  |  Branch (2527:21): [True: 0, False: 0]
  ------------------
 2528|      0|                {
 2529|      0|                    addSharedParameters(usage.getSharedParams());
 2530|      0|                }
 2531|      0|            }
 2532|      0|        }
 2533|  9.78k|    }
_ZN4Ogre20GpuProgramParameters25getAutoConstantDefinitionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 2537|  3.62k|    {
 2538|       |        // find a constant definition that matches name by iterating through the
 2539|       |        // constant definition array
 2540|  3.62k|        bool nameFound = false;
 2541|  3.62k|        size_t i = 0;
 2542|  3.62k|        const size_t numDefs = getNumAutoConstantDefinitions();
 2543|   530k|        while (!nameFound && (i < numDefs))
  ------------------
  |  Branch (2543:16): [True: 530k, False: 151]
  |  Branch (2543:30): [True: 526k, False: 3.47k]
  ------------------
 2544|   526k|        {
 2545|   526k|            if (name == AutoConstantDictionary[i].name)
  ------------------
  |  Branch (2545:17): [True: 151, False: 526k]
  ------------------
 2546|    151|                nameFound = true;
 2547|   526k|            else
 2548|   526k|                ++i;
 2549|   526k|        }
 2550|       |
 2551|  3.62k|        if (nameFound)
  ------------------
  |  Branch (2551:13): [True: 151, False: 3.47k]
  ------------------
 2552|    151|            return &AutoConstantDictionary[i];
 2553|  3.47k|        else
 2554|  3.47k|            return 0;
 2555|  3.62k|    }
_ZN4Ogre20GpuProgramParameters29getNumAutoConstantDefinitionsEv:
 2568|  3.62k|    {
 2569|  3.62k|        return sizeof(AutoConstantDictionary)/sizeof(AutoConstantDefinition);
 2570|  3.62k|    }
_ZN4Ogre19GpuSharedParameters17_setNamedConstantIfEEvRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKT_j:
  596|    156|    {
  597|    156|        GpuConstantDefinitionMap::const_iterator i = mNamedConstants.map.find(name);
  598|    156|        if (i == mNamedConstants.map.end())
  ------------------
  |  Branch (598:13): [True: 0, False: 156]
  ------------------
  599|      0|            return; // ignore
  600|       |
  601|    156|        const GpuConstantDefinition& def = i->second;
  602|    156|        memcpy(&mConstants[def.physicalIndex], val, sizeof(float) * std::min(count, def.elementSize * def.arraySize));
  603|    156|        _markDirty();
  604|    156|    }
_ZN4Ogre19GpuSharedParameters17_setNamedConstantIdEEvRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKT_j:
  596|     26|    {
  597|     26|        GpuConstantDefinitionMap::const_iterator i = mNamedConstants.map.find(name);
  598|     26|        if (i == mNamedConstants.map.end())
  ------------------
  |  Branch (598:13): [True: 0, False: 26]
  ------------------
  599|      0|            return; // ignore
  600|       |
  601|     26|        const GpuConstantDefinition& def = i->second;
  602|     26|        memcpy(&mConstants[def.physicalIndex], val, sizeof(float) * std::min(count, def.elementSize * def.arraySize));
  603|     26|        _markDirty();
  604|     26|    }
_ZN4Ogre19GpuSharedParameters17_setNamedConstantIiEEvRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKT_j:
  596|    663|    {
  597|    663|        GpuConstantDefinitionMap::const_iterator i = mNamedConstants.map.find(name);
  598|    663|        if (i == mNamedConstants.map.end())
  ------------------
  |  Branch (598:13): [True: 0, False: 663]
  ------------------
  599|      0|            return; // ignore
  600|       |
  601|    663|        const GpuConstantDefinition& def = i->second;
  602|    663|        memcpy(&mConstants[def.physicalIndex], val, sizeof(float) * std::min(count, def.elementSize * def.arraySize));
  603|    663|        _markDirty();
  604|    663|    }
_ZN4Ogre19GpuSharedParameters17_setNamedConstantIjEEvRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKT_j:
  596|     34|    {
  597|     34|        GpuConstantDefinitionMap::const_iterator i = mNamedConstants.map.find(name);
  598|     34|        if (i == mNamedConstants.map.end())
  ------------------
  |  Branch (598:13): [True: 0, False: 34]
  ------------------
  599|      0|            return; // ignore
  600|       |
  601|     34|        const GpuConstantDefinition& def = i->second;
  602|     34|        memcpy(&mConstants[def.physicalIndex], val, sizeof(float) * std::min(count, def.elementSize * def.arraySize));
  603|     34|        _markDirty();
  604|     34|    }

_ZN4Ogre15GpuProgramUsageC2ENS_14GpuProgramTypeEPNS_4PassE:
   36|  45.0k|        mParent(parent), mProgram(), mRecreateParams(false),mType(gptype)
   37|  45.0k|    {
   38|  45.0k|    }
_ZN4Ogre15GpuProgramUsageC2ERKS0_PNS_4PassE:
   41|  1.18M|        : mParent(parent)
   42|  1.18M|        , mProgram(oth.mProgram)
   43|       |        // nfz: parameters should be copied not just use a shared ptr to the original
   44|  1.18M|        , mParameters(OGRE_NEW GpuProgramParameters(*oth.mParameters))
   45|  1.18M|        , mRecreateParams(false)
   46|  1.18M|        , mType(oth.mType)
   47|  1.18M|    {
   48|  1.18M|    }
_ZN4Ogre15GpuProgramUsageD2Ev:
   51|  1.22M|    {
   52|  1.22M|        if (mProgram)
  ------------------
  |  Branch (52:13): [True: 1.22M, False: 0]
  ------------------
   53|  1.22M|            mProgram->removeListener(this);
   54|  1.22M|    }
_ZN4Ogre15GpuProgramUsage17_getProgramByNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_NS_14GpuProgramTypeE:
   59|  8.87k|    {
   60|  8.87k|        GpuProgramPtr program =
   61|  8.87k|            GpuProgramManager::getSingleton().getByName(name, group);
   62|       |
   63|       |        //Look again without the group if not found
   64|  8.87k|        if (!program)
  ------------------
  |  Branch (64:13): [True: 19, False: 8.85k]
  ------------------
   65|     19|            program = GpuProgramManager::getSingleton().getByName(
   66|     19|                name, ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME);
   67|       |
   68|  8.87k|        if (!program)
  ------------------
  |  Branch (68:13): [True: 19, False: 8.85k]
  ------------------
   69|     19|        {
   70|     19|            String progType = GpuProgram::getProgramTypeName(type);
   71|     19|            OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
   72|     19|                        "Unable to locate " + progType + " program called " + name);
   73|     19|        }
   74|       |
   75|  8.85k|        return program;
   76|  8.87k|    }
_ZN4Ogre15GpuProgramUsage10setProgramERKNS_9SharedPtrINS_10GpuProgramEEEb:
  100|  54.8k|    {
  101|  54.8k|        if (mProgram)
  ------------------
  |  Branch (101:13): [True: 9.78k, False: 45.0k]
  ------------------
  102|  9.78k|        {
  103|  9.78k|            mProgram->removeListener(this);
  104|  9.78k|            mRecreateParams = true;
  105|  9.78k|        }
  106|       |
  107|  54.8k|        mProgram = prog;
  108|       |
  109|       |        // Reset parameters
  110|  54.8k|        if (resetParams || !mParameters || mRecreateParams)
  ------------------
  |  Branch (110:13): [True: 54.8k, False: 0]
  |  Branch (110:28): [True: 0, False: 0]
  |  Branch (110:44): [True: 0, False: 0]
  ------------------
  111|  54.8k|        {
  112|  54.8k|            recreateParameters();
  113|  54.8k|        }
  114|       |
  115|       |        // Listen in on reload events so we can regenerate params
  116|  54.8k|        mProgram->addListener(this);
  117|  54.8k|    }
_ZN4Ogre15GpuProgramUsage18recreateParametersEv:
  170|  54.8k|    {
  171|       |        // Keep a reference to old ones to copy
  172|  54.8k|        GpuProgramParametersSharedPtr savedParams = mParameters;
  173|       |
  174|       |        // Create new params
  175|  54.8k|        mParameters = mProgram->createParameters();
  176|       |
  177|       |        // Copy old (matching) values across
  178|       |        // Don't use copyConstantsFrom since program may be different
  179|  54.8k|        if (savedParams)
  ------------------
  |  Branch (179:13): [True: 9.78k, False: 45.0k]
  ------------------
  180|  9.78k|            mParameters->copyMatchingNamedConstantsFrom(*savedParams.get());
  181|       |
  182|  54.8k|        mRecreateParams = false;
  183|       |
  184|  54.8k|    }

_ZNK4Ogre12LightFactory7getTypeEv:
  874|      3|    {
  875|      3|        return MOT_LIGHT;
  876|      3|    }

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

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

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

_ZN4Ogre10LogManager15getSingletonPtrEv:
   35|      1|    {
   36|      1|        return msSingleton;
   37|      1|    }
_ZN4Ogre10LogManager12getSingletonEv:
   39|  87.4k|    {  
   40|       |        assert( msSingleton );  return ( *msSingleton );  
   41|  87.4k|    }
_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|  63.6k|    {
  126|  63.6k|        OGRE_LOCK_AUTO_MUTEX;
  127|  63.6k|        if (mDefaultLog)
  ------------------
  |  Branch (127:13): [True: 63.6k, False: 0]
  ------------------
  128|  63.6k|        {
  129|  63.6k|            mDefaultLog->logMessage(message, lml, maskDebug);
  130|  63.6k|        }
  131|  63.6k|    }
_ZN4Ogre10LogManager8logErrorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
  134|  23.8k|    {
  135|  23.8k|        stream(LML_CRITICAL, maskDebug) << "Error: " << message;
  136|  23.8k|    }
_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|  23.8k|    {
  165|  23.8k|            OGRE_LOCK_AUTO_MUTEX;
  166|  23.8k|        OgreAssert(mDefaultLog, "Default log not found");
  ------------------
  |  Branch (166:9): [True: 0, False: 23.8k]
  ------------------
  167|  23.8k|        return mDefaultLog->stream(lml, maskDebug);
  168|  23.8k|    }

_ZNK4Ogre19ManualObjectFactory7getTypeEv:
  723|      3|    {
  724|      3|        return MOT_MANUAL_OBJECT;
  725|      3|    }

_ZN4Ogre8MaterialC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE:
   39|  32.4k|        :Resource(creator, name, handle, group, false, NULL),
   40|  32.4k|         mReceiveShadows(true),
   41|  32.4k|         mTransparencyCastsShadows(false),
   42|  32.4k|         mCompilationRequired(true)
   43|  32.4k|    {
   44|       |        // Override isManual, not applicable for Material (we always want to call loadImpl)
   45|  32.4k|        if(isManual)
  ------------------
  |  Branch (45:12): [True: 0, False: 32.4k]
  ------------------
   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|  32.4k|        mLodStrategy = LodStrategyManager::getSingleton().getDefaultStrategy();
   54|       |
   55|  32.4k|        mLodValues.push_back(0.0f);
   56|       |
   57|  32.4k|        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|  32.4k|        createParamDictionary("Material");
   65|  32.4k|    }
_ZN4Ogre8MaterialD2Ev:
   68|  32.4k|    {
   69|  32.4k|        removeAllTechniques();
   70|       |        // have to call this here reather than in Resource destructor
   71|       |        // since calling virtual methods in base destructors causes crash
   72|  32.4k|        unload(); 
   73|  32.4k|    }
_ZN4Ogre8MaterialaSERKS0_:
   76|  49.6k|    {
   77|  49.6k|        if (this == &rhs)
  ------------------
  |  Branch (77:13): [True: 0, False: 49.6k]
  ------------------
   78|      0|            return *this;
   79|       |
   80|  49.6k|        Resource::operator=(rhs);
   81|  49.6k|        mReceiveShadows = rhs.mReceiveShadows;
   82|  49.6k|        mTransparencyCastsShadows = rhs.mTransparencyCastsShadows;
   83|       |
   84|       |        // Copy Techniques
   85|  49.6k|        this->removeAllTechniques();
   86|  49.6k|        for(auto *t : rhs.mTechniques)
  ------------------
  |  Branch (86:21): [True: 3.45M, False: 49.6k]
  ------------------
   87|  3.45M|        {
   88|  3.45M|            Technique* tech = this->createTechnique();
   89|  3.45M|            *tech = *t;
   90|  3.45M|            if (t->isSupported())
  ------------------
  |  Branch (90:17): [True: 0, False: 3.45M]
  ------------------
   91|      0|            {
   92|      0|                insertSupportedTechnique(tech);
   93|      0|            }
   94|  3.45M|        }
   95|       |
   96|       |        // Also copy LOD information
   97|  49.6k|        mUserLodValues = rhs.mUserLodValues;
   98|  49.6k|        mLodValues = rhs.mLodValues;
   99|  49.6k|        mLodStrategy = rhs.mLodStrategy;
  100|  49.6k|        mCompilationRequired = rhs.mCompilationRequired;
  101|       |
  102|       |        // creating techniques moves us into unloaded state
  103|       |        // insertSupportedTechnique is equivalent to prepare
  104|  49.6k|        if(rhs.isLoaded())
  ------------------
  |  Branch (104:12): [True: 0, False: 49.6k]
  ------------------
  105|      0|            load();
  106|       |
  107|  49.6k|        return *this;
  108|  49.6k|    }
_ZNK4Ogre8Material5cloneERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
  170|  17.2k|    {
  171|  17.2k|        MaterialPtr newMat =
  172|  17.2k|            MaterialManager::getSingleton().create(newName, newGroup.empty() ? mGroup : newGroup);
  ------------------
  |  Branch (172:61): [True: 17.2k, False: 0]
  ------------------
  173|       |
  174|  17.2k|        if(!newMat) // interception by collision handler
  ------------------
  |  Branch (174:12): [True: 0, False: 17.2k]
  ------------------
  175|      0|            return newMat;
  176|       |
  177|       |        // Keep handle (see below, copy overrides everything)
  178|  17.2k|        ResourceHandle newHandle = newMat->getHandle();
  179|       |        // Assign values from this
  180|  17.2k|        *newMat = *this;
  181|       |        // Restore new group if required, will have been overridden by operator
  182|  17.2k|        if (!newGroup.empty())
  ------------------
  |  Branch (182:13): [True: 0, False: 17.2k]
  ------------------
  183|      0|        {
  184|      0|            newMat->mGroup = newGroup;
  185|      0|        }
  186|       |        
  187|       |        // Correct the name & handle, they get copied too
  188|  17.2k|        newMat->mName = newName;
  189|  17.2k|        newMat->mHandle = newHandle;
  190|       |
  191|       |        //if we're cloning from a loaded material, notify the creator or otherwise size won't be right
  192|  17.2k|        if (newMat->getLoadingState() == LOADSTATE_LOADED)
  ------------------
  |  Branch (192:13): [True: 0, False: 17.2k]
  ------------------
  193|      0|        {
  194|       |            // Notify manager
  195|      0|            if (mCreator)
  ------------------
  |  Branch (195:17): [True: 0, False: 0]
  ------------------
  196|      0|                mCreator->_notifyResourceLoaded(newMat.get());
  197|      0|        }
  198|       |
  199|  17.2k|        return newMat;
  200|  17.2k|    }
_ZN4Ogre8Material13applyDefaultsEv:
  217|  32.4k|    {
  218|  32.4k|        MaterialPtr defaults = MaterialManager::getSingleton().getDefaultSettings();
  219|       |
  220|  32.4k|        if (defaults)
  ------------------
  |  Branch (220:13): [True: 32.4k, False: 1]
  ------------------
  221|  32.4k|        {
  222|       |            // save name & handle
  223|  32.4k|            String savedName = mName;
  224|  32.4k|            String savedGroup = mGroup;
  225|  32.4k|            ResourceHandle savedHandle = mHandle;
  226|  32.4k|            *this = *defaults;
  227|       |            // restore name & handle
  228|  32.4k|            mName = savedName;
  229|  32.4k|            mHandle = savedHandle;
  230|  32.4k|            mGroup = savedGroup;
  231|  32.4k|        }
  232|  32.4k|        _notifyNeedsRecompile();
  233|       |
  234|  32.4k|    }
_ZN4Ogre8Material15createTechniqueEv:
  237|  3.49M|    {
  238|       |        Technique *t = OGRE_NEW Technique(this);
  239|  3.49M|        mTechniques.push_back(t);
  240|  3.49M|        _notifyNeedsRecompile();
  241|  3.49M|        return t;
  242|  3.49M|    }
_ZN4Ogre8Material19removeAllTechniquesEv:
  367|  95.8k|    {
  368|  95.8k|        for (auto *t : mTechniques)
  ------------------
  |  Branch (368:22): [True: 3.49M, False: 95.8k]
  ------------------
  369|  3.49M|        {
  370|       |            OGRE_DELETE t;
  371|  3.49M|        }
  372|  95.8k|        mTechniques.clear();
  373|  95.8k|        clearBestTechniqueList();
  374|  95.8k|    }
_ZN4Ogre8Material22clearBestTechniqueListEv:
  437|  95.8k|    {
  438|  95.8k|        mSupportedTechniques.clear();
  439|  95.8k|        mBestTechniquesBySchemeList.clear();
  440|  95.8k|        _notifyNeedsRecompile();
  441|  95.8k|    }
_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|  3.72M|    {
  535|  3.72M|        mCompilationRequired = true;
  536|       |        // Also need to unload to ensure we loaded any new items
  537|  3.72M|        if (isLoaded()) // needed to stop this being called in 'loading' state
  ------------------
  |  Branch (537:13): [True: 0, False: 3.72M]
  ------------------
  538|      0|            unload();
  539|  3.72M|    }
_ZN4Ogre8Material12setLodLevelsERKNSt3__16vectorIfNS1_9allocatorIfEEEE:
  542|  5.41k|    {
  543|       |        // Square the distances for the internal list
  544|       |        // First, clear and add single zero entry
  545|  5.41k|        mLodValues.clear();
  546|  5.41k|        mUserLodValues.clear();
  547|  5.41k|        mUserLodValues.push_back(0);
  548|  5.41k|        if (mLodStrategy)
  ------------------
  |  Branch (548:13): [True: 5.41k, False: 0]
  ------------------
  549|  5.41k|            mLodValues.push_back(mLodStrategy->getBaseValue());
  550|  5.41k|        for (auto& v : lodValues)
  ------------------
  |  Branch (550:22): [True: 49.9k, False: 5.41k]
  ------------------
  551|  49.9k|        {
  552|  49.9k|            mUserLodValues.push_back(v);
  553|  49.9k|            if (mLodStrategy)
  ------------------
  |  Branch (553:17): [True: 49.9k, False: 0]
  ------------------
  554|  49.9k|                mLodValues.push_back(mLodStrategy->transformUserValue(v));
  555|  49.9k|        }
  556|  5.41k|    }
_ZN4Ogre8Material14setLodStrategyEPNS_11LodStrategyE:
  579|  1.94k|    {
  580|  1.94k|        mLodStrategy = lodStrategy;
  581|       |
  582|  1.94k|        assert(mLodValues.size());
  583|  1.94k|        mLodValues[0] = mLodStrategy->getBaseValue();
  584|       |
  585|       |        // Re-transform all user LOD values (starting at index 1, no need to transform base value)
  586|  2.55k|        for (size_t i = 1; i < mUserLodValues.size(); ++i)
  ------------------
  |  Branch (586:28): [True: 608, False: 1.94k]
  ------------------
  587|    608|            mLodValues[i] = mLodStrategy->transformUserValue(mUserLodValues[i]);
  588|  1.94k|    }

_ZN4Ogre15MaterialManager15getSingletonPtrEv:
   40|  6.94M|    {
   41|  6.94M|        return msSingleton;
   42|  6.94M|    }
_ZN4Ogre15MaterialManager12getSingletonEv:
   44|  7.03M|    {
   45|       |        assert( msSingleton );  return ( *msSingleton );
   46|  7.03M|    }
_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|  32.4k|    {
   84|       |        return OGRE_NEW Material(this, name, handle, group, isManual, loader);
   85|  32.4k|    }
_ZN4Ogre15MaterialManager6createERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
   90|  32.4k|    {
   91|  32.4k|        return static_pointer_cast<Material>(createResource(name,group,isManual,loader,createParams));
   92|  32.4k|    }
_ZNK4Ogre15MaterialManager9getByNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
   95|  14.8k|    {
   96|  14.8k|        return static_pointer_cast<Material>(getResourceByName(name, groupName));
   97|  14.8k|    }
_ZN4Ogre15MaterialManager18getDefaultMaterialEb:
   99|     14|    MaterialPtr MaterialManager::getDefaultMaterial(bool useLighting) {
  100|     14|        MaterialPtr ret = getByName(useLighting ? "BaseWhite" : "BaseWhiteNoLighting",
  ------------------
  |  Branch (100:37): [True: 14, False: 0]
  ------------------
  101|     14|                                    ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME);
  102|       |
  103|     14|        OgreAssert(ret,
  ------------------
  |  Branch (103:9): [True: 0, False: 14]
  ------------------
  104|     14|                   "Can't find default material Did you forget to call MaterialManager::initialise()?");
  105|       |
  106|     14|        return ret;
  107|     14|    }
_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|    }
_ZN4Ogre15MaterialManager15_getSchemeIndexERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  161|  7.38k|    {
  162|  7.38k|        unsigned short ret = 0;
  163|  7.38k|        SchemeMap::iterator i = mSchemes.find(schemeName);
  164|  7.38k|        if (i != mSchemes.end())
  ------------------
  |  Branch (164:13): [True: 6.94k, False: 440]
  ------------------
  165|  6.94k|        {
  166|  6.94k|            ret = i->second;
  167|  6.94k|        }
  168|    440|        else
  169|    440|        {
  170|       |            // Create new
  171|    440|            ret = static_cast<unsigned short>(mSchemes.size());
  172|    440|            mSchemes[schemeName] = ret;
  173|    440|        }
  174|  7.38k|        return ret;
  175|       |
  176|  7.38k|    }
_ZN4Ogre15MaterialManager38_notifyBeforeIlluminationPassesClearedEPNS_9TechniqueE:
  273|  6.94M|	{
  274|       |		// First, check the scheme specific listeners
  275|  6.94M|		ListenerMap::iterator it = mListenerMap.find(mActiveSchemeName);
  276|  6.94M|		if(it != mListenerMap.end())
  ------------------
  |  Branch (276:6): [True: 0, False: 6.94M]
  ------------------
  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|  6.94M|		it = mListenerMap.find(BLANKSTRING);
  289|  6.94M|		if(it != mListenerMap.end())
  ------------------
  |  Branch (289:6): [True: 0, False: 6.94M]
  ------------------
  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|  6.94M|	}

_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|    }
_ZNK4Ogre9MeshCodec7getTypeEv:
   39|      1|        String getType() const override { return "mesh"; }

_ZN4Ogre13MovableObjectC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   43|     14|        : mName(name)
   44|     14|        , mCreator(0)
   45|     14|        , mManager(0)
   46|     14|        , mParentNode(0)
   47|     14|        , mListener(0)
   48|     14|        , mParentIsTagPoint(false)
   49|     14|        , mVisible(true)
   50|     14|        , mDebugDisplay(false)
   51|     14|        , mBeyondFarDistance(false)
   52|     14|        , mCastShadows(true)
   53|     14|        , mRenderQueueIDSet(false)
   54|     14|        , mRenderQueuePrioritySet(false)
   55|     14|        , mRenderingDisabled(false)
   56|     14|        , mRenderQueueID(RENDER_QUEUE_MAIN)
   57|     14|        , mRenderQueuePriority(100)
   58|     14|        , mUpperDistance(0)
   59|     14|        , mSquaredUpperDistance(0)
   60|     14|        , mMinPixelSize(0)
   61|     14|        , mQueryFlags(msDefaultQueryFlags)
   62|     14|        , mVisibilityFlags(msDefaultVisibilityFlags)
   63|     14|        , mLightListUpdated(0)
   64|     14|        , mLightMask(0xFFFFFFFF)
   65|     14|    {
   66|     14|        if (Root::getSingletonPtr())
  ------------------
  |  Branch (66:13): [True: 14, False: 0]
  ------------------
   67|     14|            mMinPixelSize = Root::getSingleton().getDefaultMinPixelSize();
   68|     14|    }
_ZN4Ogre13MovableObjectD2Ev:
   71|     14|    {
   72|       |        // Call listener (note, only called if there's something to do)
   73|     14|        if (mListener)
  ------------------
  |  Branch (73:13): [True: 0, False: 14]
  ------------------
   74|      0|        {
   75|      0|            mListener->objectDestroyed(this);
   76|      0|        }
   77|       |
   78|     14|        detachFromParent(); // this should never throw, if it does terminating is the thing to do
   79|     14|    }
_ZN4Ogre13MovableObject16detachFromParentEv:
  118|     14|    {
  119|     14|        if (isAttached())
  ------------------
  |  Branch (119:13): [True: 0, False: 14]
  ------------------
  120|      0|        {
  121|      0|            if (mParentIsTagPoint)
  ------------------
  |  Branch (121:17): [True: 0, False: 0]
  ------------------
  122|      0|            {
  123|      0|                TagPoint* tp = static_cast<TagPoint*>(mParentNode);
  124|      0|                tp->getParentEntity()->detachObjectFromBone(this);
  125|      0|            }
  126|      0|            else
  127|      0|            {
  128|      0|                SceneNode* sn = static_cast<SceneNode*>(mParentNode);
  129|      0|                sn->detachObject(this);
  130|      0|            }
  131|      0|        }
  132|     14|    }

_ZN4Ogre18MurmurHash3_x86_32EPKvmjPv:
   98|  1.20M|{
   99|  1.20M|  const uint8_t * data = (const uint8_t*)key;
  100|  1.20M|  const int nblocks = len / 4;
  101|       |
  102|  1.20M|  uint32_t h1 = seed;
  103|       |
  104|  1.20M|  const uint32_t c1 = 0xcc9e2d51;
  105|  1.20M|  const uint32_t c2 = 0x1b873593;
  106|       |
  107|       |  //----------
  108|       |  // body
  109|       |
  110|  1.20M|  const uint32_t * blocks = (const uint32_t *)(data + nblocks*4);
  111|       |
  112|  4.85M|  for(int i = -nblocks; i; i++)
  ------------------
  |  Branch (112:25): [True: 3.65M, False: 1.20M]
  ------------------
  113|  3.65M|  {
  114|  3.65M|    uint32_t k1 = getblock32(blocks,i);
  115|       |
  116|  3.65M|    k1 *= c1;
  117|  3.65M|    k1 = ROTL32(k1,15);
  ------------------
  |  |   44|  3.65M|#define ROTL32(x,y) rotl32(x,y)
  ------------------
  118|  3.65M|    k1 *= c2;
  119|       |    
  120|  3.65M|    h1 ^= k1;
  121|  3.65M|    h1 = ROTL32(h1,13); 
  ------------------
  |  |   44|  3.65M|#define ROTL32(x,y) rotl32(x,y)
  ------------------
  122|  3.65M|    h1 = h1*5+0xe6546b64;
  123|  3.65M|  }
  124|       |
  125|       |  //----------
  126|       |  // tail
  127|       |
  128|  1.20M|  const uint8_t * tail = (const uint8_t*)(data + nblocks*4);
  129|       |
  130|  1.20M|  uint32_t k1 = 0;
  131|       |
  132|  1.20M|  switch(len & 3)
  ------------------
  |  Branch (132:10): [True: 21.1k, False: 1.18M]
  ------------------
  133|  1.20M|  {
  134|  7.64k|  case 3: k1 ^= tail[2] << 16; OGRE_FALLTHROUGH;
  ------------------
  |  Branch (134:3): [True: 7.64k, False: 1.19M]
  ------------------
  135|  14.5k|  case 2: k1 ^= tail[1] << 8; OGRE_FALLTHROUGH;
  ------------------
  |  Branch (135:3): [True: 6.86k, False: 1.19M]
  ------------------
  136|  21.1k|  case 1: k1 ^= tail[0];
  ------------------
  |  Branch (136:3): [True: 6.60k, False: 1.19M]
  ------------------
  137|  21.1k|          k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1;
  ------------------
  |  |   44|  21.1k|#define ROTL32(x,y) rotl32(x,y)
  ------------------
  138|  1.20M|  };
  139|       |
  140|       |  //----------
  141|       |  // finalization
  142|       |
  143|  1.20M|  h1 ^= len;
  144|       |
  145|  1.20M|  h1 = fmix32(h1);
  146|       |
  147|  1.20M|  *(uint32_t*)out = h1;
  148|  1.20M|} 
_ZN4Ogre10getblock32EPKji:
   58|  3.65M|{
   59|  3.65M|  return p[i];
   60|  3.65M|}
_Z6rotl32ja:
   35|  7.32M|{
   36|  7.32M|  return (x << r) | (x >> (32 - r));
   37|  7.32M|}
_ZN4Ogre6fmix32Ej:
   71|  1.20M|{
   72|  1.20M|  h ^= h >> 16;
   73|  1.20M|  h *= 0x85ebca6b;
   74|  1.20M|  h ^= h >> 13;
   75|  1.20M|  h *= 0xc2b2ae35;
   76|  1.20M|  h ^= h >> 16;
   77|       |
   78|  1.20M|  return h;
   79|  1.20M|}

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

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

_ZN4Ogre10PVRTCCodec7startupEv:
  114|      1|    {
  115|      1|        if (!msInstance)
  ------------------
  |  Branch (115:13): [True: 1, False: 0]
  ------------------
  116|      1|        {
  117|      1|            LogManager::getSingleton().logMessage(
  118|      1|                LML_NORMAL,
  119|      1|                "PVRTC codec registering");
  120|       |
  121|       |            msInstance = OGRE_NEW PVRTCCodec();
  122|      1|            Codec::registerCodec(msInstance);
  123|      1|        }
  124|      1|    }
_ZN4Ogre10PVRTCCodecC2Ev:
  137|      1|        mType("pvr")
  138|      1|    { 
  139|      1|    }
_ZNK4Ogre10PVRTCCodec7getTypeEv:
  289|      1|    {
  290|      1|        return mType;
  291|      1|    }

_ZN4Ogre14ParticleSystemC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
  181|     14|      : MovableObject(name),
  182|     14|        mAABB(),
  183|     14|        mBoundingRadius(1.0f),
  184|     14|        mBoundsAutoUpdate(true),
  185|     14|        mBoundsUpdateTime(10.0f),
  186|     14|        mUpdateRemainTime(0),
  187|     14|        mResourceGroupName(resourceGroup),
  188|     14|        mIsRendererConfigured(false),
  189|     14|        mSpeedFactor(1.0f),
  190|     14|        mIterationInterval(0),
  191|     14|        mIterationIntervalSet(false),
  192|     14|        mSorted(false),
  193|     14|        mLocalSpace(false),
  194|     14|        mNonvisibleTimeout(0),
  195|     14|        mNonvisibleTimeoutSet(false),
  196|     14|        mTimeSinceLastVisible(0),
  197|     14|        mLastVisibleFrame(Root::getSingleton().getNextFrameNumber()),
  198|     14|        mTimeController(0),
  199|     14|        mEmittedEmitterPoolInitialised(false),
  200|     14|        mIsEmitting(true),
  201|     14|        mRenderer(0), 
  202|     14|        mCullIndividual(false),
  203|     14|        mPoolSize(0),
  204|     14|        mEmittedEmitterPoolSize(0)
  205|     14|    {
  206|     14|        setDefaultDimensions( 100, 100 );
  207|     14|        mMaterial = MaterialManager::getSingleton().getDefaultMaterial();
  208|       |        // Default to 10 particles, expect app to specify (will only be increased, not decreased)
  209|     14|        setParticleQuota( 10 );
  210|     14|        setEmittedEmitterQuota( 3 );
  211|     14|        initParameters();
  212|       |
  213|       |        // Default to billboard renderer
  214|     14|        setRenderer("billboard");
  215|     14|        mCastShadows = false;
  216|     14|    }
_ZN4Ogre14ParticleSystem16setParticleQuotaEm:
  384|     14|    {
  385|       |        // Never shrink below size()
  386|     14|        size_t currSize = mParticlePool.size();
  387|       |
  388|     14|        if( currSize < size )
  ------------------
  |  Branch (388:13): [True: 14, False: 0]
  ------------------
  389|     14|        {
  390|       |            // Will allocate particles on demand
  391|     14|            mPoolSize = size;
  392|       |            
  393|     14|        }
  394|     14|    }
_ZN4Ogre14ParticleSystem22setEmittedEmitterQuotaEm:
  402|     14|    {
  403|       |        // Never shrink below size()
  404|     14|        size_t currSize = 0;
  405|     14|        for (auto& kv : mEmittedEmitterPool)
  ------------------
  |  Branch (405:23): [True: 0, False: 14]
  ------------------
  406|      0|        {
  407|      0|            currSize += kv.second.size();
  408|      0|        }
  409|       |
  410|     14|        if( currSize < size )
  ------------------
  |  Branch (410:13): [True: 14, False: 0]
  ------------------
  411|     14|        {
  412|       |            // Will allocate emitted emitters on demand
  413|     14|            mEmittedEmitterPoolSize = size;
  414|     14|        }
  415|     14|    }
_ZN4Ogre14ParticleSystem14initParametersEv:
  771|     14|    {
  772|     14|        if (createParamDictionary("ParticleSystem"))
  ------------------
  |  Branch (772:13): [True: 1, False: 13]
  ------------------
  773|      1|        {
  774|      1|            ParamDictionary* dict = getParamDictionary();
  775|       |
  776|      1|            dict->addParameter(ParameterDef("quota", 
  777|      1|                "The maximum number of particles allowed at once in this system.",
  778|      1|                PT_UNSIGNED_INT),
  779|      1|                &msQuotaCmd);
  780|       |
  781|      1|            dict->addParameter(ParameterDef("emit_emitter_quota", 
  782|      1|                "The maximum number of emitters to be emitted at once in this system.",
  783|      1|                PT_UNSIGNED_INT),
  784|      1|                &msEmittedEmitterQuotaCmd);
  785|       |
  786|      1|            dict->addParameter(ParameterDef("material", 
  787|      1|                "The name of the material to be used to render all particles in this system.",
  788|      1|                PT_STRING),
  789|      1|                &msMaterialCmd);
  790|       |
  791|      1|            dict->addParameter(ParameterDef("particle_width", 
  792|      1|                "The width of particles in world units.",
  793|      1|                PT_REAL),
  794|      1|                &msWidthCmd);
  795|       |
  796|      1|            dict->addParameter(ParameterDef("particle_height", 
  797|      1|                "The height of particles in world units.",
  798|      1|                PT_REAL),
  799|      1|                &msHeightCmd);
  800|       |
  801|      1|            dict->addParameter(ParameterDef("cull_each", 
  802|      1|                "If true, each particle is culled in it's own right. If false, the entire system is culled as a whole.",
  803|      1|                PT_BOOL),
  804|      1|                &msCullCmd);
  805|       |
  806|      1|            dict->addParameter(ParameterDef("renderer", 
  807|      1|                "Sets the particle system renderer to use (default 'billboard').",
  808|      1|                PT_STRING),
  809|      1|                &msRendererCmd);
  810|       |
  811|      1|            dict->addParameter(ParameterDef("sorted", 
  812|      1|                "Sets whether particles should be sorted relative to the camera. ",
  813|      1|                PT_BOOL),
  814|      1|                &msSortedCmd);
  815|       |
  816|      1|            dict->addParameter(ParameterDef("local_space", 
  817|      1|                "Sets whether particles should be kept in local space rather than "
  818|      1|                "emitted into world space. ",
  819|      1|                PT_BOOL),
  820|      1|                &msLocalSpaceCmd);
  821|       |
  822|      1|            dict->addParameter(ParameterDef("iteration_interval", 
  823|      1|                "Sets a fixed update interval for the system, or 0 for the frame rate. ",
  824|      1|                PT_REAL),
  825|      1|                &msIterationIntervalCmd);
  826|       |
  827|      1|            dict->addParameter(ParameterDef("nonvisible_update_timeout", 
  828|      1|                "Sets a timeout on updates to the system if the system is not visible "
  829|      1|                "for the given number of seconds (0 to always update)",
  830|      1|                PT_REAL),
  831|      1|                &msNonvisibleTimeoutCmd);
  832|       |
  833|      1|        }
  834|     14|    }
_ZN4Ogre14ParticleSystem20setDefaultDimensionsEff:
  932|     14|    {
  933|     14|        assert(width >= 0 && height >= 0 && "Particle dimensions can not be negative");
  934|     14|        mDefaultWidth = width;
  935|     14|        mDefaultHeight = height;
  936|     14|        if (mRenderer)
  ------------------
  |  Branch (936:13): [True: 0, False: 14]
  ------------------
  937|      0|        {
  938|      0|            mRenderer->_notifyDefaultDimensions(width, height);
  939|      0|        }
  940|     14|    }
_ZN4Ogre14ParticleSystem11setRendererERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1068|     14|    {
 1069|     14|        if (mRenderer)
  ------------------
  |  Branch (1069:13): [True: 0, False: 14]
  ------------------
 1070|      0|        {
 1071|       |            // Destroy existing
 1072|      0|            ParticleSystemManager::getSingleton()._destroyRenderer(mRenderer);
 1073|      0|            mRenderer = 0;
 1074|      0|        }
 1075|       |
 1076|     14|        if (!rendererName.empty())
  ------------------
  |  Branch (1076:13): [True: 14, False: 0]
  ------------------
 1077|     14|        {
 1078|     14|            mRenderer = ParticleSystemManager::getSingleton()._createRenderer(rendererName);
 1079|     14|            mIsRendererConfigured = false;
 1080|     14|        }
 1081|     14|    }

_ZN4Ogre21ParticleSystemManager12getSingletonEv:
   47|  15.9k|    {  
   48|       |        assert( msSingleton );  return ( *msSingleton );  
   49|  15.9k|    }
_ZN4Ogre21ParticleSystemManagerC2Ev:
   52|      1|    {
   53|      1|        OGRE_LOCK_AUTO_MUTEX;
   54|       |        mFactory = OGRE_NEW ParticleSystemFactory();
   55|      1|        Root::getSingleton().addMovableObjectFactory(mFactory);
   56|      1|    }
_ZN4Ogre21ParticleSystemManager18removeAllTemplatesEb:
  133|  15.8k|    {
  134|  15.8k|        OGRE_LOCK_AUTO_MUTEX;
  135|  15.8k|        if (deleteTemplate)
  ------------------
  |  Branch (135:13): [True: 15.8k, False: 0]
  ------------------
  136|  15.8k|        {
  137|  15.8k|            ParticleTemplateMap::iterator itr;
  138|  15.8k|            for (itr = mSystemTemplates.begin(); itr != mSystemTemplates.end(); ++itr)
  ------------------
  |  Branch (138:50): [True: 0, False: 15.8k]
  ------------------
  139|  15.8k|                OGRE_DELETE itr->second;
  140|  15.8k|        }
  141|       |
  142|  15.8k|        mSystemTemplates.clear();
  143|  15.8k|    }
_ZN4Ogre21ParticleSystemManager14createTemplateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
  164|     14|    {
  165|     14|        OGRE_LOCK_AUTO_MUTEX;
  166|       |        // check name
  167|     14|        if (mSystemTemplates.find(name) != mSystemTemplates.end())
  ------------------
  |  Branch (167:13): [True: 0, False: 14]
  ------------------
  168|      0|        {
  169|       |#if OGRE_PLATFORM == OGRE_PLATFORM_WINRT
  170|       |            LogManager::getSingleton().logMessage("ParticleSystem template with name '" + name + "' already exists.");
  171|       |            return NULL;
  172|       |#else
  173|      0|            OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, 
  174|      0|                "ParticleSystem template with name '" + name + "' already exists.", 
  175|      0|                "ParticleSystemManager::createTemplate");
  176|      0|#endif
  177|      0|        }
  178|       |
  179|     14|        ParticleSystem* tpl = OGRE_NEW ParticleSystem(name, resourceGroup);
  180|     14|        addTemplate(name, tpl);
  181|     14|        return tpl;
  182|       |
  183|     14|    }
_ZN4Ogre21ParticleSystemManager15_createRendererERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  293|     14|    {
  294|     14|        OGRE_LOCK_AUTO_MUTEX;
  295|       |        // Locate affector type
  296|     14|        ParticleSystemRendererFactoryMap::iterator pFact = mRendererFactories.find(rendererType);
  297|       |
  298|     14|        if (pFact == mRendererFactories.end())
  ------------------
  |  Branch (298:13): [True: 14, False: 0]
  ------------------
  299|     14|        {
  300|     14|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Cannot find requested renderer type.", 
  301|     14|                "ParticleSystemManager::_createRenderer");
  302|     14|        }
  303|       |
  304|      0|        return pFact->second->createInstance(rendererType);
  305|     14|    }
_ZNK4Ogre21ParticleSystemFactory7getTypeEv:
  397|      3|    {
  398|      3|        return MOT_PARTICLE_SYSTEM;
  399|      3|    }

_ZN4Ogre4Pass22getBuiltinHashFunctionENS0_19BuiltinHashFunctionE:
   92|  3.33M|    {
   93|  3.33M|        Pass::HashFunc* hashFunc = NULL;
   94|       |
   95|  3.33M|        switch(builtin)
  ------------------
  |  Branch (95:16): [True: 3.33M, False: 0]
  ------------------
   96|  3.33M|        {
   97|  3.28M|        case MIN_TEXTURE_CHANGE:
  ------------------
  |  Branch (97:9): [True: 3.28M, False: 54.8k]
  ------------------
   98|  3.28M|            hashFunc = &sMinTextureStateChangeHashFunc;
   99|  3.28M|            break;
  100|  54.8k|        case MIN_GPU_PROGRAM_CHANGE:
  ------------------
  |  Branch (100:9): [True: 54.8k, False: 3.28M]
  ------------------
  101|  54.8k|            hashFunc = &sMinGpuProgramChangeHashFunc;
  102|  54.8k|            break;
  103|  3.33M|        }
  104|       |
  105|  3.33M|        return hashFunc;
  106|  3.33M|    }
_ZN4Ogre4PassC2EPNS_9TechniqueEt:
  122|  69.5k|        : mParent(parent)
  123|  69.5k|        , mHash(0)
  124|  69.5k|        , mAmbient(ColourValue::White)
  125|  69.5k|        , mDiffuse(ColourValue::White)
  126|  69.5k|        , mSpecular(ColourValue::Black)
  127|  69.5k|        , mEmissive(ColourValue::Black)
  128|  69.5k|        , mShininess(0)
  129|  69.5k|        , mTracking(TVC_NONE)
  130|  69.5k|        , mHashDirtyQueued(false)
  131|  69.5k|        , mDepthCheck(true)
  132|  69.5k|        , mDepthWrite(true)
  133|  69.5k|        , mAlphaToCoverageEnabled(false)
  134|  69.5k|        , mTransparentSorting(true)
  135|  69.5k|        , mTransparentSortingForced(false)
  136|  69.5k|        , mLightingEnabled(true)
  137|  69.5k|        , mIteratePerLight(false)
  138|  69.5k|        , mRunOnlyForOneLightType(false)
  139|  69.5k|        , mPolygonModeOverrideable(true)
  140|  69.5k|        , mFogOverride(false)
  141|  69.5k|        , mQueuedForDeletion(false)
  142|  69.5k|        , mLightScissoring(false)
  143|  69.5k|        , mLightClipPlanes(false)
  144|  69.5k|        , mPointSpritesEnabled(false)
  145|  69.5k|        , mPointAttenuationEnabled(false)
  146|  69.5k|        , mContentTypeLookupBuilt(false)
  147|  69.5k|        , mAlphaRejectVal(0)
  148|  69.5k|        , mDepthBiasConstant(0.0f)
  149|  69.5k|        , mDepthBiasSlopeScale(0.0f)
  150|  69.5k|        , mDepthBiasPerIteration(0.0f)
  151|  69.5k|        , mDepthFunc(CMPF_LESS_EQUAL)
  152|  69.5k|        , mAlphaRejectFunc(CMPF_ALWAYS_PASS)
  153|  69.5k|        , mCullMode(CULL_CLOCKWISE)
  154|  69.5k|        , mManualCullMode(MANUAL_CULL_BACK)
  155|  69.5k|        , mMaxSimultaneousLights(OGRE_MAX_SIMULTANEOUS_LIGHTS)
  156|  69.5k|        , mStartLight(0)
  157|  69.5k|        , mLightsPerIteration(1)
  158|  69.5k|        , mIndex(index)
  159|  69.5k|        , mLightMask(0xFFFFFFFF)
  160|  69.5k|        , mFogColour(ColourValue::White)
  161|  69.5k|        , mFogStart(0.0)
  162|  69.5k|        , mFogEnd(1.0)
  163|  69.5k|        , mFogDensity(0.001)
  164|  69.5k|        , mLineWidth(1.0f)
  165|  69.5k|        , mPassIterationCount(1)
  166|  69.5k|        , mPointMinSize(0.0f)
  167|  69.5k|        , mPointMaxSize(0.0f)
  168|  69.5k|        , mPointAttenution(1.0f, 1.0f, 0.0f, 0.0f)
  169|  69.5k|        , mShadeOptions(SO_GOURAUD)
  170|  69.5k|        , mPolygonMode(PM_SOLID)
  171|  69.5k|        , mIlluminationStage(IS_UNKNOWN)
  172|  69.5k|        , mOnlyLightType(Light::LT_POINT)
  173|  69.5k|        , mFogMode(FOG_NONE)
  174|  69.5k|    {
  175|       |        // init the hash inline
  176|  69.5k|        _recalculateHash();
  177|  69.5k|   }
_ZN4Ogre4PassC2EPNS_9TechniqueEtRKS0_:
  181|  3.47M|        : mParent(parent), mQueuedForDeletion(false), mIndex(index), mPassIterationCount(1)
  182|  3.47M|    {
  183|  3.47M|        *this = oth;
  184|  3.47M|        mParent = parent;
  185|  3.47M|        mIndex = index;
  186|  3.47M|        mQueuedForDeletion = false;
  187|       |
  188|       |        // init the hash inline
  189|  3.47M|        _recalculateHash();
  190|  3.47M|    }
_ZN4Ogre4PassD2Ev:
  191|  3.54M|    Pass::~Pass() = default; // ensure unique_ptr destructors are in cpp
_ZN4Ogre4PassaSERKS0_:
  194|  3.47M|    {
  195|  3.47M|        mName = oth.mName;
  196|  3.47M|        mHash = oth.mHash;
  197|  3.47M|        mAmbient = oth.mAmbient;
  198|  3.47M|        mDiffuse = oth.mDiffuse;
  199|  3.47M|        mSpecular = oth.mSpecular;
  200|  3.47M|        mEmissive = oth.mEmissive;
  201|  3.47M|        mShininess = oth.mShininess;
  202|  3.47M|        mTracking = oth.mTracking;
  203|       |
  204|       |        // Copy fog parameters
  205|  3.47M|        mFogOverride = oth.mFogOverride;
  206|  3.47M|        mFogMode = oth.mFogMode;
  207|  3.47M|        mFogColour = oth.mFogColour;
  208|  3.47M|        mFogStart = oth.mFogStart;
  209|  3.47M|        mFogEnd = oth.mFogEnd;
  210|  3.47M|        mFogDensity = oth.mFogDensity;
  211|       |
  212|       |        // Default blending (overwrite)
  213|  3.47M|        mBlendState = oth.mBlendState;
  214|       |
  215|  3.47M|        mDepthCheck = oth.mDepthCheck;
  216|  3.47M|        mDepthWrite = oth.mDepthWrite;
  217|  3.47M|        mAlphaRejectFunc = oth.mAlphaRejectFunc;
  218|  3.47M|        mAlphaRejectVal = oth.mAlphaRejectVal;
  219|  3.47M|        mAlphaToCoverageEnabled = oth.mAlphaToCoverageEnabled;
  220|  3.47M|        mTransparentSorting = oth.mTransparentSorting;
  221|  3.47M|        mTransparentSortingForced = oth.mTransparentSortingForced;
  222|  3.47M|        mDepthFunc = oth.mDepthFunc;
  223|  3.47M|        mDepthBiasConstant = oth.mDepthBiasConstant;
  224|  3.47M|        mDepthBiasSlopeScale = oth.mDepthBiasSlopeScale;
  225|  3.47M|        mDepthBiasPerIteration = oth.mDepthBiasPerIteration;
  226|  3.47M|        mCullMode = oth.mCullMode;
  227|  3.47M|        mManualCullMode = oth.mManualCullMode;
  228|  3.47M|        mLightingEnabled = oth.mLightingEnabled;
  229|  3.47M|        mMaxSimultaneousLights = oth.mMaxSimultaneousLights;
  230|  3.47M|        mStartLight = oth.mStartLight;
  231|  3.47M|        mIteratePerLight = oth.mIteratePerLight;
  232|  3.47M|        mLightsPerIteration = oth.mLightsPerIteration;
  233|  3.47M|        mRunOnlyForOneLightType = oth.mRunOnlyForOneLightType;
  234|  3.47M|        mOnlyLightType = oth.mOnlyLightType;
  235|  3.47M|        mShadeOptions = oth.mShadeOptions;
  236|  3.47M|        mPolygonMode = oth.mPolygonMode;
  237|  3.47M|        mPolygonModeOverrideable = oth.mPolygonModeOverrideable;
  238|  3.47M|        mPassIterationCount = oth.mPassIterationCount;
  239|  3.47M|        mLineWidth = oth.mLineWidth;
  240|  3.47M|        mPointAttenution = oth.mPointAttenution;
  241|  3.47M|        mPointMinSize = oth.mPointMinSize;
  242|  3.47M|        mPointMaxSize = oth.mPointMaxSize;
  243|  3.47M|        mPointSpritesEnabled = oth.mPointSpritesEnabled;
  244|  3.47M|        mPointAttenuationEnabled = oth.mPointAttenuationEnabled;
  245|  3.47M|        mShadowContentTypeLookup = oth.mShadowContentTypeLookup;
  246|  3.47M|        mContentTypeLookupBuilt = oth.mContentTypeLookupBuilt;
  247|  3.47M|        mLightScissoring = oth.mLightScissoring;
  248|  3.47M|        mLightClipPlanes = oth.mLightClipPlanes;
  249|  3.47M|        mIlluminationStage = oth.mIlluminationStage;
  250|  3.47M|        mLightMask = oth.mLightMask;
  251|       |
  252|  20.8M|        for(int i = 0; i < GPT_PIPELINE_COUNT; i++)
  ------------------
  |  Branch (252:24): [True: 17.3M, False: 3.47M]
  ------------------
  253|  17.3M|        {
  254|  17.3M|            auto& programUsage = mProgramUsage[i];
  255|  17.3M|            auto& othUsage = oth.mProgramUsage[i];
  256|  17.3M|            programUsage = othUsage ? std::make_unique<GpuProgramUsage>(*othUsage, this) : nullptr;
  ------------------
  |  Branch (256:28): [True: 1.18M, False: 16.2M]
  ------------------
  257|  17.3M|        }
  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|  3.47M|        for (auto *t : mTextureUnitStates)
  ------------------
  |  Branch (261:22): [True: 0, False: 3.47M]
  ------------------
  262|      0|        {
  263|      0|            OGRE_DELETE t;
  264|      0|        }
  265|       |
  266|  3.47M|        mTextureUnitStates.clear();
  267|       |
  268|       |        // Copy texture units
  269|  3.47M|        for (auto *s : oth.mTextureUnitStates)
  ------------------
  |  Branch (269:22): [True: 3.18M, False: 3.47M]
  ------------------
  270|  3.18M|        {
  271|  3.18M|            TextureUnitState* t = OGRE_NEW TextureUnitState(this, *s);
  272|  3.18M|            mTextureUnitStates.push_back(t);
  273|  3.18M|        }
  274|       |
  275|  3.47M|        _dirtyHash();
  276|       |
  277|  3.47M|        return *this;
  278|  3.47M|    }
_ZN4Ogre4Pass19setPointAttenuationEbfff:
  296|  1.58k|    {
  297|  1.58k|        mPointAttenuationEnabled = enabled;
  298|  1.58k|        mPointAttenution[1] = enabled ? constant : 1.0f;
  ------------------
  |  Branch (298:31): [True: 1.35k, False: 234]
  ------------------
  299|  1.58k|        mPointAttenution[2] = enabled ? linear : 0.0f;
  ------------------
  |  Branch (299:31): [True: 1.35k, False: 234]
  ------------------
  300|  1.58k|        mPointAttenution[3] = enabled ? quadratic : 0.0f;
  ------------------
  |  Branch (300:31): [True: 1.35k, False: 234]
  ------------------
  301|  1.58k|    }
_ZN4Ogre4Pass15setPointMinSizeEf:
  304|    273|    {
  305|    273|        mPointMinSize = min;
  306|    273|    }
_ZN4Ogre4Pass15setPointMaxSizeEf:
  314|    347|    {
  315|    347|        mPointMaxSize = max;
  316|    347|    }
_ZN4Ogre4Pass22createTextureUnitStateEv:
  355|  41.4k|    {
  356|       |        TextureUnitState *t = OGRE_NEW TextureUnitState(this);
  357|  41.4k|        addTextureUnitState(t);
  358|  41.4k|        mContentTypeLookupBuilt = false;
  359|  41.4k|        return t;
  360|  41.4k|    }
_ZN4Ogre4Pass19addTextureUnitStateEPNS_16TextureUnitStateE:
  374|  41.4k|    {
  375|  41.4k|        OGRE_LOCK_MUTEX(mTexUnitChangeMutex);
  376|       |
  377|  41.4k|        OgreAssert(state , "TextureUnitState is NULL");
  ------------------
  |  Branch (377:9): [True: 0, False: 41.4k]
  ------------------
  378|       |
  379|       |        // only attach TUS to pass if TUS does not belong to another pass
  380|  41.4k|        OgreAssert(!state->getParent() || (state->getParent() == this), "TextureUnitState already attached to another pass");
  ------------------
  |  Branch (380:9): [True: 0, False: 41.4k]
  |  Branch (380:9): [True: 41.4k, False: 0]
  ------------------
  381|       |
  382|  41.4k|        mTextureUnitStates.push_back(state);
  383|       |        // Notify state
  384|  41.4k|        state->_notifyParent(this);
  385|       |        // if texture unit state name is empty then give it a default name based on its index
  386|  41.4k|        if (state->getName().empty())
  ------------------
  |  Branch (386:13): [True: 41.4k, False: 0]
  ------------------
  387|  41.4k|        {
  388|       |            // its the last entry in the container so its index is size - 1
  389|  41.4k|            size_t idx = mTextureUnitStates.size() - 1;
  390|       |
  391|       |            // allow 8 digit hex number. there should never be that many texture units.
  392|       |            // This sprintf replaced a call to StringConverter::toString for performance reasons
  393|  41.4k|            state->setName( StringUtil::format("%lx", static_cast<long>(idx)));
  394|  41.4k|        }
  395|  41.4k|        _notifyNeedsRecompile();
  396|  41.4k|        _dirtyHash();
  397|       |
  398|  41.4k|        mContentTypeLookupBuilt = false;
  399|  41.4k|    }
_ZN4Ogre4Pass26removeAllTextureUnitStatesEv:
  459|  3.54M|    {
  460|  3.54M|        OGRE_LOCK_MUTEX(mTexUnitChangeMutex);
  461|  3.54M|        TextureUnitStates::iterator i, iend;
  462|  3.54M|        iend = mTextureUnitStates.end();
  463|  6.77M|        for (i = mTextureUnitStates.begin(); i != iend; ++i)
  ------------------
  |  Branch (463:46): [True: 3.22M, False: 3.54M]
  ------------------
  464|  3.22M|        {
  465|       |            OGRE_DELETE *i;
  466|  3.22M|        }
  467|  3.54M|        mTextureUnitStates.clear();
  468|  3.54M|        _notifyNeedsRecompile();
  469|  3.54M|        _dirtyHash();
  470|  3.54M|        mContentTypeLookupBuilt = false;
  471|  3.54M|    }
_ZN4Ogre4Pass16setSceneBlendingENS_14SceneBlendTypeE:
  502|  8.73k|    {
  503|       |        // Convert type into blend factors
  504|       |
  505|  8.73k|        SceneBlendFactor source;
  506|  8.73k|        SceneBlendFactor dest;
  507|  8.73k|        _getBlendFlags(sbt, source, dest);
  508|       |
  509|       |        // Set blend factors
  510|       |
  511|  8.73k|        setSceneBlending(source, dest);
  512|  8.73k|    }
_ZN4Ogre4Pass24setSeparateSceneBlendingENS_14SceneBlendTypeES1_:
  515|    986|    {
  516|       |        // Convert types into blend factors
  517|       |
  518|    986|        SceneBlendFactor source;
  519|    986|        SceneBlendFactor dest;
  520|    986|        _getBlendFlags(sbt, source, dest);
  521|       |
  522|    986|        SceneBlendFactor sourceAlpha;
  523|    986|        SceneBlendFactor destAlpha;
  524|    986|        _getBlendFlags(sbta, sourceAlpha, destAlpha);
  525|       |
  526|       |        // Set blend factors
  527|       |
  528|    986|        setSeparateSceneBlending(source, dest, sourceAlpha, destAlpha);
  529|    986|    }
_ZN4Ogre4Pass16setSceneBlendingENS_16SceneBlendFactorES1_:
  533|  9.23k|    {
  534|  9.23k|        mBlendState.sourceFactor = sourceFactor;
  535|  9.23k|        mBlendState.sourceFactorAlpha = sourceFactor;
  536|  9.23k|        mBlendState.destFactor = destFactor;
  537|  9.23k|        mBlendState.destFactorAlpha = destFactor;
  538|  9.23k|    }
_ZN4Ogre4Pass24setSeparateSceneBlendingENS_16SceneBlendFactorES1_S1_S1_:
  541|  1.21k|    {
  542|  1.21k|        mBlendState.sourceFactor = sourceFactor;
  543|  1.21k|        mBlendState.destFactor = destFactor;
  544|  1.21k|        mBlendState.sourceFactorAlpha = sourceFactorAlpha;
  545|  1.21k|        mBlendState.destFactorAlpha = destFactorAlpha;
  546|  1.21k|    }
_ZN4Ogre4Pass25setSceneBlendingOperationENS_19SceneBlendOperationE:
  549|  1.20k|    {
  550|  1.20k|        mBlendState.operation = op;
  551|  1.20k|        mBlendState.alphaOperation = op;
  552|  1.20k|    }
_ZN4Ogre4Pass33setSeparateSceneBlendingOperationENS_19SceneBlendOperationES1_:
  555|  1.12k|    {
  556|  1.12k|        mBlendState.operation = op;
  557|  1.12k|        mBlendState.alphaOperation = alphaOp;
  558|  1.12k|    }
_ZN4Ogre4Pass22setAlphaRejectSettingsENS_15CompareFunctionEhb:
  578|    241|    {
  579|    241|        mAlphaRejectFunc = func;
  580|    241|        mAlphaRejectVal = value;
  581|    241|        mAlphaToCoverageEnabled = alphaToCoverage;
  582|    241|    }
_ZN4Ogre4Pass21setColourWriteEnabledEb:
  585|    553|    {
  586|    553|        mBlendState.writeR = enabled;
  587|    553|        mBlendState.writeG = enabled;
  588|    553|        mBlendState.writeB = enabled;
  589|    553|        mBlendState.writeA = enabled;
  590|    553|    }
_ZN4Ogre4Pass21setColourWriteEnabledEbbbb:
  600|  2.53k|    {
  601|  2.53k|        mBlendState.writeR = red;
  602|  2.53k|        mBlendState.writeG = green;
  603|  2.53k|        mBlendState.writeB = blue;
  604|  2.53k|        mBlendState.writeA = alpha;
  605|  2.53k|    }
_ZN4Ogre4Pass18setIteratePerLightEbbNS_5Light10LightTypesE:
  617|  2.03k|    {
  618|  2.03k|        mIteratePerLight = enabled;
  619|  2.03k|        mRunOnlyForOneLightType = onlyForOneLightType;
  620|  2.03k|        mOnlyLightType = lightType;
  621|  2.03k|    }
_ZN4Ogre4Pass20setManualCullingModeENS_17ManualCullingModeE:
  624|    683|    {
  625|    683|        mManualCullMode = mode;
  626|    683|    }
_ZN4Ogre4Pass6setFogEbNS_7FogModeERKNS_11ColourValueEfff:
  634|  1.63k|    {
  635|  1.63k|        mFogOverride = overrideScene;
  636|  1.63k|        if (overrideScene)
  ------------------
  |  Branch (636:13): [True: 1.57k, False: 67]
  ------------------
  637|  1.57k|        {
  638|  1.57k|            mFogMode = mode;
  639|  1.57k|            mFogColour = colour;
  640|  1.57k|            mFogStart = start;
  641|  1.57k|            mFogEnd = end;
  642|  1.57k|            mFogDensity = density;
  643|  1.57k|        }
  644|  1.63k|    }
_ZN4Ogre4Pass12setDepthBiasEff:
  647|  1.45k|    {
  648|  1.45k|       mDepthBiasConstant = constantBias;
  649|  1.45k|       mDepthBiasSlopeScale = slopeScaleBias;
  650|  1.45k|    }
_ZN4Ogre4Pass13setGpuProgramENS_14GpuProgramTypeERKNS_9SharedPtrINS_10GpuProgramEEEb:
  770|  54.8k|    {
  771|  54.8k|        OGRE_LOCK_MUTEX(mGpuProgramChangeMutex);
  772|       |
  773|  54.8k|        std::unique_ptr<GpuProgramUsage>& programUsage = getProgramUsage(type);
  774|       |
  775|       |        // Turn off fragment program if name blank
  776|  54.8k|        if (!program)
  ------------------
  |  Branch (776:13): [True: 0, False: 54.8k]
  ------------------
  777|      0|        {
  778|      0|            programUsage.reset();
  779|      0|        }
  780|  54.8k|        else
  781|  54.8k|        {
  782|  54.8k|            if (!programUsage)
  ------------------
  |  Branch (782:17): [True: 45.0k, False: 9.78k]
  ------------------
  783|  45.0k|            {
  784|  45.0k|                programUsage = std::make_unique<GpuProgramUsage>(type, this);
  785|  45.0k|            }
  786|  54.8k|            programUsage->setProgram(program, resetParams);
  787|  54.8k|        }
  788|       |        // Needs recompilation
  789|  54.8k|        _notifyNeedsRecompile();
  790|       |
  791|  54.8k|        if( Pass::getHashFunction() == Pass::getBuiltinHashFunction( Pass::MIN_GPU_PROGRAM_CHANGE ) )
  ------------------
  |  Branch (791:13): [True: 54.8k, False: 0]
  ------------------
  792|  54.8k|        {
  793|  54.8k|            _dirtyHash();
  794|  54.8k|        }
  795|  54.8k|    }
_ZN4Ogre4Pass15getProgramUsageENS_14GpuProgramTypeE:
  820|  54.8k|    std::unique_ptr<GpuProgramUsage>& Pass::getProgramUsage(GpuProgramType programType) {
  821|  54.8k|        return mProgramUsage[programType % GPT_PIPELINE_COUNT];
  822|  54.8k|    }
_ZNK4Ogre4Pass15getProgramUsageENS_14GpuProgramTypeE:
  825|  28.3M|    {
  826|  28.3M|        static std::unique_ptr<GpuProgramUsage> nullUsage;
  827|  28.3M|        auto& ret = mProgramUsage[programType % GPT_PIPELINE_COUNT];
  828|  28.3M|        return ret && ret->getType() == programType ? ret : nullUsage;
  ------------------
  |  Branch (828:16): [True: 1.20M, False: 27.1M]
  |  Branch (828:23): [True: 1.18M, False: 16.6k]
  ------------------
  829|  28.3M|    }
_ZNK4Ogre4Pass17getGpuProgramNameENS_14GpuProgramTypeE:
  843|  28.3M|    {
  844|  28.3M|        OGRE_LOCK_MUTEX(mGpuProgramChangeMutex);
  845|       |
  846|  28.3M|        const std::unique_ptr<GpuProgramUsage>& programUsage = getProgramUsage(type);
  847|  28.3M|        if (!programUsage)
  ------------------
  |  Branch (847:13): [True: 27.1M, False: 1.18M]
  ------------------
  848|  27.1M|            return BLANKSTRING;
  849|  1.18M|        else
  850|  1.18M|            return programUsage->getProgramName();
  851|  28.3M|    }
_ZNK4Ogre4Pass8isLoadedEv:
  854|  3.32M|    {
  855|  3.32M|        return mParent->isLoaded();
  856|  3.32M|    }
_ZN4Ogre4Pass16_recalculateHashEv:
  859|  3.54M|    {
  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.54M|        mHash = (*msHashFunc)(this);
  866|       |
  867|       |        // overwrite the 4 upper bits with pass index
  868|  3.54M|        mHash = (uint32(mIndex) << 28) | (mHash >> 4);
  869|  3.54M|    }
_ZN4Ogre4Pass10_dirtyHashEv:
  872|  7.12M|    {
  873|  7.12M|        if (mQueuedForDeletion)
  ------------------
  |  Branch (873:13): [True: 3.54M, False: 3.57M]
  ------------------
  874|  3.54M|            return;
  875|       |
  876|  3.57M|        Material* mat = mParent->getParent();
  877|  3.57M|        if (mat->isLoading() || mat->isLoaded())
  ------------------
  |  Branch (877:13): [True: 0, False: 3.57M]
  |  Branch (877:33): [True: 0, False: 3.57M]
  ------------------
  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|  3.57M|        else
  885|  3.57M|        {
  886|  3.57M|            mHashDirtyQueued = true;
  887|  3.57M|        }
  888|  3.57M|    }
_ZN4Ogre4Pass21_notifyNeedsRecompileEv:
  897|  3.64M|    {
  898|  3.64M|        if (!mQueuedForDeletion)
  ------------------
  |  Branch (898:13): [True: 96.2k, False: 3.54M]
  ------------------
  899|  96.2k|            mParent->_notifyNeedsRecompile();
  900|  3.64M|    }
_ZN4Ogre4Pass25processPendingPassUpdatesEv:
  934|  15.8k|    {
  935|  15.8k|        {
  936|  15.8k|            OGRE_LOCK_MUTEX(msPassGraveyardMutex);
  937|       |            // Delete items in the graveyard
  938|  15.8k|            for (auto& i : msPassGraveyard)
  ------------------
  |  Branch (938:26): [True: 3.54M, False: 15.8k]
  ------------------
  939|  3.54M|            {
  940|  3.54M|                OGRE_DELETE i;
  941|  3.54M|            }
  942|  15.8k|            msPassGraveyard.clear();
  943|  15.8k|        }
  944|  15.8k|        PassSet tempDirtyHashList;
  945|  15.8k|        {
  946|  15.8k|            OGRE_LOCK_MUTEX(msDirtyHashListMutex);
  947|       |            // The dirty ones will have been removed from the groups above using the old hash now
  948|  15.8k|            tempDirtyHashList.swap(msDirtyHashList);
  949|  15.8k|        }
  950|  15.8k|        for (auto *p : tempDirtyHashList)
  ------------------
  |  Branch (950:22): [True: 0, False: 15.8k]
  ------------------
  951|      0|        {
  952|      0|            p->_recalculateHash();
  953|      0|        }
  954|  15.8k|    }
_ZN4Ogre4Pass16queueForDeletionEv:
  957|  3.54M|    {
  958|  3.54M|        mQueuedForDeletion = true;
  959|       |
  960|  3.54M|        removeAllTextureUnitStates();
  961|  3.54M|        for (auto& u : mProgramUsage)
  ------------------
  |  Branch (961:22): [True: 17.7M, False: 3.54M]
  ------------------
  962|  17.7M|            u.reset();
  963|       |
  964|       |        // remove from dirty list, if there
  965|  3.54M|        {
  966|  3.54M|            OGRE_LOCK_MUTEX(msDirtyHashListMutex);
  967|  3.54M|            msDirtyHashList.erase(this);
  968|  3.54M|        }
  969|  3.54M|        {
  970|  3.54M|            OGRE_LOCK_MUTEX(msPassGraveyardMutex);
  971|  3.54M|            msPassGraveyard.insert(this);
  972|  3.54M|        }
  973|  3.54M|    }
_ZNK4Ogre4Pass16getResourceGroupEv:
  989|  19.7M|    {
  990|  19.7M|        return mParent->getResourceGroup();
  991|  19.7M|    }
OgrePass.cpp:_ZN4OgreL14_getBlendFlagsENS_14SceneBlendTypeERNS_16SceneBlendFactorES2_:
  474|  10.7k|    {
  475|  10.7k|        switch ( type )
  476|  10.7k|        {
  477|  1.37k|        case SBT_TRANSPARENT_ALPHA:
  ------------------
  |  Branch (477:9): [True: 1.37k, False: 9.32k]
  ------------------
  478|  1.37k|            source = SBF_SOURCE_ALPHA;
  479|  1.37k|            dest = SBF_ONE_MINUS_SOURCE_ALPHA;
  480|  1.37k|            return;
  481|    320|        case SBT_TRANSPARENT_COLOUR:
  ------------------
  |  Branch (481:9): [True: 320, False: 10.3k]
  ------------------
  482|    320|            source = SBF_SOURCE_COLOUR;
  483|    320|            dest = SBF_ONE_MINUS_SOURCE_COLOUR;
  484|    320|            return;
  485|    959|        case SBT_MODULATE:
  ------------------
  |  Branch (485:9): [True: 959, False: 9.74k]
  ------------------
  486|    959|            source = SBF_DEST_COLOUR;
  487|    959|            dest = SBF_ZERO;
  488|    959|            return;
  489|  8.04k|        case SBT_ADD:
  ------------------
  |  Branch (489:9): [True: 8.04k, False: 2.65k]
  ------------------
  490|  8.04k|            source = SBF_ONE;
  491|  8.04k|            dest = SBF_ONE;
  492|  8.04k|            return;
  493|      0|        default:
  ------------------
  |  Branch (493:9): [True: 0, False: 10.7k]
  ------------------
  494|      0|        case SBT_REPLACE:
  ------------------
  |  Branch (494:9): [True: 0, False: 10.7k]
  ------------------
  495|      0|            source = SBF_ONE;
  496|      0|            dest = SBF_ZERO;
  497|      0|            return;
  498|  10.7k|        }
  499|  10.7k|    }
_ZNK4Ogre27MinGpuProgramChangeHashFuncclEPKNS_4PassE:
   67|  3.54M|        {
   68|  3.54M|            OGRE_LOCK_MUTEX(p->mGpuProgramChangeMutex);
   69|  3.54M|            uint32 hash = 0;
   70|       |
   71|  31.9M|            for(int i = 0; i < GPT_COUNT; i++)
  ------------------
  |  Branch (71:28): [True: 28.3M, False: 3.54M]
  ------------------
   72|  28.3M|            {
   73|  28.3M|                const String& name = p->getGpuProgramName(GpuProgramType(i));
   74|  28.3M|                if(!name.empty()) {
  ------------------
  |  Branch (74:20): [True: 1.18M, False: 27.1M]
  ------------------
   75|  1.18M|                    hash = FastHash(name.c_str(), name.size(), hash);
   76|  1.18M|                }
   77|  28.3M|            }
   78|       |
   79|  3.54M|            return hash;
   80|  3.54M|        }

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

_ZN4Ogre9PixelUtil8getFlagsENS_11PixelFormatE:
  198|  2.64M|    {
  199|  2.64M|        return getDescriptionFor(format).flags;
  200|  2.64M|    }
_ZN4Ogre9PixelUtil12isCompressedENS_11PixelFormatE:
  218|  2.64M|    {
  219|  2.64M|        return (PixelUtil::getFlags(format) & PFF_COMPRESSED) > 0;
  220|  2.64M|    }
_ZN4Ogre9PixelUtil13getFormatNameENS_11PixelFormatE:
  265|  1.71M|    {
  266|  1.71M|        return getDescriptionFor(srcformat).name;
  267|  1.71M|    }
_ZN4Ogre9PixelUtil12isAccessibleENS_11PixelFormatE:
  270|  2.67M|    {
  271|  2.67M|        return (srcformat != PF_UNKNOWN) && !isCompressed(srcformat);
  ------------------
  |  Branch (271:16): [True: 2.64M, False: 28.1k]
  |  Branch (271:45): [True: 1.71M, False: 927k]
  ------------------
  272|  2.67M|    }
_ZN4Ogre9PixelUtil17getFormatFromNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbb:
  287|  28.1k|    {
  288|  28.1k|        String tmp = name;
  289|  28.1k|        if (!caseSensitive)
  ------------------
  |  Branch (289:13): [True: 28.1k, False: 0]
  ------------------
  290|  28.1k|        {
  291|       |            // We are stored upper-case format names.
  292|  28.1k|            StringUtil::toUpperCase(tmp);
  293|  28.1k|        }
  294|       |
  295|  2.69M|        for (int i = 0; i < PF_COUNT; ++i)
  ------------------
  |  Branch (295:25): [True: 2.67M, False: 23.1k]
  ------------------
  296|  2.67M|        {
  297|  2.67M|            PixelFormat pf = static_cast<PixelFormat>(i);
  298|  2.67M|            if (!accessibleOnly || isAccessible(pf))
  ------------------
  |  Branch (298:17): [True: 0, False: 2.67M]
  |  Branch (298:36): [True: 1.71M, False: 955k]
  ------------------
  299|  1.71M|            {
  300|  1.71M|                if (tmp == getFormatName(pf))
  ------------------
  |  Branch (300:21): [True: 5.00k, False: 1.71M]
  ------------------
  301|  5.00k|                    return pf;
  302|  1.71M|            }
  303|  2.67M|        }
  304|       |
  305|       |        // allow look-up by alias name
  306|  23.1k|        if(tmp == "PF_BYTE_RGB")
  ------------------
  |  Branch (306:12): [True: 2.00k, False: 21.1k]
  ------------------
  307|  2.00k|            return PF_BYTE_RGB;
  308|  21.1k|        if(tmp == "PF_BYTE_RGBA")
  ------------------
  |  Branch (308:12): [True: 1.36k, False: 19.7k]
  ------------------
  309|  1.36k|            return PF_BYTE_RGBA;
  310|  19.7k|        if(tmp == "PF_BYTE_BGR")
  ------------------
  |  Branch (310:12): [True: 348, False: 19.3k]
  ------------------
  311|    348|            return PF_BYTE_BGR;
  312|  19.3k|        if(tmp == "PF_BYTE_BGRA")
  ------------------
  |  Branch (312:12): [True: 323, False: 19.0k]
  ------------------
  313|    323|            return PF_BYTE_BGRA;
  314|       |
  315|  19.0k|        return PF_UNKNOWN;
  316|  19.3k|    }
OgrePixelFormat.cpp:_ZN4OgreL17getDescriptionForENS_11PixelFormatE:
   88|  4.36M|    {
   89|  4.36M|        const int ord = (int)fmt;
   90|  4.36M|        assert(ord>=0 && ord<PF_COUNT);
   91|       |
   92|  4.36M|        return _pixelFormats[ord];
   93|  4.36M|    }

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

_ZN4Ogre24RenderSystemCapabilities16vendorFromStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  266|  4.31k|    {
  267|  4.31k|        initVendorStrings();
  268|  4.31k|        GPUVendor ret = GPU_UNKNOWN;
  269|  4.31k|        String cmpString = vendorString;
  270|  4.31k|        StringUtil::toLowerCase(cmpString);
  271|  42.4k|        for (int i = 0; i < GPU_VENDOR_COUNT; ++i)
  ------------------
  |  Branch (271:25): [True: 40.4k, False: 1.98k]
  ------------------
  272|  40.4k|        {
  273|       |            // case insensitive (lower case)
  274|  40.4k|            if (msGPUVendorStrings[i] == cmpString)
  ------------------
  |  Branch (274:17): [True: 2.33k, False: 38.1k]
  ------------------
  275|  2.33k|            {
  276|  2.33k|                ret = static_cast<GPUVendor>(i);
  277|  2.33k|                break;
  278|  2.33k|            }
  279|  40.4k|        }
  280|       |
  281|  4.31k|        return ret;
  282|       |        
  283|  4.31k|    }
_ZN4Ogre24RenderSystemCapabilities17initVendorStringsEv:
  292|  4.31k|    {
  293|  4.31k|        if (msGPUVendorStrings[0].empty())
  ------------------
  |  Branch (293:13): [True: 1, False: 4.31k]
  ------------------
  294|      1|        {
  295|       |            // Always lower case!
  296|      1|            msGPUVendorStrings[GPU_UNKNOWN] = "unknown";
  297|      1|            msGPUVendorStrings[GPU_NVIDIA] = "nvidia";
  298|      1|            msGPUVendorStrings[GPU_AMD] = "amd";
  299|      1|            msGPUVendorStrings[GPU_INTEL] = "intel";
  300|      1|            msGPUVendorStrings[GPU_IMAGINATION_TECHNOLOGIES] = "imagination technologies";
  301|      1|            msGPUVendorStrings[GPU_APPLE] = "apple";    // iOS Simulator
  302|      1|            msGPUVendorStrings[GPU_NOKIA] = "nokia";
  303|      1|            msGPUVendorStrings[GPU_MS_SOFTWARE] = "microsoft"; // Microsoft software device
  304|      1|            msGPUVendorStrings[GPU_MS_WARP] = "ms warp";
  305|      1|            msGPUVendorStrings[GPU_ARM] = "arm";
  306|      1|            msGPUVendorStrings[GPU_QUALCOMM] = "qualcomm";
  307|      1|            msGPUVendorStrings[GPU_MOZILLA] = "mozilla";
  308|      1|            msGPUVendorStrings[GPU_WEBKIT] = "webkit";
  309|      1|        }
  310|  4.31k|    }

_ZN4Ogre31RenderSystemCapabilitiesManagerC2Ev:
   49|      1|    RenderSystemCapabilitiesManager::RenderSystemCapabilitiesManager() : mSerializer(0), mScriptPattern("*.rendercaps")
   50|      1|    {
   51|       |        mSerializer = OGRE_NEW RenderSystemCapabilitiesSerializer();
   52|      1|    }

_ZN4Ogre34RenderSystemCapabilitiesSerializerC2Ev:
   38|      1|    RenderSystemCapabilitiesSerializer::RenderSystemCapabilitiesSerializer() : mCurrentLineNumber(0), mCurrentLine(0),
   39|      1|        mCurrentCapabilities(0)
   40|      1|    {
   41|      1|        initialiaseDispatchTables();
   42|      1|    }
_ZN4Ogre34RenderSystemCapabilitiesSerializer25initialiaseDispatchTablesEv:
  267|      1|    {
  268|       |        // set up driver version parsing
  269|      1|        addKeywordType("driver_version", SET_STRING_METHOD);
  270|       |        // set up the setters for driver versions
  271|      1|        addSetStringMethod("driver_version", &RenderSystemCapabilities::parseDriverVersionFromString);
  272|       |        
  273|       |        // set up device name parsing
  274|      1|        addKeywordType("device_name", SET_STRING_METHOD);
  275|       |        // set up the setters for device names
  276|      1|        addSetStringMethod("device_name", &RenderSystemCapabilities::setDeviceName);
  277|       |        
  278|       |        // set up render system name parsing
  279|      1|        addKeywordType("render_system_name", SET_STRING_METHOD);
  280|       |        // set up the setters 
  281|      1|        addSetStringMethod("render_system_name", &RenderSystemCapabilities::setRenderSystemName);
  282|       |
  283|       |        // set up vendor parsing
  284|      1|        addKeywordType("vendor", SET_STRING_METHOD);
  285|       |        // set up the setters for driver versions
  286|      1|        addSetStringMethod("vendor", &RenderSystemCapabilities::parseVendorFromString);
  287|       |
  288|       |        // initialize int types
  289|      1|        addKeywordType("num_world_matrices", SET_INT_METHOD);
  290|      1|        addKeywordType("num_texture_units", SET_INT_METHOD);
  291|      1|        addKeywordType("stencil_buffer_bit_depth", SET_INT_METHOD);
  292|      1|        addKeywordType("num_vertex_blend_matrices", SET_INT_METHOD);
  293|      1|        addKeywordType("num_multi_render_targets", SET_INT_METHOD);
  294|      1|        addKeywordType("vertex_program_constant_float_count", SET_INT_METHOD);
  295|      1|        addKeywordType("vertex_program_constant_int_count", SET_INT_METHOD);
  296|      1|        addKeywordType("vertex_program_constant_bool_count", SET_INT_METHOD);
  297|      1|        addKeywordType("fragment_program_constant_float_count", SET_INT_METHOD);
  298|      1|        addKeywordType("fragment_program_constant_int_count", SET_INT_METHOD);
  299|      1|        addKeywordType("fragment_program_constant_bool_count", SET_INT_METHOD);
  300|      1|        addKeywordType("geometry_program_constant_float_count", SET_INT_METHOD);
  301|      1|        addKeywordType("geometry_program_constant_int_count", SET_INT_METHOD);
  302|      1|        addKeywordType("geometry_program_constant_bool_count", SET_INT_METHOD);
  303|      1|        addKeywordType("tessellation_hull_program_constant_float_count", SET_INT_METHOD);
  304|      1|        addKeywordType("tessellation_hull_program_constant_int_count", SET_INT_METHOD);
  305|      1|        addKeywordType("tessellation_hull_program_constant_bool_count", SET_INT_METHOD);
  306|      1|        addKeywordType("tessellation_domain_program_constant_float_count", SET_INT_METHOD);
  307|      1|        addKeywordType("tessellation_domain_program_constant_int_count", SET_INT_METHOD);
  308|      1|        addKeywordType("tessellation_domain_program_constant_bool_count", SET_INT_METHOD);
  309|      1|        addKeywordType("compute_program_constant_float_count", SET_INT_METHOD);
  310|      1|        addKeywordType("compute_program_constant_int_count", SET_INT_METHOD);
  311|      1|        addKeywordType("compute_program_constant_bool_count", SET_INT_METHOD);
  312|      1|        addKeywordType("num_vertex_texture_units", SET_INT_METHOD);
  313|       |
  314|       |        // initialize int setters
  315|      1|        addSetIntMethod("num_texture_units", &RenderSystemCapabilities::setNumTextureUnits);
  316|      1|        addSetIntMethod("stencil_buffer_bit_depth", &RenderSystemCapabilities::setStencilBufferBitDepth);
  317|      1|        addSetIntMethod("num_multi_render_targets", &RenderSystemCapabilities::setNumMultiRenderTargets);
  318|      1|        addSetIntMethod("vertex_program_constant_float_count", &RenderSystemCapabilities::setVertexProgramConstantFloatCount);
  319|      1|        addSetIntMethod("fragment_program_constant_float_count", &RenderSystemCapabilities::setFragmentProgramConstantFloatCount);
  320|      1|        addSetIntMethod("geometry_program_constant_float_count", &RenderSystemCapabilities::setGeometryProgramConstantFloatCount);
  321|      1|        addSetIntMethod("tessellation_hull_program_constant_float_count", &RenderSystemCapabilities::setTessellationHullProgramConstantFloatCount);
  322|      1|        addSetIntMethod("tessellation_domain_program_constant_float_count", &RenderSystemCapabilities::setTessellationDomainProgramConstantFloatCount);
  323|      1|        addSetIntMethod("compute_program_constant_float_count", &RenderSystemCapabilities::setComputeProgramConstantFloatCount);
  324|      1|        addSetIntMethod("num_vertex_texture_units", &RenderSystemCapabilities::setNumVertexTextureUnits);
  325|       |
  326|       |        // initialize bool types
  327|      1|        addKeywordType("non_pow2_textures_limited", SET_BOOL_METHOD);
  328|       |
  329|       |        // initialize bool setters
  330|      1|        addSetBoolMethod("non_pow2_textures_limited", &RenderSystemCapabilities::setNonPOW2TexturesLimited);
  331|       |
  332|       |        // initialize Real types
  333|      1|        addKeywordType("max_point_size", SET_REAL_METHOD);
  334|       |
  335|       |        // initialize Real setters
  336|      1|        addSetRealMethod("max_point_size", &RenderSystemCapabilities::setMaxPointSize);
  337|       |
  338|       |        // there is no dispatch table for shader profiles, just the type
  339|      1|        addKeywordType("shader_profile", ADD_SHADER_PROFILE_STRING);
  340|       |
  341|      1|        addCapabilitiesMapping("fixed_function", RSC_FIXED_FUNCTION);
  342|      1|        addCapabilitiesMapping("anisotropy", RSC_ANISOTROPY);
  343|      1|        addCapabilitiesMapping("hwstencil", RSC_HWSTENCIL);
  344|      1|        addCapabilitiesMapping("32bit_index", RSC_32BIT_INDEX);
  345|      1|        addCapabilitiesMapping("vertex_program", RSC_VERTEX_PROGRAM);
  346|      1|        addCapabilitiesMapping("geometry_program", RSC_GEOMETRY_PROGRAM);
  347|      1|        addCapabilitiesMapping("tessellation_hull_program", RSC_TESSELLATION_HULL_PROGRAM);
  348|      1|        addCapabilitiesMapping("tessellation_domain_program", RSC_TESSELLATION_DOMAIN_PROGRAM);
  349|      1|        addCapabilitiesMapping("compute_program", RSC_COMPUTE_PROGRAM);
  350|      1|        addCapabilitiesMapping("two_sided_stencil", RSC_TWO_SIDED_STENCIL);
  351|      1|        addCapabilitiesMapping("stencil_wrap", RSC_STENCIL_WRAP);
  352|      1|        addCapabilitiesMapping("hwocclusion", RSC_HWOCCLUSION);
  353|      1|        addCapabilitiesMapping("user_clip_planes", RSC_USER_CLIP_PLANES);
  354|      1|        addCapabilitiesMapping("hwrender_to_texture", RSC_HWRENDER_TO_TEXTURE);
  355|      1|        addCapabilitiesMapping("texture_float", RSC_TEXTURE_FLOAT);
  356|      1|        addCapabilitiesMapping("non_power_of_2_textures", RSC_NON_POWER_OF_2_TEXTURES);
  357|      1|        addCapabilitiesMapping("texture_3d", RSC_TEXTURE_3D);
  358|      1|        addCapabilitiesMapping("texture_2d_array", RSC_TEXTURE_3D);
  359|      1|        addCapabilitiesMapping("texture_1d", RSC_TEXTURE_1D);
  360|      1|        addCapabilitiesMapping("point_sprites", RSC_POINT_SPRITES);
  361|      1|        addCapabilitiesMapping("wide_lines", RSC_WIDE_LINES);
  362|      1|        addCapabilitiesMapping("vertex_texture_fetch", RSC_VERTEX_TEXTURE_FETCH);
  363|      1|        addCapabilitiesMapping("mipmap_lod_bias", RSC_MIPMAP_LOD_BIAS);
  364|      1|        addCapabilitiesMapping("atomic_counters", RSC_READ_WRITE_BUFFERS);
  365|      1|        addCapabilitiesMapping("texture_compression", RSC_TEXTURE_COMPRESSION);
  366|      1|        addCapabilitiesMapping("texture_compression_dxt", RSC_TEXTURE_COMPRESSION_DXT);
  367|      1|        addCapabilitiesMapping("texture_compression_vtc", RSC_TEXTURE_COMPRESSION_VTC);
  368|      1|        addCapabilitiesMapping("texture_compression_pvrtc", RSC_TEXTURE_COMPRESSION_PVRTC);
  369|      1|        addCapabilitiesMapping("texture_compression_atc", RSC_TEXTURE_COMPRESSION_ATC);
  370|      1|        addCapabilitiesMapping("texture_compression_etc1", RSC_TEXTURE_COMPRESSION_ETC1);
  371|      1|        addCapabilitiesMapping("texture_compression_etc2", RSC_TEXTURE_COMPRESSION_ETC2);
  372|      1|        addCapabilitiesMapping("texture_compression_bc4_bc5", RSC_TEXTURE_COMPRESSION_BC4_BC5);
  373|      1|        addCapabilitiesMapping("texture_compression_bc6h_bc7", RSC_TEXTURE_COMPRESSION_BC6H_BC7);
  374|      1|        addCapabilitiesMapping("texture_compression_astc", RSC_TEXTURE_COMPRESSION_ASTC);
  375|      1|        addCapabilitiesMapping("hwrender_to_vertex_buffer", RSC_HWRENDER_TO_VERTEX_BUFFER);
  376|       |
  377|      1|        addCapabilitiesMapping("pbuffer", RSC_PBUFFER);
  378|      1|        addCapabilitiesMapping("perstageconstant", RSC_PERSTAGECONSTANT);
  379|      1|        addCapabilitiesMapping("vao", RSC_VAO);
  380|      1|        addCapabilitiesMapping("separate_shader_objects", RSC_SEPARATE_SHADER_OBJECTS);
  381|      1|        addCapabilitiesMapping("glsl_sso_redeclare", RSC_GLSL_SSO_REDECLARE);
  382|      1|        addCapabilitiesMapping("debug", RSC_DEBUG);
  383|      1|        addCapabilitiesMapping("mapbuffer", RSC_MAPBUFFER);
  384|      1|        addCapabilitiesMapping("automipmap_compressed", RSC_AUTOMIPMAP_COMPRESSED);
  385|      1|    }

_ZN4Ogre8ResourceC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE:
   36|  15.9M|        : mCreator(creator), mName(name), mGroup(group), mHandle(handle), 
   37|  15.9M|        mLoadingState(LOADSTATE_UNLOADED), mIsBackgroundLoaded(false),
   38|  15.9M|        mIsManual(isManual), mSize(0),  mLoader(loader), mStateCount(0)
   39|  15.9M|    {
   40|  15.9M|    }
_ZN4Ogre8ResourceD2Ev:
   43|  15.9M|    { 
   44|  15.9M|    }
_ZN4Ogre8ResourceaSERKS0_:
   46|  49.6k|    {
   47|  49.6k|        mName = rhs.mName;
   48|  49.6k|        mGroup = rhs.mGroup;
   49|  49.6k|        mCreator = rhs.mCreator;
   50|  49.6k|        mIsManual = rhs.mIsManual;
   51|  49.6k|        mLoader = rhs.mLoader;
   52|  49.6k|        mHandle = rhs.mHandle;
   53|  49.6k|        mSize = rhs.mSize;
   54|       |
   55|  49.6k|        mLoadingState.store(rhs.mLoadingState.load());
   56|  49.6k|        mIsBackgroundLoaded = rhs.mIsBackgroundLoaded;
   57|       |
   58|  49.6k|        return *this;
   59|  49.6k|    }
_ZN4Ogre8Resource6unloadEv:
  333|  15.9M|    { 
  334|       |        // Early-out without lock (mitigate perf cost of ensuring unloaded)
  335|  15.9M|        LoadingState old = mLoadingState.load();
  336|  15.9M|        if (old!=LOADSTATE_LOADED && old!=LOADSTATE_PREPARED) return;
  ------------------
  |  Branch (336:13): [True: 15.9M, False: 0]
  |  Branch (336:38): [True: 15.9M, 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|    }
_ZN4Ogre8Resource11addListenerEPNS0_8ListenerE:
  386|  54.4k|    {
  387|  54.4k|            OGRE_LOCK_MUTEX(mListenerListMutex);
  388|  54.4k|        mListenerList.insert(lis);
  389|  54.4k|    }
_ZN4Ogre8Resource14removeListenerEPNS0_8ListenerE:
  392|  1.23M|    {
  393|       |        // O(n) but not called very often
  394|  1.23M|            OGRE_LOCK_MUTEX(mListenerListMutex);
  395|  1.23M|        mListenerList.erase(lis);
  396|  1.23M|    }

_ZN4Ogre23ResourceBackgroundQueueC2Ev:
   47|      1|    ResourceBackgroundQueue::ResourceBackgroundQueue() {}

_ZN4Ogre20ResourceGroupManager12getSingletonEv:
   40|   106M|    {  
   41|       |        assert( msSingleton );  return ( *msSingleton );  
   42|   106M|    }
_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|  15.8k|    {
   84|  15.8k|        LogManager::getSingleton().logMessage("Creating resource group " + name);
   85|  15.8k|        if (getResourceGroup(name))
  ------------------
  |  Branch (85:13): [True: 0, False: 15.8k]
  ------------------
   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|  15.8k|        ResourceGroup* grp = OGRE_NEW_T(ResourceGroup, MEMCATEGORY_RESOURCE)();
   92|  15.8k|        grp->groupStatus = ResourceGroup::UNINITIALSED;
   93|  15.8k|        grp->name = name;
   94|  15.8k|        grp->inGlobalPool = inGlobalPool;
   95|  15.8k|        grp->customStageCount = 0;
   96|       |
   97|  15.8k|        OGRE_LOCK_AUTO_MUTEX;
   98|  15.8k|        mResourceGroupMap.emplace(name, grp);
   99|  15.8k|    }
_ZN4Ogre20ResourceGroupManager19unloadResourceGroupERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
  281|  15.8k|    {
  282|  15.8k|        LogManager::getSingleton().logMessage("Unloading resource group " + name);
  283|  15.8k|        ResourceGroup* grp = getResourceGroup(name, true);
  284|  15.8k|        OGRE_LOCK_AUTO_MUTEX;
  285|       |        // Set current group
  286|  15.8k|        mCurrentGroup = grp;
  287|  15.8k|        OGRE_LOCK_MUTEX(grp->OGRE_AUTO_MUTEX_NAME); // lock group mutex 
  288|       |
  289|       |        // unload in reverse order
  290|  15.8k|        for (auto& oi : grp->loadResourceOrderMap)
  ------------------
  |  Branch (290:23): [True: 13.1k, False: 15.8k]
  ------------------
  291|  13.1k|        {
  292|  13.1k|            for (auto& l : oi.second)
  ------------------
  |  Branch (292:26): [True: 15.9M, False: 13.1k]
  ------------------
  293|  15.9M|            {
  294|  15.9M|                Resource* resource = l.get();
  295|  15.9M|                if (!reloadableOnly || resource->isReloadable())
  ------------------
  |  Branch (295:21): [True: 15.9M, False: 0]
  |  Branch (295:40): [True: 0, False: 0]
  ------------------
  296|  15.9M|                {
  297|  15.9M|                    resource->unload();
  298|  15.9M|                }
  299|  15.9M|            }
  300|  13.1k|        }
  301|       |
  302|  15.8k|        grp->groupStatus = ResourceGroup::INITIALISED;
  303|       |
  304|       |        // reset current group
  305|  15.8k|        mCurrentGroup = 0;
  306|  15.8k|        LogManager::getSingleton().logMessage("Finished unloading resource group " + name);
  307|  15.8k|    }
_ZN4Ogre20ResourceGroupManager20destroyResourceGroupERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  362|  15.8k|    {
  363|  15.8k|        LogManager::getSingleton().logMessage("Destroying resource group " + name);
  364|  15.8k|        ResourceGroup* grp = getResourceGroup(name, true);
  365|  15.8k|        OGRE_LOCK_AUTO_MUTEX;
  366|       |        // set current group
  367|  15.8k|        mCurrentGroup = grp;
  368|  15.8k|        unloadResourceGroup(name, false); // will throw an exception if name not valid
  369|  15.8k|        dropGroupContents(grp);
  370|  15.8k|        deleteGroup(grp);
  371|  15.8k|        mResourceGroupMap.erase(mResourceGroupMap.find(name));
  372|       |        // reset current group
  373|  15.8k|        mCurrentGroup = 0;
  374|  15.8k|    }
_ZN4Ogre20ResourceGroupManager24_registerResourceManagerERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_15ResourceManagerE:
  702|      5|    {
  703|      5|        OGRE_LOCK_AUTO_MUTEX;
  704|       |
  705|      5|        LogManager::getSingleton().logMessage(
  706|      5|            "Registering ResourceManager for type " + resourceType);
  707|      5|        mResourceManagerMap[resourceType] = rm;
  708|      5|    }
_ZN4Ogre20ResourceGroupManager21_registerScriptLoaderEPNS_12ScriptLoaderE:
  726|      1|    {
  727|      1|            OGRE_LOCK_AUTO_MUTEX;
  728|       |
  729|      1|        mScriptLoaderOrderMap.emplace(su->getLoadingOrder(), su);
  730|      1|    }
_ZNK4Ogre20ResourceGroupManager22_notifyResourceCreatedERNS_9SharedPtrINS_8ResourceEEE:
  863|  15.9M|    {
  864|  15.9M|        if (mCurrentGroup && res->getGroup() == mCurrentGroup->name)
  ------------------
  |  Branch (864:13): [True: 0, False: 15.9M]
  |  Branch (864:30): [True: 0, False: 0]
  ------------------
  865|      0|        {
  866|       |            // Use current group (batch loading)
  867|      0|            addCreatedResource(res, *mCurrentGroup);
  868|      0|        }
  869|  15.9M|        else
  870|  15.9M|        {
  871|       |            // Find group
  872|  15.9M|            ResourceGroup* grp = getResourceGroup(res->getGroup());
  873|  15.9M|            if (grp)
  ------------------
  |  Branch (873:17): [True: 15.9M, False: 0]
  ------------------
  874|  15.9M|            {
  875|  15.9M|                addCreatedResource(res, *grp);
  876|  15.9M|            }
  877|  15.9M|        }
  878|       |
  879|  15.9M|        fireResourceCreated(res);
  880|  15.9M|    }
_ZNK4Ogre20ResourceGroupManager22_notifyResourceRemovedERKNS_9SharedPtrINS_8ResourceEEE:
  883|  15.9M|    {
  884|  15.9M|        fireResourceRemove(res);
  885|       |
  886|  15.9M|        if (mCurrentGroup && res->getGroup() == mCurrentGroup->name)
  ------------------
  |  Branch (886:13): [True: 15.9M, False: 0]
  |  Branch (886:30): [True: 15.9M, False: 0]
  ------------------
  887|  15.9M|        {
  888|       |            // Do nothing - we're batch unloading so list will be cleared
  889|  15.9M|        }
  890|      0|        else
  891|      0|        {
  892|       |            // Find group
  893|      0|            ResourceGroup* grp = getResourceGroup(res->getGroup());
  894|      0|            if (grp)
  ------------------
  |  Branch (894:17): [True: 0, False: 0]
  ------------------
  895|      0|            {
  896|      0|                            OGRE_LOCK_MUTEX(grp->OGRE_AUTO_MUTEX_NAME); // lock group mutex
  897|      0|                ResourceGroup::LoadResourceOrderMap::iterator i = 
  898|      0|                    grp->loadResourceOrderMap.find(
  899|      0|                        res->getCreator()->getLoadingOrder());
  900|      0|                if (i != grp->loadResourceOrderMap.end())
  ------------------
  |  Branch (900:21): [True: 0, False: 0]
  ------------------
  901|      0|                {
  902|       |                    // Iterate over the resource list and remove
  903|      0|                    LoadUnloadResourceList& resList = i->second;
  904|      0|                    for (LoadUnloadResourceList::iterator l = resList.begin();
  905|      0|                        l != resList.end(); ++ l)
  ------------------
  |  Branch (905:25): [True: 0, False: 0]
  ------------------
  906|      0|                    {
  907|      0|                        if ((*l).get() == res.get())
  ------------------
  |  Branch (907:29): [True: 0, False: 0]
  ------------------
  908|      0|                        {
  909|       |                            // this is the one
  910|      0|                            resList.erase(l);
  911|      0|                            break;
  912|      0|                        }
  913|      0|                    }
  914|      0|                }
  915|      0|            }
  916|      0|        }
  917|  15.9M|    }
_ZNK4Ogre20ResourceGroupManager18addCreatedResourceERNS_9SharedPtrINS_8ResourceEEERNS0_13ResourceGroupE:
  990|  15.9M|    {
  991|  15.9M|            OGRE_LOCK_MUTEX(grp.OGRE_AUTO_MUTEX_NAME);
  992|  15.9M|        Real order = res->getCreator()->getLoadingOrder();
  993|       |
  994|  15.9M|        ResourceGroup::LoadResourceOrderMap::iterator i = grp.loadResourceOrderMap.find(order);
  995|  15.9M|        LoadUnloadResourceList& loadList =
  996|  15.9M|            i == grp.loadResourceOrderMap.end() ? grp.loadResourceOrderMap[order] : i->second;
  ------------------
  |  Branch (996:13): [True: 13.1k, False: 15.8M]
  ------------------
  997|       |
  998|  15.9M|        loadList.push_back(res);
  999|  15.9M|    }
_ZNK4Ogre20ResourceGroupManager16getResourceGroupERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb:
 1003|  74.9M|    {
 1004|  74.9M|        OGRE_LOCK_AUTO_MUTEX;
 1005|  74.9M|        ResourceGroupMap::const_iterator i = mResourceGroupMap.find(name);
 1006|       |
 1007|  74.9M|        if (i == mResourceGroupMap.end())
  ------------------
  |  Branch (1007:13): [True: 15.8k, False: 74.9M]
  ------------------
 1008|  15.8k|        {
 1009|  15.8k|            if (throwOnFailure)
  ------------------
  |  Branch (1009:17): [True: 0, False: 15.8k]
  ------------------
 1010|  15.8k|                OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Cannot locate a resource group called '" + name + "'");
 1011|       |
 1012|  15.8k|            return nullptr;
 1013|  15.8k|        }
 1014|       |
 1015|  74.9M|        return i->second;
 1016|  74.9M|    }
_ZN4Ogre20ResourceGroupManager17dropGroupContentsEPNS0_13ResourceGroupE:
 1034|  15.8k|    {
 1035|  15.8k|            OGRE_LOCK_MUTEX(grp->OGRE_AUTO_MUTEX_NAME);
 1036|       |
 1037|  15.8k|        bool groupSet = false;
 1038|  15.8k|        if (!mCurrentGroup)
  ------------------
  |  Branch (1038:13): [True: 15.8k, False: 0]
  ------------------
 1039|  15.8k|        {
 1040|       |            // Set current group to indicate ignoring of notifications
 1041|  15.8k|            mCurrentGroup = grp;
 1042|  15.8k|            groupSet = true;
 1043|  15.8k|        }
 1044|       |        // delete all the load list entries
 1045|  15.8k|        for (auto& j : grp->loadResourceOrderMap)
  ------------------
  |  Branch (1045:22): [True: 13.1k, False: 15.8k]
  ------------------
 1046|  13.1k|        {
 1047|       |            // Iterate over resources
 1048|  13.1k|            for (auto& k : j.second)
  ------------------
  |  Branch (1048:26): [True: 15.9M, False: 13.1k]
  ------------------
 1049|  15.9M|            {
 1050|  15.9M|                k->getCreator()->remove(k);
 1051|  15.9M|            }
 1052|  13.1k|        }
 1053|  15.8k|        grp->loadResourceOrderMap.clear();
 1054|       |
 1055|  15.8k|        if (groupSet)
  ------------------
  |  Branch (1055:13): [True: 15.8k, False: 0]
  ------------------
 1056|  15.8k|        {
 1057|  15.8k|            mCurrentGroup = 0;
 1058|  15.8k|        }
 1059|  15.8k|    }
_ZN4Ogre20ResourceGroupManager11deleteGroupEPNS0_13ResourceGroupE:
 1062|  15.8k|    {
 1063|  15.8k|        {
 1064|  15.8k|            OGRE_LOCK_MUTEX(grp->OGRE_AUTO_MUTEX_NAME);
 1065|       |            // delete all the load list entries
 1066|  15.8k|            grp->loadResourceOrderMap.clear();
 1067|  15.8k|        }
 1068|       |
 1069|       |        // delete ResourceGroup
 1070|       |        OGRE_DELETE_T(grp, ResourceGroup, MEMCATEGORY_RESOURCE);
 1071|  15.8k|    }
_ZNK4Ogre20ResourceGroupManager19fireResourceCreatedERKNS_9SharedPtrINS_8ResourceEEE:
 1203|  15.9M|    {
 1204|  15.9M|        OGRE_LOCK_AUTO_MUTEX;
 1205|  15.9M|        for (auto l : mResourceGroupListenerList)
  ------------------
  |  Branch (1205:21): [True: 0, False: 15.9M]
  ------------------
 1206|      0|        {
 1207|      0|            l->resourceCreated(resource);
 1208|      0|        }
 1209|  15.9M|    }
_ZNK4Ogre20ResourceGroupManager18fireResourceRemoveERKNS_9SharedPtrINS_8ResourceEEE:
 1212|  15.9M|    {
 1213|  15.9M|        OGRE_LOCK_AUTO_MUTEX;
 1214|  15.9M|        for (auto l : mResourceGroupListenerList)
  ------------------
  |  Branch (1214:21): [True: 0, False: 15.9M]
  ------------------
 1215|      0|        {
 1216|      0|            l->resourceRemove(resource);
 1217|      0|        }
 1218|  15.9M|    }
_ZNK4Ogre20ResourceGroupManager27isResourceGroupInGlobalPoolERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1462|  58.9M|    {
 1463|  58.9M|        return getResourceGroup(name, true)->inGlobalPool;
 1464|  58.9M|    }
_ZNK4Ogre20ResourceGroupManager18getLoadingListenerEv:
 1495|  15.9M|    {
 1496|  15.9M|        return mLoadingListener;
 1497|  15.9M|    }

_ZN4Ogre15ResourceManagerC2Ev:
   35|      6|        : mNextHandle(1), mMemoryUsage(0), mVerbose(true), mLoadOrder(0)
   36|      6|    {
   37|       |        // Init memory limit & usage
   38|      6|        mMemoryBudget = std::numeric_limits<unsigned long>::max();
   39|      6|    }
_ZN4Ogre15ResourceManager14createResourceERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
   53|  15.9M|    {
   54|  15.9M|        OgreAssert(!name.empty(), "resource name must not be empty");
  ------------------
  |  Branch (54:9): [True: 10, False: 15.9M]
  ------------------
   55|       |
   56|       |        // Call creation implementation
   57|  15.9M|        ResourcePtr ret = ResourcePtr(
   58|  15.9M|            createImpl(name, getNextHandle(), group, isManual, loader, params));
   59|  15.9M|        if (params)
  ------------------
  |  Branch (59:13): [True: 0, False: 15.9M]
  ------------------
   60|      0|            ret->setParameterList(*params);
   61|       |
   62|  15.9M|        addImpl(ret);
   63|       |        // Tell resource group manager
   64|  15.9M|        if(ret)
  ------------------
  |  Branch (64:12): [True: 15.8M, False: 1.59k]
  ------------------
   65|  15.8M|            ResourceGroupManager::getSingleton()._notifyResourceCreated(ret);
   66|  15.9M|        return ret;
   67|       |
   68|  15.9M|    }
_ZN4Ogre15ResourceManager16createOrRetrieveERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE:
   75|  19.6M|    {
   76|       |        // Lock for the whole get / insert
   77|  19.6M|            OGRE_LOCK_AUTO_MUTEX;
   78|       |
   79|  19.6M|        ResourcePtr res = getResourceByName(name, group);
   80|  19.6M|        bool created = false;
   81|  19.6M|        if (!res)
  ------------------
  |  Branch (81:13): [True: 15.8M, False: 3.82M]
  ------------------
   82|  15.8M|        {
   83|  15.8M|            created = true;
   84|  15.8M|            res = createResource(name, group, isManual, loader, params);
   85|  15.8M|        }
   86|       |
   87|  19.6M|        return ResourceCreateOrRetrieveResult(res, created);
   88|  19.6M|    }
_ZN4Ogre15ResourceManager7addImplERNS_9SharedPtrINS_8ResourceEEE:
  112|  15.9M|    {
  113|  15.9M|            OGRE_LOCK_AUTO_MUTEX;
  114|       |
  115|  15.9M|            std::pair<ResourceMap::iterator, bool> result;
  116|  15.9M|        if(ResourceGroupManager::getSingleton().isResourceGroupInGlobalPool(res->getGroup()))
  ------------------
  |  Branch (116:12): [True: 3, False: 15.9M]
  ------------------
  117|      3|        {
  118|      3|            result = mResources.emplace(res->getName(), res);
  119|      3|        }
  120|  15.9M|        else
  121|  15.9M|        {
  122|       |            // we will create the group if it doesn't exists in our list
  123|  15.9M|            auto resgroup = mResourcesWithGroup.emplace(res->getGroup(), ResourceMap()).first;
  124|  15.9M|            result = resgroup->second.emplace(res->getName(), res);
  125|  15.9M|        }
  126|       |
  127|       |        // Attempt to resolve the collision
  128|  15.9M|        ResourceLoadingListener* listener = ResourceGroupManager::getSingleton().getLoadingListener();
  129|  15.9M|        if (!result.second && listener)
  ------------------
  |  Branch (129:13): [True: 1.79k, False: 15.9M]
  |  Branch (129:31): [True: 0, False: 1.79k]
  ------------------
  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|  15.9M|        if (!result.second)
  ------------------
  |  Branch (150:13): [True: 1.79k, False: 15.9M]
  ------------------
  151|  1.79k|        {
  152|  1.79k|            OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, getResourceType()+" with the name " + res->getName() +
  153|  1.79k|                " already exists.", "ResourceManager::add");
  154|  1.79k|        }
  155|       |
  156|       |        // Insert the handle
  157|  15.9M|        std::pair<ResourceHandleMap::iterator, bool> resultHandle = mResourcesByHandle.emplace(res->getHandle(), res);
  158|  15.9M|        if (!resultHandle.second)
  ------------------
  |  Branch (158:13): [True: 0, False: 15.9M]
  ------------------
  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|  15.9M|    }
_ZN4Ogre15ResourceManager10removeImplERKNS_9SharedPtrINS_8ResourceEEE:
  167|  15.9M|    {
  168|  15.9M|        OgreAssert(res, "attempting to remove nullptr");
  ------------------
  |  Branch (168:9): [True: 0, False: 15.9M]
  ------------------
  169|       |
  170|  15.9M|#if OGRE_RESOURCEMANAGER_STRICT
  171|  15.9M|        if (res->getCreator() != this)
  ------------------
  |  Branch (171:13): [True: 0, False: 15.9M]
  ------------------
  172|  15.9M|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Resource '" + res->getName() + "' was not created by the '" +
  173|  15.9M|                                                          getResourceType() + "' ResourceManager");
  174|  15.9M|#endif
  175|       |
  176|  15.9M|        OGRE_LOCK_AUTO_MUTEX;
  177|       |
  178|  15.9M|        if(ResourceGroupManager::getSingleton().isResourceGroupInGlobalPool(res->getGroup()))
  ------------------
  |  Branch (178:12): [True: 0, False: 15.9M]
  ------------------
  179|      0|        {
  180|      0|            ResourceMap::iterator nameIt = mResources.find(res->getName());
  181|      0|            if (nameIt != mResources.end())
  ------------------
  |  Branch (181:17): [True: 0, False: 0]
  ------------------
  182|      0|            {
  183|      0|                mResources.erase(nameIt);
  184|      0|            }
  185|      0|        }
  186|  15.9M|        else
  187|  15.9M|        {
  188|  15.9M|            ResourceWithGroupMap::iterator groupIt = mResourcesWithGroup.find(res->getGroup());
  189|  15.9M|            if (groupIt != mResourcesWithGroup.end())
  ------------------
  |  Branch (189:17): [True: 15.9M, False: 0]
  ------------------
  190|  15.9M|            {
  191|  15.9M|                ResourceMap::iterator nameIt = groupIt->second.find(res->getName());
  192|  15.9M|                if (nameIt != groupIt->second.end())
  ------------------
  |  Branch (192:21): [True: 15.9M, False: 0]
  ------------------
  193|  15.9M|                {
  194|  15.9M|                    groupIt->second.erase(nameIt);
  195|  15.9M|                }
  196|       |
  197|  15.9M|                if (groupIt->second.empty())
  ------------------
  |  Branch (197:21): [True: 13.1k, False: 15.8M]
  ------------------
  198|  13.1k|                {
  199|  13.1k|                    mResourcesWithGroup.erase(groupIt);
  200|  13.1k|                }
  201|  15.9M|            }
  202|  15.9M|        }
  203|       |
  204|  15.9M|        ResourceHandleMap::iterator handleIt = mResourcesByHandle.find(res->getHandle());
  205|  15.9M|        if (handleIt != mResourcesByHandle.end())
  ------------------
  |  Branch (205:13): [True: 15.9M, False: 0]
  ------------------
  206|  15.9M|        {
  207|  15.9M|            mResourcesByHandle.erase(handleIt);
  208|  15.9M|        }
  209|       |        // Tell resource group manager
  210|  15.9M|        ResourceGroupManager::getSingleton()._notifyResourceRemoved(res);
  211|  15.9M|    }
_ZN4Ogre15ResourceManager6removeERKNS_9SharedPtrINS_8ResourceEEE:
  298|  15.9M|    {
  299|  15.9M|        removeImpl(res);
  300|  15.9M|    }
_ZNK4Ogre15ResourceManager17getResourceByNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
  368|  27.1M|    {
  369|  27.1M|        OGRE_LOCK_AUTO_MUTEX;
  370|       |
  371|       |        // resource should be in global pool
  372|  27.1M|        bool isGlobal = ResourceGroupManager::getSingleton().isResourceGroupInGlobalPool(groupName);
  373|       |
  374|  27.1M|        if(isGlobal)
  ------------------
  |  Branch (374:12): [True: 3.69M, False: 23.4M]
  ------------------
  375|  3.69M|        {
  376|  3.69M|            auto it = mResources.find(name);
  377|  3.69M|            if( it != mResources.end())
  ------------------
  |  Branch (377:17): [True: 14, False: 3.69M]
  ------------------
  378|     14|            {
  379|     14|                return it->second;
  380|     14|            }
  381|  3.69M|        }
  382|       |
  383|       |        // look in all grouped pools
  384|  27.1M|        if (groupName == ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME)
  ------------------
  |  Branch (384:13): [True: 3.69M, False: 23.4M]
  ------------------
  385|  3.69M|        {
  386|  3.69M|            for (auto& r : mResourcesWithGroup)
  ------------------
  |  Branch (386:26): [True: 3.68M, False: 3.69M]
  ------------------
  387|  3.68M|            {
  388|  3.68M|                auto resMapIt = r.second.find(name);
  389|       |
  390|  3.68M|                if( resMapIt != r.second.end())
  ------------------
  |  Branch (390:21): [True: 1.99k, False: 3.68M]
  ------------------
  391|  1.99k|                {
  392|  1.99k|                    return resMapIt->second;
  393|  1.99k|                }
  394|  3.68M|            }
  395|  3.69M|        }
  396|  23.4M|        else if (!isGlobal)
  ------------------
  |  Branch (396:18): [True: 23.4M, False: 0]
  ------------------
  397|  23.4M|        {
  398|       |            // look in the grouped pool
  399|  23.4M|            auto itGroup = mResourcesWithGroup.find(groupName);
  400|  23.4M|            if (itGroup != mResourcesWithGroup.end())
  ------------------
  |  Branch (400:17): [True: 23.4M, False: 11.7k]
  ------------------
  401|  23.4M|            {
  402|  23.4M|                auto it = itGroup->second.find(name);
  403|       |
  404|  23.4M|                if( it != itGroup->second.end())
  ------------------
  |  Branch (404:21): [True: 3.92M, False: 19.5M]
  ------------------
  405|  3.92M|                {
  406|  3.92M|                    return it->second;
  407|  3.92M|                }
  408|  23.4M|            }
  409|       |
  410|       |#if !OGRE_RESOURCEMANAGER_STRICT
  411|       |            // fall back to global
  412|       |            auto it = mResources.find(name);
  413|       |            if( it != mResources.end())
  414|       |            {
  415|       |                return it->second;
  416|       |            }
  417|       |#endif
  418|  23.4M|        }
  419|       |    
  420|  23.2M|        return ResourcePtr();
  421|  27.1M|    }
_ZN4Ogre15ResourceManager13getNextHandleEv:
  431|  15.9M|    {
  432|       |        // This is an atomic operation and hence needs no locking
  433|  15.9M|        return mNextHandle++;
  434|  15.9M|    }

_ZNK4Ogre18RibbonTrailFactory7getTypeEv:
  433|      3|    {
  434|      3|        return MOT_RIBBON_TRAIL;
  435|      3|    }

_ZN4Ogre4Root15getSingletonPtrEv:
   86|     14|    {
   87|     14|        return msSingleton;
   88|     14|    }
_ZN4Ogre4Root12getSingletonEv:
   90|  27.6k|    {
   91|       |        assert( msSingleton );  return ( *msSingleton );
   92|  27.6k|    }
_ZN4Ogre4RootC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_S9_:
  100|      1|      : mQueuedEnd(false)
  101|      1|      , mCurrentSceneManager(NULL)
  102|      1|      , mNextFrame(1)
  103|      1|      , mFrameSmoothingTime(0.0f)
  104|      1|      , mRemoveQueueStructuresOnClear(false)
  105|      1|      , mDefaultMinPixelSize(0)
  106|      1|      , mNextMovableObjectTypeFlag(1)
  107|      1|      , mIsInitialised(false)
  108|      1|      , mIsBlendIndicesGpuRedundant(true)
  109|      1|      , mIsBlendWeightsGpuRedundant(true)
  110|      1|    {
  111|       |        // superclass will do singleton checking
  112|       |
  113|       |        // Init
  114|      1|        mActiveRenderer = 0;
  115|      1|        mVersion = StringConverter::toString(OGRE_VERSION_MAJOR) + "." +
  116|      1|            StringConverter::toString(OGRE_VERSION_MINOR) + "." +
  117|      1|            StringConverter::toString(OGRE_VERSION_PATCH) +
  118|      1|            OGRE_VERSION_SUFFIX + " " +
  119|      1|            "(" + OGRE_VERSION_NAME + ")";
  120|      1|        mConfigFileName = configFileName;
  121|       |
  122|       |        // Create log manager and default log file if there is no log manager yet
  123|      1|        if(!LogManager::getSingletonPtr())
  ------------------
  |  Branch (123:12): [True: 0, False: 1]
  ------------------
  124|      0|        {
  125|      0|            mLogManager = std::make_unique<LogManager>();
  126|       |
  127|       |#if OGRE_PLATFORM == OGRE_PLATFORM_EMSCRIPTEN
  128|       |            // suppress writing log to Emscripten virtual FS, improves performance
  129|       |            mLogManager->createLog(logFileName, true, true, true);
  130|       |#else
  131|      0|            mLogManager->createLog(logFileName, true, true);
  132|      0|#endif
  133|       |
  134|       |#if OGRE_PLATFORM == OGRE_PLATFORM_ANDROID
  135|       |            mAndroidLogger.reset(new AndroidLogListener());
  136|       |            mLogManager->getDefaultLog()->addListener(mAndroidLogger.get());
  137|       |#endif
  138|      0|        }
  139|       |
  140|      1|        mDynLibManager = std::make_unique<DynLibManager>();
  141|      1|        mArchiveManager = std::make_unique<ArchiveManager>();
  142|      1|        mResourceGroupManager = std::make_unique<ResourceGroupManager>();
  143|       |
  144|       |        // WorkQueue (note: users can replace this if they want)
  145|      1|        DefaultWorkQueue* defaultQ = OGRE_NEW DefaultWorkQueue("Root");
  146|       |        // match threads to hardware
  147|      1|        int threadCount = OGRE_THREAD_HARDWARE_CONCURRENCY;
  148|       |        // but clamp it at 2 by default - we dont scale much beyond that currently
  149|       |        // yet it helps on android where it needlessly burns CPU
  150|      1|        threadCount = Math::Clamp(threadCount, 1, 2);
  151|      1|        defaultQ->setWorkerThreadCount(threadCount);
  152|       |
  153|       |        // only allow workers to access rendersystem if threadsupport is 1
  154|      1|        defaultQ->setWorkersCanAccessRenderSystem(OGRE_THREAD_SUPPORT == 1);
  155|      1|        mWorkQueue.reset(defaultQ);
  156|       |
  157|       |        // ResourceBackgroundQueue
  158|      1|        mResourceBackgroundQueue = std::make_unique<ResourceBackgroundQueue>();
  159|       |
  160|       |        // Create SceneManager enumerator (note - will be managed by singleton)
  161|      1|        mSceneManagerEnum = std::make_unique<SceneManagerEnumerator>();
  162|      1|        mShadowTextureManager = std::make_unique<ShadowTextureManager>();
  163|      1|        mRenderSystemCapabilitiesManager = std::make_unique<RenderSystemCapabilitiesManager>();
  164|      1|        mMaterialManager = std::make_unique<MaterialManager>();
  165|      1|        mMeshManager = std::make_unique<MeshManager>();
  166|      1|        mSkeletonManager = std::make_unique<SkeletonManager>();
  167|      1|        mParticleManager = std::make_unique<ParticleSystemManager>();
  168|      1|        mTimer = std::make_unique<Timer>();
  169|      1|        mLodStrategyManager = std::make_unique<LodStrategyManager>();
  170|       |
  171|       |#if OGRE_PROFILING
  172|       |        // Profiler
  173|       |        mProfiler.reset(new Profiler());
  174|       |        Profiler::getSingleton().setTimer(mTimer.get());
  175|       |#endif
  176|       |
  177|       |
  178|      1|        mFileSystemArchiveFactory = std::make_unique<FileSystemArchiveFactory>();
  179|      1|        ArchiveManager::getSingleton().addArchiveFactory( mFileSystemArchiveFactory.get() );
  180|      1|#   if OGRE_NO_ZIP_ARCHIVE == 0
  181|      1|        mZipArchiveFactory = std::make_unique<ZipArchiveFactory>();
  182|      1|        ArchiveManager::getSingleton().addArchiveFactory( mZipArchiveFactory.get() );
  183|      1|        mEmbeddedZipArchiveFactory = std::make_unique<EmbeddedZipArchiveFactory>();
  184|      1|        ArchiveManager::getSingleton().addArchiveFactory( mEmbeddedZipArchiveFactory.get() );
  185|      1|#   endif
  186|       |
  187|      1|#if OGRE_NO_DDS_CODEC == 0
  188|       |        // Register image codecs
  189|      1|        DDSCodec::startup();
  190|      1|#endif
  191|      1|#if OGRE_NO_PVRTC_CODEC == 0
  192|      1|        PVRTCCodec::startup();
  193|      1|#endif
  194|      1|#if OGRE_NO_ETC_CODEC == 0
  195|      1|        ETCCodec::startup();
  196|      1|#endif
  197|      1|#if OGRE_NO_ASTC_CODEC == 0
  198|      1|        ASTCCodec::startup();
  199|      1|#endif
  200|       |
  201|      1|        mGpuProgramManager = std::make_unique<GpuProgramManager>();
  202|      1|        mExternalTextureSourceManager = std::make_unique<ExternalTextureSourceManager>();
  203|      1|        mCompositorManager = std::make_unique<CompositorManager>();
  204|      1|        mCompilerManager = std::make_unique<ScriptCompilerManager>();
  205|       |
  206|       |        // Auto window
  207|      1|        mAutoWindow = 0;
  208|       |
  209|       |        // instantiate and register base movable factories
  210|      1|        mEntityFactory = std::make_unique<EntityFactory>();
  211|      1|        addMovableObjectFactory(mEntityFactory.get());
  212|      1|        mLightFactory = std::make_unique<LightFactory>();
  213|      1|        addMovableObjectFactory(mLightFactory.get());
  214|      1|        mBillboardSetFactory = std::make_unique<BillboardSetFactory>();
  215|      1|        addMovableObjectFactory(mBillboardSetFactory.get());
  216|      1|        mManualObjectFactory = std::make_unique<ManualObjectFactory>();
  217|      1|        addMovableObjectFactory(mManualObjectFactory.get());
  218|      1|        mBillboardChainFactory = std::make_unique<BillboardChainFactory>();
  219|      1|        addMovableObjectFactory(mBillboardChainFactory.get());
  220|      1|        mRibbonTrailFactory = std::make_unique<RibbonTrailFactory>();
  221|      1|        addMovableObjectFactory(mRibbonTrailFactory.get());
  222|      1|        mStaticGeometryFactory = std::make_unique<StaticGeometryFactory>();
  223|      1|        addMovableObjectFactory(mStaticGeometryFactory.get());
  224|      1|        mRectangle2DFactory = std::make_unique<Rectangle2DFactory>();
  225|      1|        addMovableObjectFactory(mRectangle2DFactory.get());
  226|       |
  227|       |        // Load plugins
  228|      1|        if (!pluginFileName.empty())
  ------------------
  |  Branch (228:13): [True: 0, False: 1]
  ------------------
  229|      0|            loadPlugins(pluginFileName);
  230|       |
  231|      1|        LogManager::getSingleton().logMessage("*-*-* OGRE Initialising");
  232|      1|        LogManager::getSingleton().logMessage("*-*-* Version " + mVersion);
  233|       |
  234|       |        // Can't create managers until initialised
  235|      1|        mControllerManager = 0;
  236|       |
  237|      1|        mFirstTimePostWindowInit = false;
  238|      1|    }
_ZN4Ogre4Root15getRenderSystemEv:
  485|  27.5k|    {
  486|       |        // Gets the currently active renderer
  487|  27.5k|        return mActiveRenderer;
  488|       |
  489|  27.5k|    }
_ZN4Ogre4Root23addMovableObjectFactoryEPNS_20MovableObjectFactoryEb:
 1166|      9|    {
 1167|      9|        MovableObjectFactoryMap::iterator facti = mMovableObjectFactoryMap.find(
 1168|      9|            fact->getType());
 1169|      9|        if (!overrideExisting && facti != mMovableObjectFactoryMap.end())
  ------------------
  |  Branch (1169:13): [True: 9, False: 0]
  |  Branch (1169:13): [True: 0, False: 9]
  |  Branch (1169:34): [True: 0, False: 9]
  ------------------
 1170|      0|        {
 1171|      0|            OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM,
 1172|      0|                "A factory of type '" + fact->getType() + "' already exists.",
 1173|      0|                "Root::addMovableObjectFactory");
 1174|      0|        }
 1175|       |
 1176|      9|        if (fact->requestTypeFlags())
  ------------------
  |  Branch (1176:13): [True: 0, False: 9]
  ------------------
 1177|      0|        {
 1178|      0|            if (facti != mMovableObjectFactoryMap.end() && facti->second->requestTypeFlags())
  ------------------
  |  Branch (1178:17): [True: 0, False: 0]
  |  Branch (1178:17): [True: 0, False: 0]
  |  Branch (1178:60): [True: 0, False: 0]
  ------------------
 1179|      0|            {
 1180|       |                // Copy type flags from the factory we're replacing
 1181|      0|                fact->_notifyTypeFlags(facti->second->getTypeFlags());
 1182|      0|            }
 1183|      0|            else
 1184|      0|            {
 1185|       |                // Allocate new
 1186|      0|                fact->_notifyTypeFlags(_allocateNextMovableObjectTypeFlag());
 1187|      0|            }
 1188|      0|        }
 1189|       |
 1190|       |        // Save
 1191|      9|        mMovableObjectFactoryMap[fact->getType()] = fact;
 1192|       |
 1193|      9|        LogManager::getSingleton().logMessage("MovableObjectFactory for type '" +
 1194|      9|            fact->getType() + "' registered.");
 1195|       |
 1196|      9|    }

_ZN4Ogre22SceneManagerEnumeratorC2Ev:
   47|      1|        : mInstanceCreateCount(0), mCurrentRenderSystem(0)
   48|      1|    {
   49|      1|        addFactory(&mDefaultFactory);
   50|       |
   51|      1|    }
_ZN4Ogre22SceneManagerEnumerator10addFactoryEPNS_19SceneManagerFactoryE:
   75|      1|    {
   76|      1|        mFactories[fact->getTypeName()] = fact;
   77|       |        // add to metadata
   78|      1|        mMetaDataList.push_back(fact->getTypeName());
   79|       |        // Log
   80|      1|        LogManager::getSingleton().logMessage("SceneManagerFactory for type '" + fact->getTypeName() + "' registered.");
   81|      1|    }

_ZN4Ogre26DefaultSceneManagerFactoryC2Ev:
   49|      1|        DefaultSceneManagerFactory() {}
_ZNK4Ogre26DefaultSceneManagerFactory11getTypeNameEv:
   52|      3|        const String& getTypeName(void) const override { return SMT_DEFAULT; }

_ZN4Ogre12AbstractNodeC2EPS0_:
   40|  16.2M|        :line(0), type(ANT_UNKNOWN), parent(ptr)
   41|  16.2M|    {}
_ZN4Ogre16AtomAbstractNodeC2EPNS_12AbstractNodeE:
   45|  11.0M|        :AbstractNode(ptr), id(0)
   46|  11.0M|    {
   47|  11.0M|        type = ANT_ATOM;
   48|  11.0M|    }
_ZNK4Ogre16AtomAbstractNode5cloneEv:
   51|  6.23M|    {
   52|       |        AtomAbstractNode *node = OGRE_NEW AtomAbstractNode(parent);
   53|  6.23M|        node->file = file;
   54|  6.23M|        node->line = line;
   55|  6.23M|        node->id = id;
   56|  6.23M|        node->type = type;
   57|  6.23M|        node->value = value;
   58|  6.23M|        return node;
   59|  6.23M|    }
_ZN4Ogre18ObjectAbstractNodeC2EPNS_12AbstractNodeE:
   63|   804k|        :AbstractNode(ptr), id(0), abstract(false)
   64|   804k|    {
   65|   804k|        type = ANT_OBJECT;
   66|   804k|    }
_ZNK4Ogre18ObjectAbstractNode5cloneEv:
   69|   689k|    {
   70|   689k|        ObjectAbstractNode *node = OGRE_NEW ObjectAbstractNode(parent);
   71|   689k|        node->file = file;
   72|   689k|        node->line = line;
   73|   689k|        node->type = type;
   74|   689k|        node->name = name;
   75|   689k|        node->cls = cls;
   76|   689k|        node->id = id;
   77|   689k|        node->abstract = abstract;
   78|   689k|        for(const auto & i : children)
  ------------------
  |  Branch (78:28): [True: 1.40M, False: 689k]
  ------------------
   79|  1.40M|        {
   80|  1.40M|            AbstractNodePtr newNode = AbstractNodePtr(i->clone());
   81|  1.40M|            newNode->parent = node;
   82|  1.40M|            node->children.push_back(newNode);
   83|  1.40M|        }
   84|   689k|        for(const auto & value : values)
  ------------------
  |  Branch (84:32): [True: 338k, False: 689k]
  ------------------
   85|   338k|        {
   86|   338k|            AbstractNodePtr newNode = AbstractNodePtr(value->clone());
   87|   338k|            newNode->parent = node;
   88|   338k|            node->values.push_back(newNode);
   89|   338k|        }
   90|   689k|        node->mEnv = mEnv;
   91|   689k|        return node;
   92|   689k|    }
_ZN4Ogre18ObjectAbstractNode11setVariableERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
  100|  6.37k|    {
  101|  6.37k|        mEnv[inName] = value;
  102|  6.37k|    }
_ZNK4Ogre18ObjectAbstractNode11getVariableERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  105|  1.16M|    {
  106|  1.16M|        std::map<String,String>::const_iterator i = mEnv.find(inName);
  107|  1.16M|        if(i != mEnv.end())
  ------------------
  |  Branch (107:12): [True: 332k, False: 835k]
  ------------------
  108|   332k|            return std::make_pair(true, i->second);
  109|       |
  110|   835k|        auto parentNode = this->parent;
  111|  2.45M|        while(parentNode && parentNode->type == ANT_OBJECT)
  ------------------
  |  Branch (111:15): [True: 1.86M, False: 583k]
  |  Branch (111:29): [True: 1.86M, False: 725]
  ------------------
  112|  1.86M|        {
  113|  1.86M|            ObjectAbstractNode *parentObj = (ObjectAbstractNode*)parentNode;
  114|  1.86M|            i = parentObj->mEnv.find(inName);
  115|  1.86M|            if(i != parentObj->mEnv.end())
  ------------------
  |  Branch (115:16): [True: 251k, False: 1.61M]
  ------------------
  116|   251k|                return std::make_pair(true, i->second);
  117|  1.61M|            parentNode = parentNode->parent;
  118|  1.61M|        }
  119|   584k|        return std::make_pair(false, "");
  120|   835k|    }
_ZNK4Ogre18ObjectAbstractNode12getVariablesEv:
  123|   797k|    {
  124|   797k|        return mEnv;
  125|   797k|    }
_ZN4Ogre20PropertyAbstractNodeC2EPNS_12AbstractNodeE:
  129|  2.60M|        :AbstractNode(ptr), id(0)
  130|  2.60M|    {
  131|  2.60M|        type = ANT_PROPERTY;
  132|  2.60M|    }
_ZNK4Ogre20PropertyAbstractNode5cloneEv:
  135|  2.32M|    {
  136|  2.32M|        PropertyAbstractNode *node = OGRE_NEW PropertyAbstractNode(parent);
  137|  2.32M|        node->file = file;
  138|  2.32M|        node->line = line;
  139|  2.32M|        node->type = type;
  140|  2.32M|        node->name = name;
  141|  2.32M|        node->id = id;
  142|  2.32M|        for(const auto & value : values)
  ------------------
  |  Branch (142:32): [True: 5.51M, False: 2.32M]
  ------------------
  143|  5.51M|        {
  144|  5.51M|            AbstractNodePtr newNode = AbstractNodePtr(value->clone());
  145|  5.51M|            newNode->parent = node;
  146|  5.51M|            node->values.push_back(newNode);
  147|  5.51M|        }
  148|  2.32M|        return node;
  149|  2.32M|    }
_ZN4Ogre18ImportAbstractNodeC2Ev:
  153|  9.45k|        :AbstractNode(0)
  154|  9.45k|    {
  155|  9.45k|        type = ANT_IMPORT;
  156|  9.45k|    }
_ZN4Ogre26VariableAccessAbstractNodeC2EPNS_12AbstractNodeE:
  171|  1.79M|        :AbstractNode(ptr)
  172|  1.79M|    {
  173|  1.79M|        type = ANT_VARIABLE_ACCESS;
  174|  1.79M|    }
_ZNK4Ogre26VariableAccessAbstractNode5cloneEv:
  177|   139k|    {
  178|       |        VariableAccessAbstractNode *node = OGRE_NEW VariableAccessAbstractNode(parent);
  179|   139k|        node->file = file;
  180|   139k|        node->line = line;
  181|   139k|        node->type = type;
  182|   139k|        node->name = name;
  183|   139k|        return node;
  184|   139k|    }
_ZN4Ogre22ScriptCompilerListenerC2Ev:
  188|      1|    {
  189|      1|    }
_ZN4Ogre22ScriptCompilerListener13preConversionEPNS_14ScriptCompilerENS_9SharedPtrINSt3__14listINS3_INS_12ConcreteNodeEEENS4_9allocatorIS7_EEEEEE:
  197|  15.8k|    {
  198|       |
  199|  15.8k|    }
_ZN4Ogre22ScriptCompilerListener14postConversionEPNS_14ScriptCompilerERKNS_9SharedPtrINSt3__14listINS3_INS_12AbstractNodeEEENS4_9allocatorIS7_EEEEEE:
  202|  15.7k|    {
  203|  15.7k|        return true;
  204|  15.7k|    }
_ZN4Ogre22ScriptCompilerListener11handleEventEPNS_14ScriptCompilerEPNS_19ScriptCompilerEventEPv:
  220|   352k|    {
  221|   352k|        return false;
  222|   352k|    }
_ZN4Ogre14ScriptCompilerC2Ev:
  261|      1|        :mListener(0)
  262|      1|    {
  263|      1|        initWordMap();
  264|      1|    }
_ZN4Ogre14ScriptCompiler7compileERKNS_9SharedPtrINSt3__14listINS1_INS_12ConcreteNodeEEENS2_9allocatorIS5_EEEEEERKNS2_12basic_stringIcNS2_11char_traitsIcEENS6_IcEEEE:
  327|  15.8k|    {
  328|  15.8k|        if(nodes && !nodes->empty())
  ------------------
  |  Branch (328:12): [True: 15.8k, False: 0]
  |  Branch (328:21): [True: 15.5k, False: 259]
  ------------------
  329|  15.5k|        {
  330|  15.5k|            mSourceFile = nodes->front()->file;
  331|  15.5k|        }
  332|       |
  333|       |        // Set up the compilation context
  334|  15.8k|        mGroup = group;
  335|       |
  336|       |        // Clear the past errors
  337|  15.8k|        mErrors.clear();
  338|       |
  339|       |        // Clear the environment
  340|  15.8k|        mEnv.clear();
  341|       |
  342|  15.8k|        if(mListener)
  ------------------
  |  Branch (342:12): [True: 15.8k, False: 0]
  ------------------
  343|  15.8k|            mListener->preConversion(this, nodes);
  344|       |
  345|       |        // Convert our nodes to an AST
  346|  15.8k|        AbstractNodeListPtr ast = convertToAST(*nodes);
  347|       |        // Processes the imports for this script
  348|  15.8k|        processImports(*ast);
  349|       |        // Process object inheritance
  350|  15.8k|        processObjects(*ast, *ast);
  351|       |        // Process variable expansion
  352|  15.8k|        std::set<String> expadingVars;
  353|  15.8k|        processVariables(*ast, expadingVars);
  354|       |
  355|       |        // Allows early bail-out through the listener
  356|  15.8k|        if(mListener && !mListener->postConversion(this, ast))
  ------------------
  |  Branch (356:12): [True: 15.7k, False: 23]
  |  Branch (356:25): [True: 0, False: 15.7k]
  ------------------
  357|      0|            return mErrors.empty();
  358|       |
  359|       |        // Translate the nodes
  360|  15.8k|        for(auto & i : *ast)
  ------------------
  |  Branch (360:22): [True: 83.1k, False: 15.8k]
  ------------------
  361|  83.1k|        {
  362|       |#if DEBUG_AST
  363|       |            logAST(0, i);
  364|       |#endif
  365|  83.1k|            if(i->type == ANT_OBJECT && static_cast<ObjectAbstractNode*>(i.get())->abstract)
  ------------------
  |  Branch (365:16): [True: 26.9k, False: 56.1k]
  |  Branch (365:41): [True: 732, False: 26.1k]
  ------------------
  366|    732|                continue;
  367|       |            //LogManager::getSingleton().logMessage(static_cast<ObjectAbstractNode*>((*i).get())->name);
  368|  82.3k|            ScriptTranslator *translator = ScriptCompilerManager::getSingleton().getTranslator(i);
  369|  82.3k|            if(translator)
  ------------------
  |  Branch (369:16): [True: 18.3k, False: 63.9k]
  ------------------
  370|  18.3k|                translator->translate(this, i);
  371|  82.3k|        }
  372|       |
  373|  15.8k|        mImports.clear();
  374|  15.8k|        mImportRequests.clear();
  375|  15.8k|        mImportTable.clear();
  376|  15.8k|        mSourceFile.clear();
  377|       |
  378|  15.8k|        return mErrors.empty();
  379|  15.8k|    }
_ZN4Ogre14ScriptCompiler8addErrorEjRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiS9_:
  382|  13.8M|    {
  383|  13.8M|        if(mListener)
  ------------------
  |  Branch (383:12): [True: 13.8M, False: 0]
  ------------------
  384|  13.8M|        {
  385|  13.8M|            mListener->handleError(this, code, file, line, msg);
  386|  13.8M|        }
  387|      0|        else
  388|      0|        {
  389|      0|            static ScriptCompilerListener defaultListener;
  390|      0|            defaultListener.handleError(this, code, file, line, msg);
  391|      0|        }
  392|       |
  393|  13.8M|        mErrors.push_back({file, msg, line, code});
  394|  13.8M|    }
_ZN4Ogre14ScriptCompiler8addErrorERKNS_12AbstractNodeERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEj:
  397|   361k|    {
  398|   361k|        addError(code, mSourceFile, node.line, msg);
  399|   361k|    }
_ZN4Ogre14ScriptCompiler11setListenerEPNS_22ScriptCompilerListenerE:
  402|      1|    {
  403|      1|        mListener = listener;
  404|      1|    }
_ZN4Ogre14ScriptCompiler11getListenerEv:
  407|  8.75k|    {
  408|  8.75k|        return mListener;
  409|  8.75k|    }
_ZNK4Ogre14ScriptCompiler16getResourceGroupEv:
  412|   110k|    {
  413|   110k|        return mGroup;
  414|   110k|    }
_ZN4Ogre14ScriptCompiler10_fireEventEPNS_19ScriptCompilerEventEPv:
  417|   352k|    {
  418|   352k|        if(mListener)
  ------------------
  |  Branch (418:12): [True: 352k, False: 0]
  ------------------
  419|   352k|            return mListener->handleEvent(this, evt, retval);
  420|      0|        return false;
  421|   352k|    }
_ZN4Ogre14ScriptCompiler12convertToASTERKNSt3__14listINS_9SharedPtrINS_12ConcreteNodeEEENS1_9allocatorIS5_EEEE:
  424|   561k|    {
  425|   561k|        AbstractTreeBuilder builder(this);
  426|   561k|        AbstractTreeBuilder::visit(&builder, nodes);
  427|   561k|        return builder.getResult();
  428|   561k|    }
_ZN4Ogre14ScriptCompiler14processImportsERNSt3__14listINS_9SharedPtrINS_12AbstractNodeEEENS1_9allocatorIS5_EEEE:
  431|  15.8k|    {
  432|       |        // We only need to iterate over the top-level of nodes
  433|  15.8k|        AbstractNodeList::iterator i = nodes.begin();
  434|   114k|        while(i != nodes.end())
  ------------------
  |  Branch (434:15): [True: 98.5k, False: 15.8k]
  ------------------
  435|  98.5k|        {
  436|       |            // We move to the next node here and save the current one.
  437|       |            // If any replacement happens, then we are still assured that
  438|       |            // i points to the node *after* the replaced nodes, no matter
  439|       |            // how many insertions and deletions may happen
  440|  98.5k|            AbstractNodeList::iterator cur = i++;
  441|  98.5k|            if((*cur)->type == ANT_IMPORT)
  ------------------
  |  Branch (441:16): [True: 9.45k, False: 89.0k]
  ------------------
  442|  9.45k|            {
  443|  9.45k|                ImportAbstractNode *import = (ImportAbstractNode*)(*cur).get();
  444|       |                // Only process if the file's contents haven't been loaded
  445|  9.45k|                if(mImports.find(import->source) == mImports.end())
  ------------------
  |  Branch (445:20): [True: 9.45k, False: 0]
  ------------------
  446|  9.45k|                {
  447|       |                    // Load the script
  448|  9.45k|                    AbstractNodeListPtr importedNodes = loadImportPath(import->source);
  449|  9.45k|                    if(importedNodes && !importedNodes->empty())
  ------------------
  |  Branch (449:24): [True: 9.45k, False: 0]
  |  Branch (449:41): [True: 0, False: 9.45k]
  ------------------
  450|      0|                    {
  451|      0|                        processImports(*importedNodes);
  452|      0|                        processObjects(*importedNodes, *importedNodes);
  453|      0|                    }
  454|  9.45k|                    else
  455|  9.45k|                    {
  456|  9.45k|                        addError(CE_REFERENCETOANONEXISTINGOBJECT, import->file, import->line, import->source);
  457|  9.45k|                    }
  458|       |
  459|  9.45k|                    if(importedNodes && !importedNodes->empty())
  ------------------
  |  Branch (459:24): [True: 9.45k, False: 0]
  |  Branch (459:41): [True: 0, False: 9.45k]
  ------------------
  460|      0|                        mImports.insert(std::make_pair(import->source, importedNodes));
  461|  9.45k|                }
  462|       |
  463|  9.45k|                ImportRequestMap::iterator iter = mImportRequests.lower_bound(import->source),
  464|  9.45k|                                           end = mImportRequests.upper_bound(import->source);
  465|       |                // Handle the target request now
  466|       |                // If it is a '*' import we remove all previous requests and just use the '*'
  467|       |                // Otherwise, ensure '*' isn't already registered and register our request
  468|  9.45k|                if(import->target == "*")
  ------------------
  |  Branch (468:20): [True: 4.27k, False: 5.18k]
  ------------------
  469|  4.27k|                {
  470|  4.27k|                    mImportRequests.erase(iter, end);
  471|  4.27k|                    mImportRequests.insert(std::make_pair(import->source, "*"));
  472|  4.27k|                }
  473|  5.18k|                else
  474|  5.18k|                {
  475|  5.18k|                    if(iter == end || iter->second != "*")
  ------------------
  |  Branch (475:24): [True: 943, False: 4.24k]
  |  Branch (475:39): [True: 4.01k, False: 232]
  ------------------
  476|  4.95k|                    {
  477|  4.95k|                        mImportRequests.insert(std::make_pair(import->source, import->target));
  478|  4.95k|                    }
  479|  5.18k|                }
  480|       |
  481|  9.45k|                nodes.erase(cur);
  482|  9.45k|            }
  483|  98.5k|        }
  484|       |
  485|       |        // All import nodes are removed
  486|       |        // We have cached the code blocks from all the imported scripts
  487|       |        // We can process all import requests now
  488|  15.8k|        for(auto & import : mImports)
  ------------------
  |  Branch (488:27): [True: 0, False: 15.8k]
  ------------------
  489|      0|        {
  490|      0|            ImportRequestMap::iterator j = mImportRequests.lower_bound(import.first),
  491|      0|                end = mImportRequests.upper_bound(import.first);
  492|      0|            if(j != end)
  ------------------
  |  Branch (492:16): [True: 0, False: 0]
  ------------------
  493|      0|            {
  494|      0|                if(j->second == "*")
  ------------------
  |  Branch (494:20): [True: 0, False: 0]
  ------------------
  495|      0|                {
  496|       |                    // Insert the entire AST into the import table
  497|      0|                    mImportTable.insert(mImportTable.begin(), import.second->begin(), import.second->end());
  498|      0|                    continue; // Skip ahead to the next file
  499|      0|                }
  500|      0|                else
  501|      0|                {
  502|      0|                    for(; j != end; ++j)
  ------------------
  |  Branch (502:27): [True: 0, False: 0]
  ------------------
  503|      0|                    {
  504|       |                        // Locate this target and insert it into the import table
  505|      0|                        auto target = locateTarget(*import.second, j->second);
  506|      0|                        if(target)
  ------------------
  |  Branch (506:28): [True: 0, False: 0]
  ------------------
  507|      0|                            mImportTable.insert(mImportTable.begin(), target);
  508|      0|                        else
  509|       |                            // -1 for line as we lost that info here
  510|      0|                            addError(CE_REFERENCETOANONEXISTINGOBJECT, nodes.front()->file, -1, j->second);
  511|      0|                    }
  512|      0|                }
  513|      0|            }
  514|      0|        }
  515|  15.8k|    }
_ZN4Ogre14ScriptCompiler14loadImportPathERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  518|  9.45k|    {
  519|  9.45k|        AbstractNodeListPtr retval;
  520|  9.45k|        ConcreteNodeListPtr nodes;
  521|       |
  522|  9.45k|        if(mListener)
  ------------------
  |  Branch (522:12): [True: 9.45k, False: 0]
  ------------------
  523|  9.45k|            nodes = mListener->importFile(this, name);
  524|       |
  525|  9.45k|        if(!nodes && ResourceGroupManager::getSingletonPtr())
  ------------------
  |  Branch (525:12): [True: 0, False: 9.45k]
  |  Branch (525:22): [True: 0, False: 0]
  ------------------
  526|      0|        {
  527|      0|            auto stream = ResourceGroupManager::getSingleton().openResource(name, mGroup, NULL, false);
  528|       |
  529|      0|            if (!stream)
  ------------------
  |  Branch (529:17): [True: 0, False: 0]
  ------------------
  530|      0|                return retval;
  531|       |
  532|      0|            nodes = ScriptParser::parse(ScriptLexer::tokenize(stream->getAsString(), name), name);
  533|      0|        }
  534|       |
  535|  9.45k|        if(nodes)
  ------------------
  |  Branch (535:12): [True: 9.45k, False: 0]
  ------------------
  536|  9.45k|            retval = convertToAST(*nodes);
  537|       |
  538|  9.45k|        return retval;
  539|  9.45k|    }
_ZN4Ogre14ScriptCompiler12locateTargetERKNSt3__14listINS_9SharedPtrINS_12AbstractNodeEEENS1_9allocatorIS5_EEEERKNS1_12basic_stringIcNS1_11char_traitsIcEENS6_IcEEEE:
  542|   194k|    {
  543|       |        // Search for a top-level object node
  544|   194k|        for(const auto& n : nodes)
  ------------------
  |  Branch (544:27): [True: 928k, False: 68.2k]
  ------------------
  545|   928k|        {
  546|   928k|            if(n->type == ANT_OBJECT && static_cast<ObjectAbstractNode*>(n.get())->name == target)
  ------------------
  |  Branch (546:16): [True: 443k, False: 485k]
  |  Branch (546:41): [True: 126k, False: 317k]
  ------------------
  547|   126k|            {
  548|   126k|                return n;
  549|   126k|            }
  550|   928k|        }
  551|       |
  552|  68.2k|        return nullptr;
  553|   194k|    }
_ZN4Ogre14ScriptCompiler14processObjectsERNSt3__14listINS_9SharedPtrINS_12AbstractNodeEEENS1_9allocatorIS5_EEEERKS8_PKNS_18ObjectAbstractNodeE:
  556|   704k|    {
  557|   704k|        for(auto& node : nodes)
  ------------------
  |  Branch (557:24): [True: 1.84M, False: 704k]
  ------------------
  558|  1.84M|        {
  559|  1.84M|            if(node->type == ANT_OBJECT)
  ------------------
  |  Branch (559:16): [True: 689k, False: 1.15M]
  ------------------
  560|   689k|            {
  561|   689k|                ObjectAbstractNode *obj = (ObjectAbstractNode*)node.get();
  562|       |
  563|   689k|                auto skipNode = exclude ? exclude : obj; // set to us at the top level
  ------------------
  |  Branch (563:33): [True: 660k, False: 28.0k]
  ------------------
  564|       |
  565|   689k|#ifdef OGRE_BUILD_COMPONENT_OVERLAY
  566|   689k|                bool isOverlayElement = obj->cls == "overlay_element";
  567|   689k|#endif
  568|       |                // Overlay base classes in order.
  569|   689k|                for (String& base : obj->bases)
  ------------------
  |  Branch (569:35): [True: 160k, False: 689k]
  ------------------
  570|   160k|                {
  571|       |                    // Check the top level first, then check the import table
  572|   160k|                    auto target = locateTarget(top, base);
  573|   160k|                    if(!target)
  ------------------
  |  Branch (573:24): [True: 34.1k, False: 126k]
  ------------------
  574|  34.1k|                        target = locateTarget(mImportTable, base);
  575|       |
  576|   160k|                    if (!target)
  ------------------
  |  Branch (576:25): [True: 34.1k, False: 126k]
  ------------------
  577|  34.1k|                    {
  578|  34.1k|                        addError(CE_OBJECTBASENOTFOUND, obj->file, obj->line, base);
  579|  34.1k|                        continue;
  580|  34.1k|                    }
  581|       |
  582|   126k|                    auto& src = static_cast<const ObjectAbstractNode&>(*target);
  583|       |
  584|   126k|                    if (target.get() == skipNode)
  ------------------
  |  Branch (584:25): [True: 2.41k, False: 123k]
  ------------------
  585|  2.41k|                    {
  586|  2.41k|                        addError(CE_OBJECTBASENOTFOUND, obj->file, obj->line, "cannot inherit from itself");
  587|  2.41k|                        continue;
  588|  2.41k|                    }
  589|       |
  590|   123k|                    if (src.cls != obj->cls)
  ------------------
  |  Branch (590:25): [True: 3.20k, False: 120k]
  ------------------
  591|  3.20k|                    {
  592|  3.20k|                        addError(CE_OBJECTBASENOTFOUND, obj->file, obj->line, "cannot inherit from a different type");
  593|  3.20k|                        continue;
  594|  3.20k|                    }
  595|       |
  596|   120k|#ifdef OGRE_BUILD_COMPONENT_OVERLAY
  597|       |                    // uses custom inheritance for renaming children
  598|   120k|                    if (isOverlayElement)
  ------------------
  |  Branch (598:25): [True: 384, False: 120k]
  ------------------
  599|    384|                    {
  600|    384|                        if (src.abstract)
  ------------------
  |  Branch (600:29): [True: 190, False: 194]
  ------------------
  601|    190|                            base = ""; // hide from custom inheritance
  602|    194|                        else
  603|    194|                            continue;
  604|    384|                    }
  605|   120k|#endif
  606|   120k|                    overlayObject(src, *obj);
  607|   120k|                }
  608|       |
  609|       |                // Recurse into children
  610|   689k|                processObjects(obj->children, top, skipNode);
  611|       |
  612|       |                // Overrides now exist in obj's overrides list. These are non-object nodes which must now
  613|       |                // Be placed in the children section of the object node such that overriding from parents
  614|       |                // into children works properly.
  615|   689k|                obj->children.insert(obj->children.begin(), obj->overrides.begin(), obj->overrides.end());
  616|   689k|            }
  617|  1.84M|        }
  618|   704k|    }
_ZN4Ogre14ScriptCompiler13overlayObjectERKNS_18ObjectAbstractNodeERS1_:
  621|   797k|    {
  622|       |        // Overlay the environment of one on top the other first
  623|   797k|        for(const auto & i : src.getVariables())
  ------------------
  |  Branch (623:28): [True: 15.5k, False: 797k]
  ------------------
  624|  15.5k|        {
  625|  15.5k|            std::pair<bool,String> var = dest.getVariable(i.first);
  626|  15.5k|            if(!var.first)
  ------------------
  |  Branch (626:16): [True: 3.37k, False: 12.1k]
  ------------------
  627|  3.37k|                dest.setVariable(i.first, i.second);
  628|  15.5k|        }
  629|       |
  630|       |        // Create a vector storing each pairing of override between source and destination
  631|   797k|        typedef SharedPtr<ObjectAbstractNode> ObjectAbstractNodePtr;
  632|   797k|        std::vector<std::pair<ObjectAbstractNodePtr,AbstractNodeList::iterator> > overrides;
  633|       |        // A list of indices for each destination node tracks the minimum
  634|       |        // source node they can index-match against
  635|   797k|        std::map<ObjectAbstractNode*,size_t> indices;
  636|       |        // A map storing which nodes have overridden from the destination node
  637|   797k|        std::map<ObjectAbstractNode*,bool> overridden;
  638|       |
  639|       |        // Fill the vector with objects from the source node (base)
  640|       |        // And insert non-objects into the overrides list of the destination
  641|   797k|        AbstractNodeList::iterator insertPos = dest.children.begin();
  642|   797k|        for(const auto & i : src.children)
  ------------------
  |  Branch (642:28): [True: 2.78M, False: 797k]
  ------------------
  643|  2.78M|        {
  644|  2.78M|            if(i->type == ANT_OBJECT)
  ------------------
  |  Branch (644:16): [True: 878k, False: 1.90M]
  ------------------
  645|   878k|            {
  646|   878k|                overrides.push_back(std::make_pair(static_pointer_cast<ObjectAbstractNode>(i), dest.children.end()));
  647|   878k|            }
  648|  1.90M|            else
  649|  1.90M|            {
  650|  1.90M|                AbstractNodePtr newNode(i->clone());
  651|  1.90M|                newNode->parent = &dest;
  652|  1.90M|                dest.overrides.push_back(newNode);
  653|  1.90M|            }
  654|  2.78M|        }
  655|       |
  656|       |        // Track the running maximum override index in the name-matching phase
  657|   797k|        size_t maxOverrideIndex = 0;
  658|       |
  659|       |        // Loop through destination children searching for name-matching overrides
  660|  14.6M|        for(AbstractNodeList::iterator i = dest.children.begin(); i != dest.children.end(); )
  ------------------
  |  Branch (660:67): [True: 13.8M, False: 797k]
  ------------------
  661|  13.8M|        {
  662|  13.8M|            if((*i)->type == ANT_OBJECT)
  ------------------
  |  Branch (662:16): [True: 11.9M, False: 1.86M]
  ------------------
  663|  11.9M|            {
  664|       |                // Start tracking the override index position for this object
  665|  11.9M|                size_t overrideIndex = 0;
  666|       |
  667|  11.9M|                ObjectAbstractNode *node = static_cast<ObjectAbstractNode*>((*i).get());
  668|  11.9M|                indices[node] = maxOverrideIndex;
  669|  11.9M|                overridden[node] = false;
  670|       |
  671|       |                // special treatment for materials with * in their name
  672|  11.9M|                bool nodeHasWildcard=node->name.find('*') != String::npos;
  673|       |
  674|       |                // Find the matching name node
  675|  40.0M|                for(size_t j = 0; j < overrides.size(); ++j)
  ------------------
  |  Branch (675:35): [True: 39.5M, False: 542k]
  ------------------
  676|  39.5M|                {
  677|  39.5M|                    ObjectAbstractNode *temp = overrides[j].first.get();
  678|       |                    // Consider a match a node that has a wildcard and matches an input name
  679|  39.5M|                    bool wildcardMatch = nodeHasWildcard &&
  ------------------
  |  Branch (679:42): [True: 198k, False: 39.3M]
  ------------------
  680|   198k|                        (StringUtil::match(temp->name,node->name,true) ||
  ------------------
  |  Branch (680:26): [True: 85.2k, False: 112k]
  ------------------
  681|   112k|                            (node->name.size() == 1 && temp->name.empty()));
  ------------------
  |  Branch (681:30): [True: 0, False: 112k]
  |  Branch (681:56): [True: 0, False: 0]
  ------------------
  682|  39.5M|                    if(temp->cls == node->cls && !node->name.empty() && (temp->name == node->name || wildcardMatch))
  ------------------
  |  Branch (682:24): [True: 18.9M, False: 20.5M]
  |  Branch (682:50): [True: 17.9M, False: 912k]
  |  Branch (682:74): [True: 11.4M, False: 6.58M]
  |  Branch (682:102): [True: 11.3k, False: 6.57M]
  ------------------
  683|  11.4M|                    {
  684|       |                        // Pair these two together unless it's already paired
  685|  11.4M|                        if(overrides[j].second == dest.children.end())
  ------------------
  |  Branch (685:28): [True: 321k, False: 11.1M]
  ------------------
  686|   321k|                        {
  687|   321k|                            AbstractNodeList::iterator currentIterator = i;
  688|   321k|                            ObjectAbstractNode *currentNode = node;
  689|   321k|                            if (wildcardMatch)
  ------------------
  |  Branch (689:33): [True: 23.9k, False: 297k]
  ------------------
  690|  23.9k|                            {
  691|       |                                //If wildcard is matched, make a copy of current material and put it before the iterator, matching its name to the parent. Use same reinterpret cast as above when node is set
  692|  23.9k|                                AbstractNodePtr newNode((*i)->clone());
  693|  23.9k|                                currentIterator = dest.children.insert(currentIterator, newNode);
  694|  23.9k|                                currentNode = static_cast<ObjectAbstractNode*>((*currentIterator).get());
  695|  23.9k|                                currentNode->name = temp->name;//make the regex match its matcher
  696|  23.9k|                            }
  697|   321k|                            overrides[j] = std::make_pair(overrides[j].first, currentIterator);
  698|       |                            // Store the max override index for this matched pair
  699|   321k|                            overrideIndex = j;
  700|   321k|                            overrideIndex = maxOverrideIndex = std::max(overrideIndex, maxOverrideIndex);
  701|   321k|                            indices[currentNode] = overrideIndex;
  702|   321k|                            overridden[currentNode] = true;
  703|   321k|                        }
  704|  11.1M|                        else
  705|  11.1M|                        {
  706|  11.1M|                            addError(CE_DUPLICATEOVERRIDE, node->file, node->line);
  707|  11.1M|                        }
  708|       |
  709|  11.4M|                        if(!wildcardMatch)
  ------------------
  |  Branch (709:28): [True: 11.3M, False: 29.8k]
  ------------------
  710|  11.3M|                            break;
  711|  11.4M|                    }
  712|  39.5M|                }
  713|       |
  714|  11.9M|                if (nodeHasWildcard)
  ------------------
  |  Branch (714:21): [True: 17.1k, False: 11.9M]
  ------------------
  715|  17.1k|                {
  716|       |                    //if the node has a wildcard it will be deleted since it was duplicated for every match
  717|  17.1k|                    AbstractNodeList::iterator deletable=i++;
  718|  17.1k|                    dest.children.erase(deletable);
  719|  17.1k|                }
  720|  11.9M|                else
  721|  11.9M|                {
  722|  11.9M|                    ++i; //Behavior in absence of regex, just increment iterator
  723|  11.9M|                }
  724|  11.9M|            }
  725|  1.86M|            else
  726|  1.86M|            {
  727|  1.86M|                ++i; //Behavior in absence of replaceable object, just increment iterator to find another
  728|  1.86M|            }
  729|  13.8M|        }
  730|       |
  731|       |        // Now make matches based on index
  732|       |        // Loop through destination children searching for index-matching overrides
  733|  14.6M|        for(AbstractNodeList::iterator i = dest.children.begin(); i != dest.children.end(); ++i)
  ------------------
  |  Branch (733:67): [True: 13.8M, False: 797k]
  ------------------
  734|  13.8M|        {
  735|  13.8M|            if((*i)->type == ANT_OBJECT)
  ------------------
  |  Branch (735:16): [True: 11.9M, False: 1.86M]
  ------------------
  736|  11.9M|            {
  737|  11.9M|                ObjectAbstractNode *node = static_cast<ObjectAbstractNode*>((*i).get());
  738|  11.9M|                if(!overridden[node])
  ------------------
  |  Branch (738:20): [True: 11.6M, False: 321k]
  ------------------
  739|  11.6M|                {
  740|       |                    // Retrieve the minimum override index from the map
  741|  11.6M|                    size_t overrideIndex = indices[node];
  742|       |
  743|  11.6M|                    if(overrideIndex < overrides.size())
  ------------------
  |  Branch (743:24): [True: 11.6M, False: 19.2k]
  ------------------
  744|  11.6M|                    {
  745|       |                        // Search for minimum matching override
  746|  91.8M|                        for(size_t j = overrideIndex; j < overrides.size(); ++j)
  ------------------
  |  Branch (746:55): [True: 80.6M, False: 11.2M]
  ------------------
  747|  80.6M|                        {
  748|  80.6M|                            ObjectAbstractNode *temp = overrides[j].first.get();
  749|  80.6M|                            if(temp->name.empty() && node->name.empty() && temp->cls == node->cls && overrides[j].second == dest.children.end())
  ------------------
  |  Branch (749:32): [True: 2.55M, False: 78.0M]
  |  Branch (749:32): [True: 356k, False: 80.2M]
  |  Branch (749:54): [True: 620k, False: 1.93M]
  |  Branch (749:76): [True: 518k, False: 102k]
  |  Branch (749:102): [True: 356k, False: 162k]
  ------------------
  750|   356k|                            {
  751|   356k|                                overrides[j] = std::make_pair(overrides[j].first, i);
  752|   356k|                                break;
  753|   356k|                            }
  754|  80.6M|                        }
  755|  11.6M|                    }
  756|  11.6M|                }
  757|  11.9M|            }
  758|  13.8M|        }
  759|       |
  760|       |        // Loop through overrides, either inserting source nodes or overriding
  761|   797k|        insertPos = dest.children.begin();
  762|   797k|        for(auto & override : overrides)
  ------------------
  |  Branch (762:29): [True: 878k, False: 797k]
  ------------------
  763|   878k|        {
  764|   878k|            if(override.second != dest.children.end())
  ------------------
  |  Branch (764:16): [True: 677k, False: 201k]
  ------------------
  765|   677k|            {
  766|       |                // Override the destination with the source (base) object
  767|   677k|                overlayObject(*override.first,
  768|   677k|                    static_cast<ObjectAbstractNode&>(**override.second));
  769|   677k|                insertPos = override.second;
  770|   677k|                insertPos++;
  771|   677k|            }
  772|   201k|            else
  773|   201k|            {
  774|       |                // No override was possible, so insert this node at the insert position
  775|       |                // into the destination (child) object
  776|   201k|                AbstractNodePtr newNode(override.first->clone());
  777|   201k|                newNode->parent = &dest;
  778|   201k|                if(insertPos != dest.children.end())
  ------------------
  |  Branch (778:20): [True: 174k, False: 26.8k]
  ------------------
  779|   174k|                {
  780|   174k|                    dest.children.insert(insertPos, newNode);
  781|   174k|                }
  782|  26.8k|                else
  783|  26.8k|                {
  784|  26.8k|                    dest.children.push_back(newNode);
  785|  26.8k|                }
  786|   201k|            }
  787|   878k|        }
  788|   797k|    }
_ZN4Ogre14ScriptCompiler14isNameExcludedERKNS_18ObjectAbstractNodeEPNS_12AbstractNodeE:
  791|  64.1k|    {
  792|       |        // Run past the listener
  793|  64.1k|        bool excludeName = false;
  794|  64.1k|        ProcessNameExclusionScriptCompilerEvent evt(node.cls, parent);
  795|  64.1k|        if(_fireEvent(&evt, (void*)&excludeName))
  ------------------
  |  Branch (795:12): [True: 0, False: 64.1k]
  ------------------
  796|      0|            return excludeName;
  797|       |
  798|       |        // Process the built-in name exclusions
  799|  64.1k|        if(node.id == ID_EMITTER || node.id == ID_AFFECTOR)
  ------------------
  |  Branch (799:12): [True: 279, False: 63.8k]
  |  Branch (799:37): [True: 567, False: 63.2k]
  ------------------
  800|    846|        {
  801|       |            // emitters or affectors inside a particle_system are excluded
  802|  2.13k|            while(parent && parent->type == ANT_OBJECT)
  ------------------
  |  Branch (802:19): [True: 1.68k, False: 445]
  |  Branch (802:29): [True: 1.35k, False: 335]
  ------------------
  803|  1.35k|            {
  804|  1.35k|                ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(parent);
  805|  1.35k|                if(obj->id == ID_PARTICLE_SYSTEM)
  ------------------
  |  Branch (805:20): [True: 66, False: 1.28k]
  ------------------
  806|     66|                    return true;
  807|  1.28k|                parent = obj->parent;
  808|  1.28k|            }
  809|    846|        }
  810|  63.2k|        else if(node.id == ID_PASS)
  ------------------
  |  Branch (810:17): [True: 5.42k, False: 57.8k]
  ------------------
  811|  5.42k|        {
  812|       |            // passes inside compositors are excluded
  813|  12.5k|            while(parent && parent->type == ANT_OBJECT)
  ------------------
  |  Branch (813:19): [True: 9.66k, False: 2.84k]
  |  Branch (813:29): [True: 9.43k, False: 232]
  ------------------
  814|  9.43k|            {
  815|  9.43k|                ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(parent);
  816|  9.43k|                if(obj->id == ID_TARGET || obj->id == ID_TARGET_OUTPUT)
  ------------------
  |  Branch (816:20): [True: 2.04k, False: 7.39k]
  |  Branch (816:44): [True: 305, False: 7.08k]
  ------------------
  817|  2.34k|                    return true;
  818|  7.08k|                parent = obj->parent;
  819|  7.08k|            }
  820|  5.42k|        }
  821|  57.8k|        else if(node.id == ID_TEXTURE_SOURCE)
  ------------------
  |  Branch (821:17): [True: 1.05k, False: 56.7k]
  ------------------
  822|  1.05k|        {
  823|       |            // Parent must be texture_unit
  824|  4.88k|            while(parent && parent->type == ANT_OBJECT)
  ------------------
  |  Branch (824:19): [True: 4.29k, False: 586]
  |  Branch (824:29): [True: 4.09k, False: 208]
  ------------------
  825|  4.09k|            {
  826|  4.09k|                ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(parent);
  827|  4.09k|                if(obj->id == ID_TEXTURE_UNIT)
  ------------------
  |  Branch (827:20): [True: 260, False: 3.83k]
  ------------------
  828|    260|                    return true;
  829|  3.83k|                parent = obj->parent;
  830|  3.83k|            }
  831|  1.05k|        }
  832|       |
  833|  61.4k|        return false;
  834|  64.1k|    }
_ZN4Ogre14ScriptCompiler16processVariablesERNSt3__14listINS_9SharedPtrINS_12AbstractNodeEEENS1_9allocatorIS5_EEEERNS1_3setINS1_12basic_stringIcNS1_11char_traitsIcEENS6_IcEEEENS1_4lessISF_EENS6_ISF_EEEE:
  837|  4.42M|    {
  838|  4.42M|        AbstractNodeList::iterator i = nodes.begin();
  839|  20.2M|        while(i != nodes.end())
  ------------------
  |  Branch (839:15): [True: 15.8M, False: 4.42M]
  ------------------
  840|  15.8M|        {
  841|  15.8M|            AbstractNodeList::iterator cur = i;
  842|  15.8M|            ++i;
  843|       |
  844|  15.8M|            if((*cur)->type == ANT_OBJECT)
  ------------------
  |  Branch (844:16): [True: 671k, False: 15.1M]
  ------------------
  845|   671k|            {
  846|       |                // Only process if this object is not abstract
  847|   671k|                ObjectAbstractNode *obj = (ObjectAbstractNode*)(*cur).get();
  848|   671k|                if(!obj->abstract)
  ------------------
  |  Branch (848:20): [True: 669k, False: 2.01k]
  ------------------
  849|   669k|                {
  850|   669k|                    processVariables(obj->children, expandingVars);
  851|   669k|                    processVariables(obj->values, expandingVars);
  852|   669k|                }
  853|   671k|            }
  854|  15.1M|            else if((*cur)->type == ANT_PROPERTY)
  ------------------
  |  Branch (854:21): [True: 2.52M, False: 12.6M]
  ------------------
  855|  2.52M|            {
  856|  2.52M|                PropertyAbstractNode *prop = (PropertyAbstractNode*)(*cur).get();
  857|  2.52M|                processVariables(prop->values, expandingVars);
  858|  2.52M|            }
  859|  12.6M|            else if((*cur)->type == ANT_VARIABLE_ACCESS)
  ------------------
  |  Branch (859:21): [True: 1.77M, False: 10.8M]
  ------------------
  860|  1.77M|            {
  861|  1.77M|                VariableAccessAbstractNode *var = (VariableAccessAbstractNode*)(*cur).get();
  862|       |
  863|       |                // Look up the enclosing scope
  864|  1.77M|                ObjectAbstractNode *scope = 0;
  865|  1.77M|                AbstractNode *temp = var->parent;
  866|  5.81M|                while(temp)
  ------------------
  |  Branch (866:23): [True: 5.19M, False: 620k]
  ------------------
  867|  5.19M|                {
  868|  5.19M|                    if(temp->type == ANT_OBJECT)
  ------------------
  |  Branch (868:24): [True: 1.15M, False: 4.04M]
  ------------------
  869|  1.15M|                    {
  870|  1.15M|                        scope = (ObjectAbstractNode*)temp;
  871|  1.15M|                        break;
  872|  1.15M|                    }
  873|  4.04M|                    temp = temp->parent;
  874|  4.04M|                }
  875|       |
  876|       |                // Look up the variable in the environment
  877|  1.77M|                std::pair<bool,String> varAccess;
  878|  1.77M|                if(scope)
  ------------------
  |  Branch (878:20): [True: 1.15M, False: 620k]
  ------------------
  879|  1.15M|                    varAccess = scope->getVariable(var->name);
  880|  1.77M|                if(!scope || !varAccess.first)
  ------------------
  |  Branch (880:20): [True: 620k, False: 1.15M]
  |  Branch (880:30): [True: 581k, False: 571k]
  ------------------
  881|  1.20M|                {
  882|  1.20M|                    std::map<String,String>::iterator k = mEnv.find(var->name);
  883|  1.20M|                    varAccess.first = k != mEnv.end();
  884|  1.20M|                    if(varAccess.first)
  ------------------
  |  Branch (884:24): [True: 597k, False: 604k]
  ------------------
  885|   597k|                        varAccess.second = k->second;
  886|  1.20M|                }
  887|       |
  888|  1.77M|                if(varAccess.first)
  ------------------
  |  Branch (888:20): [True: 1.16M, False: 604k]
  ------------------
  889|  1.16M|                {
  890|  1.16M|                    if(!expandingVars.insert(var->name).second)
  ------------------
  |  Branch (890:24): [True: 632k, False: 536k]
  ------------------
  891|   632k|                    {
  892|       |                        // Error
  893|   632k|                        addError(CE_INVALIDPARAMETERS, var->file, var->line, var->name+ " is defined recursively");
  894|   632k|                        nodes.erase(cur);
  895|   632k|                        continue;
  896|   632k|                    }
  897|       |
  898|       |                    // Found the variable, so process it and insert it into the tree
  899|   536k|                    ConcreteNodeListPtr cst = ScriptParser::parseChunk(ScriptLexer::tokenize(varAccess.second, var->file), var->file);
  900|   536k|                    AbstractNodeListPtr ast = convertToAST(*cst);
  901|       |
  902|       |                    // Set up ownership for these nodes
  903|   536k|                    for(auto & j : *ast)
  ------------------
  |  Branch (903:34): [True: 5.59M, False: 536k]
  ------------------
  904|  5.59M|                        j->parent = var->parent;
  905|       |
  906|       |                    // Recursively handle variable accesses within the variable expansion
  907|   536k|                    processVariables(*ast, expandingVars);
  908|       |
  909|       |                    // Insert the nodes in place of the variable
  910|   536k|                    nodes.insert(cur, ast->begin(), ast->end());
  911|       |
  912|   536k|                    expandingVars.erase(var->name);
  913|   536k|                }
  914|   604k|                else
  915|   604k|                {
  916|       |                    // Error
  917|   604k|                    addError(CE_UNDEFINEDVARIABLE, var->file, var->line, var->name);
  918|   604k|                }
  919|       |
  920|       |                // Remove the variable node
  921|  1.14M|                nodes.erase(cur);
  922|  1.14M|            }
  923|  15.8M|        }
  924|  4.42M|    }
_ZN4Ogre14ScriptCompiler11initWordMapEv:
  927|      1|    {
  928|      1|        mIds["on"] = ID_ON;
  929|      1|        mIds["off"] = ID_OFF;
  930|      1|        mIds["true"] = ID_TRUE;
  931|      1|        mIds["false"] = ID_FALSE;
  932|      1|        mIds["yes"] = ID_YES;
  933|      1|        mIds["no"] = ID_NO;
  934|       |
  935|       |        // Material ids
  936|      1|        mIds["material"] = ID_MATERIAL;
  937|      1|        mIds["vertex_program"] = ID_VERTEX_PROGRAM;
  938|      1|        mIds["geometry_program"] = ID_GEOMETRY_PROGRAM;
  939|      1|        mIds["fragment_program"] = ID_FRAGMENT_PROGRAM;
  940|      1|        mIds["tessellation_hull_program"] = ID_TESSELLATION_HULL_PROGRAM;
  941|      1|        mIds["tessellation_domain_program"] = ID_TESSELLATION_DOMAIN_PROGRAM;
  942|      1|        mIds["compute_program"] = ID_COMPUTE_PROGRAM;
  943|      1|        mIds["mesh_program"] = ID_MESH_PROGRAM;
  944|      1|        mIds["task_program"] = ID_TASK_PROGRAM;
  945|      1|        mIds["technique"] = ID_TECHNIQUE;
  946|      1|        mIds["pass"] = ID_PASS;
  947|      1|        mIds["texture_unit"] = ID_TEXTURE_UNIT;
  948|      1|        mIds["vertex_program_ref"] = ID_VERTEX_PROGRAM_REF;
  949|      1|        mIds["geometry_program_ref"] = ID_GEOMETRY_PROGRAM_REF;
  950|      1|        mIds["fragment_program_ref"] = ID_FRAGMENT_PROGRAM_REF;
  951|      1|        mIds["tessellation_hull_program_ref"] = ID_TESSELLATION_HULL_PROGRAM_REF;
  952|      1|        mIds["tessellation_domain_program_ref"] = ID_TESSELLATION_DOMAIN_PROGRAM_REF;
  953|      1|        mIds["compute_program_ref"] = ID_COMPUTE_PROGRAM_REF;
  954|      1|        mIds["mesh_program_ref"] = ID_MESH_PROGRAM_REF;
  955|      1|        mIds["task_program_ref"] = ID_TASK_PROGRAM_REF;
  956|      1|        mIds["shadow_caster_vertex_program_ref"] = ID_SHADOW_CASTER_VERTEX_PROGRAM_REF;
  957|      1|        mIds["shadow_caster_fragment_program_ref"] = ID_SHADOW_CASTER_FRAGMENT_PROGRAM_REF;
  958|      1|        mIds["shadow_receiver_vertex_program_ref"] = ID_SHADOW_RECEIVER_VERTEX_PROGRAM_REF;
  959|      1|        mIds["shadow_receiver_fragment_program_ref"] = ID_SHADOW_RECEIVER_FRAGMENT_PROGRAM_REF;
  960|       |
  961|      1|        mIds["lod_values"] = ID_LOD_VALUES;
  962|      1|        mIds["lod_strategy"] = ID_LOD_STRATEGY;
  963|      1|        mIds["lod_distances"] = ID_LOD_DISTANCES;
  964|      1|        mIds["receive_shadows"] = ID_RECEIVE_SHADOWS;
  965|      1|        mIds["transparency_casts_shadows"] = ID_TRANSPARENCY_CASTS_SHADOWS;
  966|      1|        mIds["set_texture_alias"] = ID_SET_TEXTURE_ALIAS;
  967|       |
  968|      1|        mIds["source"] = ID_SOURCE;
  969|      1|        mIds["syntax"] = ID_SYNTAX;
  970|      1|        mIds["default_params"] = ID_DEFAULT_PARAMS;
  971|      1|        mIds["param_indexed"] = ID_PARAM_INDEXED;
  972|      1|        mIds["param_named"] = ID_PARAM_NAMED;
  973|      1|        mIds["param_indexed_auto"] = ID_PARAM_INDEXED_AUTO;
  974|      1|        mIds["param_named_auto"] = ID_PARAM_NAMED_AUTO;
  975|       |
  976|      1|        mIds["scheme"] = ID_SCHEME;
  977|      1|        mIds["lod_index"] = ID_LOD_INDEX;
  978|      1|        mIds["shadow_caster_material"] = ID_SHADOW_CASTER_MATERIAL;
  979|      1|        mIds["shadow_receiver_material"] = ID_SHADOW_RECEIVER_MATERIAL;
  980|      1|        mIds["gpu_vendor_rule"] = ID_GPU_VENDOR_RULE;
  981|      1|        mIds["gpu_device_rule"] = ID_GPU_DEVICE_RULE;
  982|      1|        mIds["include"] = ID_INCLUDE;
  983|      1|        mIds["exclude"] = ID_EXCLUDE;
  984|       |
  985|      1|        mIds["ambient"] = ID_AMBIENT;
  986|      1|        mIds["diffuse"] = ID_DIFFUSE;
  987|      1|        mIds["specular"] = ID_SPECULAR;
  988|      1|        mIds["emissive"] = ID_EMISSIVE;
  989|      1|        mIds["vertexcolour"] = ID_VERTEXCOLOUR;
  990|      1|        mIds["scene_blend"] = ID_SCENE_BLEND;
  991|      1|        mIds["colour_blend"] = ID_COLOUR_BLEND;
  992|      1|        mIds["one"] = ID_ONE;
  993|      1|        mIds["zero"] = ID_ZERO;
  994|      1|        mIds["dest_colour"] = ID_DEST_COLOUR;
  995|      1|        mIds["src_colour"] = ID_SRC_COLOUR;
  996|      1|        mIds["one_minus_src_colour"] = ID_ONE_MINUS_SRC_COLOUR;
  997|      1|        mIds["one_minus_dest_colour"] = ID_ONE_MINUS_DEST_COLOUR;
  998|      1|        mIds["dest_alpha"] = ID_DEST_ALPHA;
  999|      1|        mIds["src_alpha"] = ID_SRC_ALPHA;
 1000|      1|        mIds["one_minus_dest_alpha"] = ID_ONE_MINUS_DEST_ALPHA;
 1001|      1|        mIds["one_minus_src_alpha"] = ID_ONE_MINUS_SRC_ALPHA;
 1002|      1|        mIds["separate_scene_blend"] = ID_SEPARATE_SCENE_BLEND;
 1003|      1|        mIds["scene_blend_op"] = ID_SCENE_BLEND_OP;
 1004|      1|        mIds["reverse_subtract"] = ID_REVERSE_SUBTRACT;
 1005|      1|        mIds["min"] = ID_MIN;
 1006|      1|        mIds["max"] = ID_MAX;
 1007|      1|        mIds["separate_scene_blend_op"] = ID_SEPARATE_SCENE_BLEND_OP;
 1008|      1|        mIds["depth_check"] = ID_DEPTH_CHECK;
 1009|      1|        mIds["depth_write"] = ID_DEPTH_WRITE;
 1010|      1|        mIds["depth_func"] = ID_DEPTH_FUNC;
 1011|      1|        mIds["depth_bias"] = ID_DEPTH_BIAS;
 1012|      1|        mIds["iteration_depth_bias"] = ID_ITERATION_DEPTH_BIAS;
 1013|      1|        mIds["always_fail"] = ID_ALWAYS_FAIL;
 1014|      1|        mIds["always_pass"] = ID_ALWAYS_PASS;
 1015|      1|        mIds["less_equal"] = ID_LESS_EQUAL;
 1016|      1|        mIds["less"] = ID_LESS;
 1017|      1|        mIds["equal"] = ID_EQUAL;
 1018|      1|        mIds["not_equal"] = ID_NOT_EQUAL;
 1019|      1|        mIds["greater_equal"] = ID_GREATER_EQUAL;
 1020|      1|        mIds["greater"] = ID_GREATER;
 1021|      1|        mIds["alpha_rejection"] = ID_ALPHA_REJECTION;
 1022|      1|        mIds["alpha_to_coverage"] = ID_ALPHA_TO_COVERAGE;
 1023|      1|        mIds["light_scissor"] = ID_LIGHT_SCISSOR;
 1024|      1|        mIds["light_clip_planes"] = ID_LIGHT_CLIP_PLANES;
 1025|      1|        mIds["transparent_sorting"] = ID_TRANSPARENT_SORTING;
 1026|      1|        mIds["illumination_stage"] = ID_ILLUMINATION_STAGE;
 1027|      1|        mIds["decal"] = ID_DECAL;
 1028|      1|        mIds["cull_hardware"] = ID_CULL_HARDWARE;
 1029|      1|        mIds["clockwise"] = ID_CLOCKWISE;
 1030|      1|        mIds["anticlockwise"] = ID_ANTICLOCKWISE;
 1031|      1|        mIds["cull_software"] = ID_CULL_SOFTWARE;
 1032|      1|        mIds["back"] = ID_BACK;
 1033|      1|        mIds["front"] = ID_FRONT;
 1034|      1|        mIds["lighting"] = ID_LIGHTING;
 1035|      1|        mIds["shading"] = ID_SHADING;
 1036|      1|        mIds["flat"] = ID_FLAT;
 1037|      1|        mIds["gouraud"] = ID_GOURAUD;
 1038|      1|        mIds["phong"] = ID_PHONG;
 1039|      1|        mIds["polygon_mode"] = ID_POLYGON_MODE;
 1040|      1|        mIds["solid"] = ID_SOLID;
 1041|      1|        mIds["wireframe"] = ID_WIREFRAME;
 1042|      1|        mIds["points"] = ID_POINTS;
 1043|      1|        mIds["polygon_mode_overrideable"] = ID_POLYGON_MODE_OVERRIDEABLE;
 1044|      1|        mIds["fog_override"] = ID_FOG_OVERRIDE;
 1045|      1|        mIds["none"] = ID_NONE;
 1046|      1|        mIds["linear"] = ID_LINEAR;
 1047|      1|        mIds["exp"] = ID_EXP;
 1048|      1|        mIds["exp2"] = ID_EXP2;
 1049|      1|        mIds["colour_write"] = ID_COLOUR_WRITE;
 1050|      1|        mIds["max_lights"] = ID_MAX_LIGHTS;
 1051|      1|        mIds["start_light"] = ID_START_LIGHT;
 1052|      1|        mIds["iteration"] = ID_ITERATION;
 1053|      1|        mIds["once"] = ID_ONCE;
 1054|      1|        mIds["once_per_light"] = ID_ONCE_PER_LIGHT;
 1055|      1|        mIds["per_n_lights"] = ID_PER_N_LIGHTS;
 1056|      1|        mIds["per_light"] = ID_PER_LIGHT;
 1057|      1|        mIds["point"] = ID_POINT;
 1058|      1|        mIds["spot"] = ID_SPOT;
 1059|      1|        mIds["directional"] = ID_DIRECTIONAL;
 1060|      1|        mIds["light_mask"] = ID_LIGHT_MASK;
 1061|      1|        mIds["point_size"] = ID_POINT_SIZE;
 1062|      1|        mIds["point_sprites"] = ID_POINT_SPRITES;
 1063|      1|        mIds["point_size_min"] = ID_POINT_SIZE_MIN;
 1064|      1|        mIds["point_size_max"] = ID_POINT_SIZE_MAX;
 1065|      1|        mIds["point_size_attenuation"] = ID_POINT_SIZE_ATTENUATION;
 1066|       |
 1067|      1|        mIds["texture_alias"] = ID_TEXTURE_ALIAS;
 1068|      1|        mIds["texture"] = ID_TEXTURE;
 1069|      1|        mIds["1d"] = ID_1D;
 1070|      1|        mIds["2d"] = ID_2D;
 1071|      1|        mIds["3d"] = ID_3D;
 1072|      1|        mIds["cubic"] = ID_CUBIC;
 1073|      1|        mIds["unlimited"] = ID_UNLIMITED;
 1074|      1|        mIds["2darray"] = ID_2DARRAY; // deprecated and undocumented
 1075|      1|        mIds["2d_array"] = ID_2DARRAY;
 1076|      1|        mIds["2d_ms"] = ID_2DMS;
 1077|      1|        mIds["alpha"] = ID_ALPHA;
 1078|      1|        mIds["gamma"] = ID_GAMMA;
 1079|      1|        mIds["anim_texture"] = ID_ANIM_TEXTURE;
 1080|      1|        mIds["cubic_texture"] = ID_CUBIC_TEXTURE;
 1081|      1|        mIds["separateUV"] = ID_SEPARATE_UV;
 1082|      1|        mIds["combinedUVW"] = ID_COMBINED_UVW;
 1083|      1|        mIds["tex_coord_set"] = ID_TEX_COORD_SET;
 1084|      1|        mIds["tex_address_mode"] = ID_TEX_ADDRESS_MODE;
 1085|      1|        mIds["wrap"] = ID_WRAP;
 1086|      1|        mIds["clamp"] = ID_CLAMP;
 1087|      1|        mIds["mirror"] = ID_MIRROR;
 1088|      1|        mIds["border"] = ID_BORDER;
 1089|      1|        mIds["tex_border_colour"] = ID_TEX_BORDER_COLOUR;
 1090|      1|        mIds["filtering"] = ID_FILTERING;
 1091|      1|        mIds["bilinear"] = ID_BILINEAR;
 1092|      1|        mIds["trilinear"] = ID_TRILINEAR;
 1093|      1|        mIds["anisotropic"] = ID_ANISOTROPIC;
 1094|      1|        mIds["compare_test"] = ID_CMPTEST;
 1095|      1|        mIds["compare_func"] = ID_CMPFUNC;
 1096|      1|        mIds["max_anisotropy"] = ID_MAX_ANISOTROPY;
 1097|      1|        mIds["mipmap_bias"] = ID_MIPMAP_BIAS;
 1098|      1|        mIds["colour_op"] = ID_COLOUR_OP;
 1099|      1|        mIds["replace"] = ID_REPLACE;
 1100|      1|        mIds["add"] = ID_ADD;
 1101|      1|        mIds["modulate"] = ID_MODULATE;
 1102|      1|        mIds["alpha_blend"] = ID_ALPHA_BLEND;
 1103|      1|        mIds["colour_op_ex"] = ID_COLOUR_OP_EX;
 1104|      1|        mIds["source1"] = ID_SOURCE1;
 1105|      1|        mIds["source2"] = ID_SOURCE2;
 1106|      1|        mIds["modulate"] = ID_MODULATE;
 1107|      1|        mIds["modulate_x2"] = ID_MODULATE_X2;
 1108|      1|        mIds["modulate_x4"] = ID_MODULATE_X4;
 1109|      1|        mIds["add"] = ID_ADD;
 1110|      1|        mIds["add_signed"] = ID_ADD_SIGNED;
 1111|      1|        mIds["add_smooth"] = ID_ADD_SMOOTH;
 1112|      1|        mIds["subtract"] = ID_SUBTRACT;
 1113|      1|        mIds["blend_diffuse_alpha"] = ID_BLEND_DIFFUSE_ALPHA;
 1114|      1|        mIds["blend_texture_alpha"] = ID_BLEND_TEXTURE_ALPHA;
 1115|      1|        mIds["blend_current_alpha"] = ID_BLEND_CURRENT_ALPHA;
 1116|      1|        mIds["blend_manual"] = ID_BLEND_MANUAL;
 1117|      1|        mIds["dotproduct"] = ID_DOT_PRODUCT;
 1118|      1|        mIds["blend_diffuse_colour"] = ID_BLEND_DIFFUSE_COLOUR;
 1119|      1|        mIds["src_current"] = ID_SRC_CURRENT;
 1120|      1|        mIds["src_texture"] = ID_SRC_TEXTURE;
 1121|      1|        mIds["src_diffuse"] = ID_SRC_DIFFUSE;
 1122|      1|        mIds["src_specular"] = ID_SRC_SPECULAR;
 1123|      1|        mIds["src_manual"] = ID_SRC_MANUAL;
 1124|      1|        mIds["colour_op_multipass_fallback"] = ID_COLOUR_OP_MULTIPASS_FALLBACK;
 1125|      1|        mIds["alpha_op_ex"] = ID_ALPHA_OP_EX;
 1126|      1|        mIds["env_map"] = ID_ENV_MAP;
 1127|      1|        mIds["spherical"] = ID_SPHERICAL;
 1128|      1|        mIds["planar"] = ID_PLANAR;
 1129|      1|        mIds["cubic_reflection"] = ID_CUBIC_REFLECTION;
 1130|      1|        mIds["cubic_normal"] = ID_CUBIC_NORMAL;
 1131|      1|        mIds["scroll"] = ID_SCROLL;
 1132|      1|        mIds["scroll_anim"] = ID_SCROLL_ANIM;
 1133|      1|        mIds["rotate"] = ID_ROTATE;
 1134|      1|        mIds["rotate_anim"] = ID_ROTATE_ANIM;
 1135|      1|        mIds["scale"] = ID_SCALE;
 1136|      1|        mIds["wave_xform"] = ID_WAVE_XFORM;
 1137|      1|        mIds["scroll_x"] = ID_SCROLL_X;
 1138|      1|        mIds["scroll_y"] = ID_SCROLL_Y;
 1139|      1|        mIds["scale_x"] = ID_SCALE_X;
 1140|      1|        mIds["scale_y"] = ID_SCALE_Y;
 1141|      1|        mIds["sine"] = ID_SINE;
 1142|      1|        mIds["triangle"] = ID_TRIANGLE;
 1143|      1|        mIds["sawtooth"] = ID_SAWTOOTH;
 1144|      1|        mIds["square"] = ID_SQUARE;
 1145|      1|        mIds["inverse_sawtooth"] = ID_INVERSE_SAWTOOTH;
 1146|      1|        mIds["transform"] = ID_TRANSFORM;
 1147|      1|        mIds["geometry"] = ID_GEOMETRY;
 1148|      1|        mIds["tessellation_hull"] = ID_TESSELLATION_HULL;
 1149|      1|        mIds["tessellation_domain"] = ID_TESSELLATION_DOMAIN;
 1150|      1|        mIds["compute"] = ID_COMPUTE;
 1151|      1|        mIds["content_type"] = ID_CONTENT_TYPE;
 1152|      1|        mIds["named"] = ID_NAMED;
 1153|      1|        mIds["shadow"] = ID_SHADOW;
 1154|      1|        mIds["texture_source"] = ID_TEXTURE_SOURCE;
 1155|      1|        mIds["shared_params"] = ID_SHARED_PARAMS;
 1156|      1|        mIds["shared_param_named"] = ID_SHARED_PARAM_NAMED;
 1157|      1|        mIds["shared_params_ref"] = ID_SHARED_PARAMS_REF;
 1158|      1|        mIds["use_linear_colours"] = ID_USE_LINEAR_COLOURS;
 1159|       |
 1160|       |        // Particle system
 1161|      1|        mIds["particle_system"] = ID_PARTICLE_SYSTEM;
 1162|      1|        mIds["emitter"] = ID_EMITTER;
 1163|      1|        mIds["affector"] = ID_AFFECTOR;
 1164|       |
 1165|       |        // Compositor
 1166|      1|        mIds["compositor"] = ID_COMPOSITOR;
 1167|      1|        mIds["target"] = ID_TARGET;
 1168|      1|        mIds["target_output"] = ID_TARGET_OUTPUT;
 1169|       |
 1170|      1|        mIds["input"] = ID_INPUT;
 1171|       |        //mIds["none"] = ID_NONE; - already registered
 1172|      1|        mIds["previous"] = ID_PREVIOUS;
 1173|      1|        mIds["target_width"] = ID_TARGET_WIDTH;
 1174|      1|        mIds["target_height"] = ID_TARGET_HEIGHT;
 1175|      1|        mIds["target_width_scaled"] = ID_TARGET_WIDTH_SCALED;
 1176|      1|        mIds["target_height_scaled"] = ID_TARGET_HEIGHT_SCALED;
 1177|      1|        mIds["pooled"] = ID_POOLED;
 1178|       |        //mIds["gamma"] = ID_GAMMA; - already registered
 1179|      1|        mIds["no_fsaa"] = ID_NO_FSAA;
 1180|      1|        mIds["fsaa"] = ID_FSAA;
 1181|      1|        mIds["depth_pool"] = ID_DEPTH_POOL;
 1182|       |
 1183|      1|        mIds["texture_ref"] = ID_TEXTURE_REF;
 1184|      1|        mIds["local_scope"] = ID_SCOPE_LOCAL;
 1185|      1|        mIds["chain_scope"] = ID_SCOPE_CHAIN;
 1186|      1|        mIds["global_scope"] = ID_SCOPE_GLOBAL;
 1187|      1|        mIds["compositor_logic"] = ID_COMPOSITOR_LOGIC;
 1188|       |
 1189|      1|        mIds["only_initial"] = ID_ONLY_INITIAL;
 1190|      1|        mIds["visibility_mask"] = ID_VISIBILITY_MASK;
 1191|      1|        mIds["lod_bias"] = ID_LOD_BIAS;
 1192|      1|        mIds["material_scheme"] = ID_MATERIAL_SCHEME;
 1193|      1|        mIds["shadows"] = ID_SHADOWS_ENABLED;
 1194|       |
 1195|      1|        mIds["clear"] = ID_CLEAR;
 1196|      1|        mIds["stencil"] = ID_STENCIL;
 1197|      1|        mIds["render_scene"] = ID_RENDER_SCENE;
 1198|      1|        mIds["render_quad"] = ID_RENDER_QUAD;
 1199|      1|        mIds["identifier"] = ID_IDENTIFIER;
 1200|      1|        mIds["first_render_queue"] = ID_FIRST_RENDER_QUEUE;
 1201|      1|        mIds["last_render_queue"] = ID_LAST_RENDER_QUEUE;
 1202|      1|        mIds["quad_normals"] = ID_QUAD_NORMALS;
 1203|      1|        mIds["camera_far_corners_view_space"] = ID_CAMERA_FAR_CORNERS_VIEW_SPACE;
 1204|      1|        mIds["camera_far_corners_world_space"] = ID_CAMERA_FAR_CORNERS_WORLD_SPACE;
 1205|       |
 1206|      1|        mIds["buffers"] = ID_BUFFERS;
 1207|      1|        mIds["colour"] = ID_COLOUR;
 1208|      1|        mIds["depth"] = ID_DEPTH;
 1209|      1|        mIds["colour_value"] = ID_COLOUR_VALUE;
 1210|      1|        mIds["depth_value"] = ID_DEPTH_VALUE;
 1211|      1|        mIds["stencil_value"] = ID_STENCIL_VALUE;
 1212|       |
 1213|      1|        mIds["check"] = ID_CHECK;
 1214|      1|        mIds["comp_func"] = ID_COMP_FUNC;
 1215|      1|        mIds["ref_value"] = ID_REF_VALUE;
 1216|      1|        mIds["mask"] = ID_MASK;
 1217|      1|        mIds["fail_op"] = ID_FAIL_OP;
 1218|      1|        mIds["keep"] = ID_KEEP;
 1219|      1|        mIds["increment"] = ID_INCREMENT;
 1220|      1|        mIds["decrement"] = ID_DECREMENT;
 1221|      1|        mIds["increment_wrap"] = ID_INCREMENT_WRAP;
 1222|      1|        mIds["decrement_wrap"] = ID_DECREMENT_WRAP;
 1223|      1|        mIds["invert"] = ID_INVERT;
 1224|      1|        mIds["depth_fail_op"] = ID_DEPTH_FAIL_OP;
 1225|      1|        mIds["pass_op"] = ID_PASS_OP;
 1226|      1|        mIds["two_sided"] = ID_TWO_SIDED;
 1227|       |
 1228|      1|        mIds["line_width"] = ID_LINE_WIDTH;
 1229|      1|        mIds["sampler"] = ID_SAMPLER;
 1230|      1|        mIds["sampler_ref"] = ID_SAMPLER_REF;
 1231|      1|        mIds["thread_groups"] = ID_THREAD_GROUPS;
 1232|      1|        mIds["render_custom"] = ID_RENDER_CUSTOM;
 1233|      1|        mIds["auto"] = ID_AUTO;
 1234|      1|        mIds["camera"] = ID_CAMERA;
 1235|      1|        mIds["align_to_face"] = ID_ALIGN_TO_FACE;
 1236|      1|        mIds["unordered_access_mip"] = ID_UNORDERED_ACCESS_MIP;
 1237|       |
 1238|      1|		mLargestRegisteredWordId = ID_END_BUILTIN_IDS;
 1239|      1|	}
_ZN4Ogre14ScriptCompiler19AbstractTreeBuilderC2EPS0_:
 1258|   561k|        :mNodes(std::make_shared<AbstractNodeList>()), mCurrent(0), mCompiler(compiler)
 1259|   561k|    {
 1260|   561k|    }
_ZNK4Ogre14ScriptCompiler19AbstractTreeBuilder9getResultEv:
 1263|   561k|    {
 1264|   561k|        return mNodes;
 1265|   561k|    }
_ZN4Ogre14ScriptCompiler19AbstractTreeBuilder5visitEPNS_12ConcreteNodeE:
 1268|  6.79M|    {
 1269|  6.79M|        AbstractNodePtr asn;
 1270|       |
 1271|       |        // Import = "import" >> 2 children, mCurrent == null
 1272|  6.79M|        if(node->type == CNT_IMPORT && mCurrent == 0)
  ------------------
  |  Branch (1272:12): [True: 10.1k, False: 6.78M]
  |  Branch (1272:40): [True: 9.45k, False: 729]
  ------------------
 1273|  9.45k|        {
 1274|  9.45k|            if(node->children.size() > 2)
  ------------------
  |  Branch (1274:16): [True: 0, False: 9.45k]
  ------------------
 1275|      0|            {
 1276|      0|                mCompiler->addError(CE_FEWERPARAMETERSEXPECTED, node->file, node->line);
 1277|      0|                return;
 1278|      0|            }
 1279|  9.45k|            if(node->children.size() < 2)
  ------------------
  |  Branch (1279:16): [True: 0, False: 9.45k]
  ------------------
 1280|      0|            {
 1281|      0|                mCompiler->addError(CE_STRINGEXPECTED, node->file, node->line);
 1282|      0|                return;
 1283|      0|            }
 1284|       |
 1285|  9.45k|            ImportAbstractNode *impl = OGRE_NEW ImportAbstractNode();
 1286|  9.45k|            impl->line = node->line;
 1287|  9.45k|            impl->file = node->file;
 1288|       |
 1289|  9.45k|            ConcreteNodeList::iterator iter = node->children.begin();
 1290|  9.45k|            impl->target = (*iter)->token;
 1291|       |
 1292|  9.45k|            iter++;
 1293|  9.45k|            impl->source = (*iter)->token;
 1294|       |
 1295|  9.45k|            asn = AbstractNodePtr(impl);
 1296|  9.45k|        }
 1297|       |        // variable set = "set" >> 2 children, children[0] == variable
 1298|  6.78M|        else if(node->type == CNT_VARIABLE_ASSIGN)
  ------------------
  |  Branch (1298:17): [True: 5.20k, False: 6.77M]
  ------------------
 1299|  5.20k|        {
 1300|  5.20k|            if(node->children.size() > 2)
  ------------------
  |  Branch (1300:16): [True: 0, False: 5.20k]
  ------------------
 1301|      0|            {
 1302|      0|                mCompiler->addError(CE_FEWERPARAMETERSEXPECTED, node->file, node->line);
 1303|      0|                return;
 1304|      0|            }
 1305|  5.20k|            if(node->children.size() < 2)
  ------------------
  |  Branch (1305:16): [True: 0, False: 5.20k]
  ------------------
 1306|      0|            {
 1307|      0|                mCompiler->addError(CE_STRINGEXPECTED, node->file, node->line);
 1308|      0|                return;
 1309|      0|            }
 1310|  5.20k|            if(node->children.front()->type != CNT_VARIABLE)
  ------------------
  |  Branch (1310:16): [True: 0, False: 5.20k]
  ------------------
 1311|      0|            {
 1312|      0|                mCompiler->addError(CE_VARIABLEEXPECTED, node->children.front()->file, node->children.front()->line);
 1313|      0|                return;
 1314|      0|            }
 1315|       |
 1316|  5.20k|            ConcreteNodeList::iterator i = node->children.begin();
 1317|  5.20k|            String name = (*i)->token;
 1318|       |
 1319|  5.20k|            ++i;
 1320|  5.20k|            String value = (*i)->token;
 1321|       |
 1322|  5.20k|            if(mCurrent && mCurrent->type == ANT_OBJECT)
  ------------------
  |  Branch (1322:16): [True: 4.03k, False: 1.16k]
  |  Branch (1322:28): [True: 3.00k, False: 1.03k]
  ------------------
 1323|  3.00k|            {
 1324|  3.00k|                ObjectAbstractNode *ptr = (ObjectAbstractNode*)mCurrent;
 1325|  3.00k|                ptr->setVariable(name, value);
 1326|  3.00k|            }
 1327|  2.20k|            else
 1328|  2.20k|            {
 1329|  2.20k|                mCompiler->mEnv.insert(std::make_pair(name, value));
 1330|  2.20k|            }
 1331|  5.20k|        }
 1332|       |        // variable = $*, no children
 1333|  6.77M|        else if(node->type == CNT_VARIABLE)
  ------------------
  |  Branch (1333:17): [True: 1.65M, False: 5.12M]
  ------------------
 1334|  1.65M|        {
 1335|  1.65M|            if(!node->children.empty())
  ------------------
  |  Branch (1335:16): [True: 0, False: 1.65M]
  ------------------
 1336|      0|            {
 1337|      0|                mCompiler->addError(CE_FEWERPARAMETERSEXPECTED, node->file, node->line);
 1338|      0|                return;
 1339|      0|            }
 1340|       |
 1341|  1.65M|            VariableAccessAbstractNode *impl = OGRE_NEW VariableAccessAbstractNode(mCurrent);
 1342|  1.65M|            impl->line = node->line;
 1343|  1.65M|            impl->file = node->file;
 1344|  1.65M|            impl->name = node->token;
 1345|       |
 1346|  1.65M|            asn = AbstractNodePtr(impl);
 1347|  1.65M|        }
 1348|       |        // Handle properties and objects here
 1349|  5.12M|        else if(!node->children.empty())
  ------------------
  |  Branch (1349:17): [True: 393k, False: 4.73M]
  ------------------
 1350|   393k|        {
 1351|       |            // Grab the last two nodes
 1352|   393k|            ConcreteNodePtr temp1, temp2;
 1353|   393k|            ConcreteNodeList::reverse_iterator riter = node->children.rbegin();
 1354|   393k|            if(riter != node->children.rend())
  ------------------
  |  Branch (1354:16): [True: 393k, False: 0]
  ------------------
 1355|   393k|            {
 1356|   393k|                temp1 = *riter;
 1357|   393k|                riter++;
 1358|   393k|            }
 1359|   393k|            if(riter != node->children.rend())
  ------------------
  |  Branch (1359:16): [True: 208k, False: 184k]
  ------------------
 1360|   208k|                temp2 = *riter;
 1361|       |
 1362|       |            // object = last 2 children == { and }
 1363|   393k|            if(temp1 && temp2 &&
  ------------------
  |  Branch (1363:16): [True: 393k, False: 0]
  |  Branch (1363:25): [True: 208k, False: 184k]
  ------------------
 1364|   208k|                temp1->type == CNT_RBRACE && temp2->type == CNT_LBRACE)
  ------------------
  |  Branch (1364:17): [True: 115k, False: 93.6k]
  |  Branch (1364:46): [True: 115k, False: 0]
  ------------------
 1365|   115k|            {
 1366|   115k|                if(node->children.size() < 2)
  ------------------
  |  Branch (1366:20): [True: 0, False: 115k]
  ------------------
 1367|      0|                {
 1368|      0|                    mCompiler->addError(CE_STRINGEXPECTED, node->file, node->line);
 1369|      0|                    return;
 1370|      0|                }
 1371|       |
 1372|   115k|                ObjectAbstractNode *impl = OGRE_NEW ObjectAbstractNode(mCurrent);
 1373|   115k|                impl->line = node->line;
 1374|   115k|                impl->file = node->file;
 1375|   115k|                impl->abstract = false;
 1376|       |
 1377|       |                // Create a temporary detail list
 1378|   115k|                std::list<ConcreteNode*> temp;
 1379|   115k|                if(node->token == "abstract")
  ------------------
  |  Branch (1379:20): [True: 958, False: 114k]
  ------------------
 1380|    958|                {
 1381|    958|                    impl->abstract = true;
 1382|    958|                    for(const auto& c : node->children)
  ------------------
  |  Branch (1382:39): [True: 3.22k, False: 958]
  ------------------
 1383|  3.22k|                        temp.push_back(c.get());
 1384|    958|                }
 1385|   114k|                else
 1386|   114k|                {
 1387|   114k|                    temp.push_back(node);
 1388|   114k|                    for(const auto& c : node->children)
  ------------------
  |  Branch (1388:39): [True: 442k, False: 114k]
  ------------------
 1389|   442k|                        temp.push_back(c.get());
 1390|   114k|                }
 1391|       |
 1392|       |                // Get the type of object
 1393|   115k|                std::list<ConcreteNode*>::const_iterator iter = temp.begin();
 1394|   115k|                impl->cls = (*iter)->token;
 1395|   115k|                ++iter;
 1396|       |
 1397|       |                // try to map the cls to an id
 1398|   115k|                ScriptCompiler::IdMap::const_iterator iter2 = mCompiler->mIds.find(impl->cls);
 1399|   115k|                if(iter2 != mCompiler->mIds.end())
  ------------------
  |  Branch (1399:20): [True: 82.6k, False: 32.4k]
  ------------------
 1400|  82.6k|                {
 1401|  82.6k|                    impl->id = iter2->second;
 1402|  82.6k|                }
 1403|  32.4k|                else
 1404|  32.4k|                {
 1405|  32.4k|                    mCompiler->addError(CE_UNEXPECTEDTOKEN, impl->file, impl->line,
 1406|  32.4k|                                        "'" + impl->cls + "'. If this is a legacy script you must prepend the type (e.g. font, overlay).");
 1407|  32.4k|                }
 1408|       |
 1409|       |                // Get the name
 1410|       |                // Unless the type is in the exclusion list
 1411|   115k|                if(iter != temp.end() && ((*iter)->type == CNT_WORD || (*iter)->type == CNT_QUOTE || (*iter)->type == CNT_VARIABLE) &&
  ------------------
  |  Branch (1411:20): [True: 115k, False: 0]
  |  Branch (1411:20): [True: 61.4k, False: 53.5k]
  |  Branch (1411:43): [True: 63.3k, False: 51.7k]
  |  Branch (1411:72): [True: 290, False: 51.4k]
  |  Branch (1411:102): [True: 522, False: 50.9k]
  ------------------
 1412|  64.1k|                    !mCompiler->isNameExcluded(*impl, mCurrent))
  ------------------
  |  Branch (1412:21): [True: 61.4k, False: 2.67k]
  ------------------
 1413|  61.4k|                {
 1414|  61.4k|                    impl->name = (*iter)->token;
 1415|  61.4k|                    ++iter;
 1416|  61.4k|                }
 1417|       |
 1418|       |                // Everything up until the colon is a "value" of this object
 1419|   240k|                while(iter != temp.end() && (*iter)->type != CNT_COLON && (*iter)->type != CNT_LBRACE)
  ------------------
  |  Branch (1419:23): [True: 240k, False: 344]
  |  Branch (1419:23): [True: 125k, False: 115k]
  |  Branch (1419:45): [True: 221k, False: 19.2k]
  |  Branch (1419:75): [True: 125k, False: 95.4k]
  ------------------
 1420|   125k|                {
 1421|   125k|                    if((*iter)->type == CNT_VARIABLE)
  ------------------
  |  Branch (1421:24): [True: 6.79k, False: 119k]
  ------------------
 1422|  6.79k|                    {
 1423|  6.79k|                        VariableAccessAbstractNode *var = OGRE_NEW VariableAccessAbstractNode(impl);
 1424|  6.79k|                        var->file = (*iter)->file;
 1425|  6.79k|                        var->line = (*iter)->line;
 1426|  6.79k|                        var->type = ANT_VARIABLE_ACCESS;
 1427|  6.79k|                        var->name = (*iter)->token;
 1428|  6.79k|                        impl->values.push_back(AbstractNodePtr(var));
 1429|  6.79k|                    }
 1430|   119k|                    else
 1431|   119k|                    {
 1432|   119k|                        AtomAbstractNode *atom = OGRE_NEW AtomAbstractNode(impl);
 1433|   119k|                        atom->file = (*iter)->file;
 1434|   119k|                        atom->line = (*iter)->line;
 1435|   119k|                        atom->type = ANT_ATOM;
 1436|   119k|                        atom->value = (*iter)->token;
 1437|       |
 1438|   119k|                        auto idpos = mCompiler->mIds.find(atom->value);
 1439|   119k|                        if(idpos != mCompiler->mIds.end())
  ------------------
  |  Branch (1439:28): [True: 3.64k, False: 115k]
  ------------------
 1440|  3.64k|                            atom->id = idpos->second;
 1441|       |
 1442|   119k|                        impl->values.push_back(AbstractNodePtr(atom));
 1443|   119k|                    }
 1444|   125k|                    ++iter;
 1445|   125k|                }
 1446|       |
 1447|       |                // Find the bases
 1448|   115k|                if(iter != temp.end() && (*iter)->type == CNT_COLON)
  ------------------
  |  Branch (1448:20): [True: 114k, False: 344]
  |  Branch (1448:20): [True: 19.2k, False: 95.8k]
  |  Branch (1448:42): [True: 19.2k, False: 95.4k]
  ------------------
 1449|  19.2k|                {
 1450|       |                    // Children of the ':' are bases
 1451|  19.2k|                    for(auto & j : (*iter)->children)
  ------------------
  |  Branch (1451:34): [True: 160k, False: 19.2k]
  ------------------
 1452|   160k|                        impl->bases.push_back(j->token);
 1453|  19.2k|                    ++iter;
 1454|  19.2k|                }
 1455|       |
 1456|   115k|                asn = AbstractNodePtr(impl);
 1457|   115k|                mCurrent = impl;
 1458|       |
 1459|       |                // Visit the children of the {
 1460|   115k|                AbstractTreeBuilder::visit(this, temp2->children);
 1461|       |
 1462|       |                // Go back up the stack
 1463|   115k|                mCurrent = impl->parent;
 1464|   115k|            }
 1465|       |            // Otherwise, it is a property
 1466|   278k|            else
 1467|   278k|            {
 1468|   278k|                PropertyAbstractNode *impl = OGRE_NEW PropertyAbstractNode(mCurrent);
 1469|   278k|                impl->line = node->line;
 1470|   278k|                impl->file = node->file;
 1471|   278k|                impl->name = node->token;
 1472|       |
 1473|   278k|                ScriptCompiler::IdMap::const_iterator iter2 = mCompiler->mIds.find(impl->name);
 1474|   278k|                if(iter2 != mCompiler->mIds.end())
  ------------------
  |  Branch (1474:20): [True: 90.4k, False: 188k]
  ------------------
 1475|  90.4k|                    impl->id = iter2->second;
 1476|       |
 1477|   278k|                asn = AbstractNodePtr(impl);
 1478|   278k|                mCurrent = impl;
 1479|       |
 1480|       |                // Visit the children of the {
 1481|   278k|                AbstractTreeBuilder::visit(this, node->children);
 1482|       |
 1483|       |                // Go back up the stack
 1484|   278k|                mCurrent = impl->parent;
 1485|   278k|            }
 1486|   393k|        }
 1487|       |        // Otherwise, it is a standard atom
 1488|  4.73M|        else
 1489|  4.73M|        {
 1490|  4.73M|            AtomAbstractNode *impl = OGRE_NEW AtomAbstractNode(mCurrent);
 1491|  4.73M|            impl->line = node->line;
 1492|  4.73M|            impl->file = node->file;
 1493|  4.73M|            impl->value = node->token;
 1494|       |
 1495|  4.73M|            ScriptCompiler::IdMap::const_iterator iter2 = mCompiler->mIds.find(impl->value);
 1496|  4.73M|            if(iter2 != mCompiler->mIds.end())
  ------------------
  |  Branch (1496:16): [True: 76.0k, False: 4.65M]
  ------------------
 1497|  76.0k|                impl->id = iter2->second;
 1498|       |
 1499|  4.73M|            asn = AbstractNodePtr(impl);
 1500|       |
 1501|  4.73M|            if(mCurrent && mCurrent->type != ANT_PROPERTY)
  ------------------
  |  Branch (1501:16): [True: 698k, False: 4.03M]
  |  Branch (1501:28): [True: 56.3k, False: 642k]
  ------------------
 1502|  56.3k|            {
 1503|       |                // stray atom outside of a property is likely a property without a value
 1504|  56.3k|                mCompiler->addError(*impl, "missing property value");
 1505|  56.3k|            }
 1506|  4.73M|        }
 1507|       |
 1508|       |        // Here, we must insert the node into the tree
 1509|  6.79M|        if(asn)
  ------------------
  |  Branch (1509:12): [True: 6.78M, False: 5.20k]
  ------------------
 1510|  6.78M|        {
 1511|  6.78M|            if(mCurrent)
  ------------------
  |  Branch (1511:16): [True: 1.09M, False: 5.69M]
  ------------------
 1512|  1.09M|            {
 1513|  1.09M|                if(mCurrent->type == ANT_PROPERTY)
  ------------------
  |  Branch (1513:20): [True: 803k, False: 290k]
  ------------------
 1514|   803k|                {
 1515|   803k|                    PropertyAbstractNode *impl = static_cast<PropertyAbstractNode*>(mCurrent);
 1516|   803k|                    impl->values.push_back(asn);
 1517|   803k|                }
 1518|   290k|                else
 1519|   290k|                {
 1520|   290k|                    ObjectAbstractNode *impl = static_cast<ObjectAbstractNode*>(mCurrent);
 1521|   290k|                    impl->children.push_back(asn);
 1522|   290k|                }
 1523|  1.09M|            }
 1524|  5.69M|            else
 1525|  5.69M|            {
 1526|  5.69M|                mNodes->push_back(asn);
 1527|  5.69M|            }
 1528|  6.78M|        }
 1529|  6.79M|    }
_ZN4Ogre14ScriptCompiler19AbstractTreeBuilder5visitEPS1_RKNSt3__14listINS_9SharedPtrINS_12ConcreteNodeEEENS3_9allocatorIS7_EEEE:
 1532|   955k|    {
 1533|   955k|        for(const auto & node : nodes)
  ------------------
  |  Branch (1533:31): [True: 6.79M, False: 955k]
  ------------------
 1534|  6.79M|            visitor->visit(node.get());
 1535|   955k|    }
_ZN4Ogre21ScriptCompilerManager12getSingletonEv:
 1547|   418k|    {
 1548|       |        assert( msSingleton );  return ( *msSingleton );
 1549|   418k|    }
_ZN4Ogre21ScriptCompilerManagerC2Ev:
 1552|      1|    {
 1553|      1|            OGRE_LOCK_AUTO_MUTEX;
 1554|      1|        mScriptPatterns.push_back("*.program");
 1555|      1|        mScriptPatterns.push_back("*.material");
 1556|      1|        mScriptPatterns.push_back("*.particle");
 1557|      1|        mScriptPatterns.push_back("*.compositor");
 1558|      1|        mScriptPatterns.push_back("*.os");
 1559|      1|        ResourceGroupManager::getSingleton()._registerScriptLoader(this);
 1560|       |
 1561|       |        mBuiltinTranslatorManager = OGRE_NEW BuiltinScriptTranslatorManager();
 1562|      1|        mManagers.push_back(mBuiltinTranslatorManager);
 1563|      1|    }
_ZN4Ogre21ScriptCompilerManager11setListenerEPNS_22ScriptCompilerListenerE:
 1571|      1|    {
 1572|      1|            OGRE_LOCK_AUTO_MUTEX;
 1573|      1|        mScriptCompiler.setListener(listener);
 1574|      1|    }
_ZN4Ogre21ScriptCompilerManager13getTranslatorERKNS_9SharedPtrINS_12AbstractNodeEEE:
 1607|   402k|    {
 1608|   402k|        ScriptTranslator *translator = 0;
 1609|   402k|        {
 1610|   402k|                    OGRE_LOCK_AUTO_MUTEX;
 1611|       |
 1612|       |            // Start looking from the back
 1613|   572k|            for(std::vector<ScriptTranslatorManager*>::reverse_iterator i = mManagers.rbegin(); i != mManagers.rend(); ++i)
  ------------------
  |  Branch (1613:97): [True: 402k, False: 169k]
  ------------------
 1614|   402k|            {
 1615|   402k|                translator = (*i)->getTranslator(node);
 1616|   402k|                if(translator != 0)
  ------------------
  |  Branch (1616:20): [True: 232k, False: 169k]
  ------------------
 1617|   232k|                    break;
 1618|   402k|            }
 1619|   402k|        }
 1620|   402k|        return translator;
 1621|   402k|	}
_ZNK4Ogre21ScriptCompilerManager15getLoadingOrderEv:
 1639|      1|    {
 1640|       |        /// Load relatively early, before most script loaders run
 1641|      1|        return 90.0f;
 1642|      1|    }
_ZN4Ogre21ScriptCompilerManager11parseScriptERNS_9SharedPtrINS_10DataStreamEEERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
 1645|  15.8k|    {
 1646|  15.8k|        ConcreteNodeListPtr nodes =
 1647|  15.8k|            ScriptParser::parse(ScriptLexer::tokenize(stream->getAsString(), stream->getName()), stream->getName());
 1648|  15.8k|        {
 1649|       |            // compile is not reentrant
 1650|  15.8k|            OGRE_LOCK_AUTO_MUTEX;
 1651|  15.8k|            mScriptCompiler.compile(nodes, groupName);
 1652|  15.8k|        }
 1653|  15.8k|    }

_ZN4Ogre11ScriptLexer8tokenizeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
   35|   552k|    {
   36|   552k|        String error;
   37|   552k|        ScriptTokenList ret = _tokenize(str, source.c_str(), error);
   38|       |
   39|   552k|        if (!error.empty())
  ------------------
  |  Branch (39:13): [True: 15.2k, False: 537k]
  ------------------
   40|  15.2k|            LogManager::getSingleton().logError("ScriptLexer - " + error);
   41|       |
   42|   552k|        return ret;
   43|   552k|    }
_ZN4Ogre11ScriptLexer9_tokenizeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKcRS7_:
   46|   552k|    {
   47|       |        // State enums
   48|   552k|        enum{ READY = 0, COMMENT, MULTICOMMENT, WORD, QUOTE, VAR, POSSIBLECOMMENT };
   49|       |
   50|       |        // Set up some constant characters of interest
   51|   552k|        const wchar_t varopener = '$', quote = '\"', slash = '/', backslash = '\\', openbrace = '{', closebrace = '}', colon = ':', star = '*', cr = '\r', lf = '\n';
   52|   552k|        char c = 0, lastc = 0;
   53|       |
   54|   552k|        String lexeme;
   55|   552k|        uint32 line = 1, state = READY, lastQuote = 0, firstOpenBrace = 0, braceLayer = 0;
   56|   552k|        ScriptTokenList tokens;
   57|       |
   58|       |        // Iterate over the input
   59|   552k|        for(char i : str)
  ------------------
  |  Branch (59:20): [True: 63.5M, False: 547k]
  ------------------
   60|  63.5M|        {
   61|  63.5M|            lastc = c;
   62|  63.5M|            c = i;
   63|       |
   64|  63.5M|            if(c == quote)
  ------------------
  |  Branch (64:16): [True: 71.5k, False: 63.4M]
  ------------------
   65|  71.5k|                lastQuote = line;
   66|       |            
   67|  63.5M|            if(state == READY || state == WORD || state == VAR)
  ------------------
  |  Branch (67:16): [True: 11.6M, False: 51.8M]
  |  Branch (67:34): [True: 38.1M, False: 13.6M]
  |  Branch (67:51): [True: 11.0M, False: 2.61M]
  ------------------
   68|  60.8M|            {
   69|  60.8M|                if(c == openbrace)
  ------------------
  |  Branch (69:20): [True: 224k, False: 60.6M]
  ------------------
   70|   224k|                {
   71|   224k|                    if(braceLayer == 0)
  ------------------
  |  Branch (71:24): [True: 34.8k, False: 189k]
  ------------------
   72|  34.8k|                        firstOpenBrace = line;
   73|       |
   74|   224k|                    if (braceLayer >= MAX_BRACE_LAYER)
  ------------------
  |  Branch (74:25): [True: 214, False: 224k]
  ------------------
   75|    214|                    {
   76|    214|                        error = StringUtil::format("too deeply nested open brackets '{' (max %u) at %s:%d",
   77|    214|                                                   MAX_BRACE_LAYER, source, line);
   78|    214|                        return tokens;
   79|    214|                    }
   80|       |
   81|   224k|                    braceLayer ++;
   82|   224k|                }
   83|  60.6M|                else if(c == closebrace)
  ------------------
  |  Branch (83:25): [True: 194k, False: 60.4M]
  ------------------
   84|   194k|                {
   85|   194k|                    if (braceLayer == 0)
  ------------------
  |  Branch (85:25): [True: 4.41k, False: 190k]
  ------------------
   86|  4.41k|                    {
   87|  4.41k|                        error = StringUtil::format(
   88|  4.41k|                            "no matching open bracket '{' found for close bracket '}' at %s:%d", source,
   89|  4.41k|                            line);
   90|  4.41k|                        return tokens;
   91|  4.41k|                    }
   92|       |
   93|   190k|                    braceLayer --;
   94|   190k|                }
   95|  60.8M|            }
   96|       |            
   97|       |            
   98|  63.4M|            switch(state)
  ------------------
  |  Branch (98:20): [True: 63.4M, False: 0]
  ------------------
   99|  63.4M|            {
  100|  11.6M|            case READY:
  ------------------
  |  Branch (100:13): [True: 11.6M, False: 51.8M]
  ------------------
  101|  11.6M|                if(c == slash && lastc == slash)
  ------------------
  |  Branch (101:20): [True: 20.5k, False: 11.6M]
  |  Branch (101:34): [True: 212, False: 20.3k]
  ------------------
  102|    212|                {
  103|       |                    // Comment start, clear out the lexeme
  104|    212|                    lexeme = "";
  105|    212|                    state = COMMENT;
  106|    212|                }
  107|  11.6M|                else if(c == star && lastc == slash)
  ------------------
  |  Branch (107:25): [True: 15.4k, False: 11.6M]
  |  Branch (107:38): [True: 351, False: 15.0k]
  ------------------
  108|    351|                {
  109|    351|                    lexeme = "";
  110|    351|                    state = MULTICOMMENT;
  111|    351|                }
  112|  11.6M|                else if(c == quote)
  ------------------
  |  Branch (112:25): [True: 24.9k, False: 11.6M]
  ------------------
  113|  24.9k|                {
  114|       |                    // Clear out the lexeme ready to be filled with quotes!
  115|  24.9k|                    lexeme = c;
  116|  24.9k|                    state = QUOTE;
  117|  24.9k|                }
  118|  11.6M|                else if(c == varopener)
  ------------------
  |  Branch (118:25): [True: 1.78M, False: 9.86M]
  ------------------
  119|  1.78M|                {
  120|       |                    // Set up to read in a variable
  121|  1.78M|                    lexeme = c;
  122|  1.78M|                    state = VAR;
  123|  1.78M|                }
  124|  9.86M|                else if(isNewline(c))
  ------------------
  |  Branch (124:25): [True: 95.6k, False: 9.76M]
  ------------------
  125|  95.6k|                {
  126|  95.6k|                    lexeme = c;
  127|  95.6k|                    setToken(lexeme, line, tokens);
  128|  95.6k|                }
  129|  9.76M|                else if(!isWhitespace(c))
  ------------------
  |  Branch (129:25): [True: 5.50M, False: 4.25M]
  ------------------
  130|  5.50M|                {
  131|  5.50M|                    lexeme = c;
  132|  5.50M|                    if(c == slash)
  ------------------
  |  Branch (132:24): [True: 20.3k, False: 5.48M]
  ------------------
  133|  20.3k|                        state = POSSIBLECOMMENT;
  134|  5.48M|                    else
  135|  5.48M|                        state = WORD;
  136|  5.50M|                }
  137|  11.6M|                break;
  138|   295k|            case COMMENT:
  ------------------
  |  Branch (138:13): [True: 295k, False: 63.2M]
  ------------------
  139|   295k|                if(isNewline(c))
  ------------------
  |  Branch (139:20): [True: 8.10k, False: 286k]
  ------------------
  140|  8.10k|                {
  141|  8.10k|                    lexeme = c;
  142|  8.10k|                    setToken(lexeme, line, tokens);
  143|  8.10k|                    state = READY;
  144|  8.10k|                }
  145|   295k|                break;
  146|  2.05k|            case MULTICOMMENT:
  ------------------
  |  Branch (146:13): [True: 2.05k, False: 63.4M]
  ------------------
  147|  2.05k|                if(c == slash && lastc == star)
  ------------------
  |  Branch (147:20): [True: 989, False: 1.06k]
  |  Branch (147:34): [True: 777, False: 212]
  ------------------
  148|    777|                    state = READY;
  149|  2.05k|                break;
  150|  20.0k|            case POSSIBLECOMMENT:
  ------------------
  |  Branch (150:13): [True: 20.0k, False: 63.4M]
  ------------------
  151|  20.0k|                if(c == slash && lastc == slash)
  ------------------
  |  Branch (151:20): [True: 8.38k, False: 11.6k]
  |  Branch (151:34): [True: 8.38k, False: 0]
  ------------------
  152|  8.38k|                {
  153|  8.38k|                    lexeme = "";
  154|  8.38k|                    state = COMMENT;
  155|  8.38k|                    break;  
  156|  8.38k|                }
  157|  11.6k|                else if(c == star && lastc == slash)
  ------------------
  |  Branch (157:25): [True: 511, False: 11.1k]
  |  Branch (157:38): [True: 511, False: 0]
  ------------------
  158|    511|                {
  159|    511|                    lexeme = "";
  160|    511|                    state = MULTICOMMENT;
  161|    511|                    break;
  162|    511|                }
  163|  11.1k|                else
  164|  11.1k|                {
  165|  11.1k|                    state = WORD;
  166|  11.1k|                    OGRE_FALLTHROUGH;
  167|  11.1k|                }
  168|  38.1M|            case WORD:
  ------------------
  |  Branch (168:13): [True: 38.1M, False: 25.3M]
  ------------------
  169|  38.1M|                if(isNewline(c))
  ------------------
  |  Branch (169:20): [True: 370k, False: 37.7M]
  ------------------
  170|   370k|                {
  171|   370k|                    setToken(lexeme, line, tokens);
  172|   370k|                    lexeme = c;
  173|   370k|                    setToken(lexeme, line, tokens);
  174|   370k|                    state = READY;
  175|   370k|                }
  176|  37.7M|                else if(isWhitespace(c))
  ------------------
  |  Branch (176:25): [True: 4.42M, False: 33.3M]
  ------------------
  177|  4.42M|                {
  178|  4.42M|                    setToken(lexeme, line, tokens);
  179|  4.42M|                    state = READY;
  180|  4.42M|                }
  181|  33.3M|                else if(c == openbrace || c == closebrace || c == colon)
  ------------------
  |  Branch (181:25): [True: 85.5k, False: 33.2M]
  |  Branch (181:43): [True: 68.1k, False: 33.2M]
  |  Branch (181:62): [True: 21.8k, False: 33.1M]
  ------------------
  182|   175k|                {
  183|   175k|                    setToken(lexeme, line, tokens);
  184|   175k|                    lexeme = c;
  185|   175k|                    setToken(lexeme, line, tokens);
  186|   175k|                    state = READY;
  187|   175k|                }
  188|  33.1M|                else
  189|  33.1M|                {
  190|  33.1M|                    lexeme += c;
  191|  33.1M|                }
  192|  38.1M|                break;
  193|  2.29M|            case QUOTE:
  ------------------
  |  Branch (193:13): [True: 2.29M, False: 61.1M]
  ------------------
  194|  2.29M|                if(c != backslash)
  ------------------
  |  Branch (194:20): [True: 2.29M, False: 4.34k]
  ------------------
  195|  2.29M|                {
  196|       |                    // Allow embedded quotes with escaping
  197|  2.29M|                    if(c == quote && lastc == backslash)
  ------------------
  |  Branch (197:24): [True: 24.6k, False: 2.26M]
  |  Branch (197:38): [True: 518, False: 24.1k]
  ------------------
  198|    518|                    {
  199|    518|                        lexeme += c;
  200|    518|                    }
  201|  2.29M|                    else if(c == quote)
  ------------------
  |  Branch (201:29): [True: 24.1k, False: 2.26M]
  ------------------
  202|  24.1k|                    {
  203|  24.1k|                        lexeme += c;
  204|  24.1k|                        setToken(lexeme, line, tokens);
  205|  24.1k|                        state = READY;
  206|  24.1k|                    }
  207|  2.26M|                    else
  208|  2.26M|                    {
  209|       |                        // Backtrack here and allow a backslash normally within the quote
  210|  2.26M|                        if(lastc == backslash)
  ------------------
  |  Branch (210:28): [True: 3.61k, False: 2.26M]
  ------------------
  211|  3.61k|                            lexeme = lexeme + "\\" + c;
  212|  2.26M|                        else
  213|  2.26M|                            lexeme += c;
  214|  2.26M|                    }
  215|  2.29M|                }
  216|  2.29M|                break;
  217|  11.0M|            case VAR:
  ------------------
  |  Branch (217:13): [True: 11.0M, False: 52.4M]
  ------------------
  218|  11.0M|                if(isNewline(c))
  ------------------
  |  Branch (218:20): [True: 4.35k, False: 11.0M]
  ------------------
  219|  4.35k|                {
  220|  4.35k|                    setToken(lexeme, line, tokens);
  221|  4.35k|                    lexeme = c;
  222|  4.35k|                    setToken(lexeme, line, tokens);
  223|  4.35k|                    state = READY;
  224|  4.35k|                }
  225|  11.0M|                else if(isWhitespace(c))
  ------------------
  |  Branch (225:25): [True: 1.76M, False: 9.29M]
  ------------------
  226|  1.76M|                {
  227|  1.76M|                    setToken(lexeme, line, tokens);
  228|  1.76M|                    state = READY;
  229|  1.76M|                }
  230|  9.29M|                else if(c == openbrace || c == closebrace || c == colon)
  ------------------
  |  Branch (230:25): [True: 1.60k, False: 9.29M]
  |  Branch (230:43): [True: 724, False: 9.28M]
  |  Branch (230:62): [True: 1.19k, False: 9.28M]
  ------------------
  231|  3.52k|                {
  232|  3.52k|                    setToken(lexeme, line, tokens);
  233|  3.52k|                    lexeme = c;
  234|  3.52k|                    setToken(lexeme, line, tokens);
  235|  3.52k|                    state = READY;
  236|  3.52k|                }
  237|  9.28M|                else
  238|  9.28M|                {
  239|  9.28M|                    lexeme += c;
  240|  9.28M|                }
  241|  11.0M|                break;
  242|  63.4M|            }
  243|       |
  244|       |            // Separate check for newlines just to track line numbers
  245|  63.4M|            if(c == cr || (c == lf && lastc != cr))
  ------------------
  |  Branch (245:16): [True: 8.33k, False: 63.4M]
  |  Branch (245:28): [True: 507k, False: 62.9M]
  |  Branch (245:39): [True: 507k, False: 284]
  ------------------
  246|   516k|                line++;
  247|  63.4M|        }
  248|       |
  249|       |        // Check for valid exit states
  250|   547k|        if(state == WORD || state == VAR)
  ------------------
  |  Branch (250:12): [True: 527k, False: 20.2k]
  |  Branch (250:29): [True: 8.74k, False: 11.4k]
  ------------------
  251|   536k|        {
  252|   536k|            if(!lexeme.empty())
  ------------------
  |  Branch (252:16): [True: 536k, False: 0]
  ------------------
  253|   536k|                setToken(lexeme, line, tokens);
  254|   536k|        }
  255|  11.4k|        else
  256|  11.4k|        {
  257|  11.4k|            if(state == QUOTE)
  ------------------
  |  Branch (257:16): [True: 757, False: 10.7k]
  ------------------
  258|    757|            {
  259|    757|                error = StringUtil::format("no matching \" found for \" at %s:%d", source, lastQuote);
  260|    757|                return tokens;
  261|    757|            }
  262|  11.4k|        }
  263|       |        
  264|       |        // Check that all opened brackets have been closed
  265|   547k|        if (braceLayer == 1)
  ------------------
  |  Branch (265:13): [True: 4.21k, False: 542k]
  ------------------
  266|  4.21k|        {
  267|  4.21k|            error = StringUtil::format("no matching closing bracket '}' for open bracket '{' at %s:%d",
  268|  4.21k|                                       source, firstOpenBrace);
  269|  4.21k|        }
  270|   542k|        else if (braceLayer > 1)
  ------------------
  |  Branch (270:18): [True: 5.59k, False: 537k]
  ------------------
  271|  5.59k|        {
  272|  5.59k|            error = StringUtil::format(
  273|  5.59k|                "too many open brackets (%d) '{' without matching closing bracket '}' in %s", braceLayer,
  274|  5.59k|                source);
  275|  5.59k|        }
  276|       |       
  277|   547k|        return tokens;
  278|   547k|    }
_ZN4Ogre11ScriptLexer8setTokenERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjRNS1_6vectorINS_11ScriptTokenENS5_ISB_EEEE:
  281|  7.95M|    {
  282|  7.95M|        const char openBracket = '{', closeBracket = '}', colon = ':',
  283|  7.95M|            quote = '\"', var = '$';
  284|       |
  285|  7.95M|        ScriptToken token;
  286|  7.95M|        token.line = line;
  287|  7.95M|        bool ignore = false;
  288|       |
  289|       |        // Check the user token map first
  290|  7.95M|        if(lexeme.size() == 1 && isNewline(lexeme[0]))
  ------------------
  |  Branch (290:12): [True: 2.45M, False: 5.50M]
  |  Branch (290:34): [True: 478k, False: 1.97M]
  ------------------
  291|   478k|        {
  292|   478k|            token.type = TID_NEWLINE;
  293|   478k|            if(!tokens.empty() && tokens.back().type == TID_NEWLINE)
  ------------------
  |  Branch (293:16): [True: 475k, False: 3.39k]
  |  Branch (293:35): [True: 54.6k, False: 420k]
  ------------------
  294|  54.6k|                ignore = true;
  295|   478k|        }
  296|  7.47M|        else if(lexeme.size() == 1 && lexeme[0] == openBracket)
  ------------------
  |  Branch (296:17): [True: 1.97M, False: 5.50M]
  |  Branch (296:39): [True: 193k, False: 1.78M]
  ------------------
  297|   193k|            token.type = TID_LBRACKET;
  298|  7.28M|        else if(lexeme.size() == 1 && lexeme[0] == closeBracket)
  ------------------
  |  Branch (298:17): [True: 1.78M, False: 5.50M]
  |  Branch (298:39): [True: 140k, False: 1.64M]
  ------------------
  299|   140k|            token.type = TID_RBRACKET;
  300|  7.14M|        else if(lexeme.size() == 1 && lexeme[0] == colon)
  ------------------
  |  Branch (300:17): [True: 1.64M, False: 5.50M]
  |  Branch (300:39): [True: 45.5k, False: 1.59M]
  ------------------
  301|  45.5k|            token.type = TID_COLON;
  302|  7.10M|        else
  303|  7.10M|        {
  304|  7.10M|            token.lexeme = lexeme;
  305|       |
  306|       |            // This is either a non-zero length phrase or quoted phrase
  307|  7.10M|            if(lexeme.size() >= 2 && lexeme[0] == quote && lexeme[lexeme.size() - 1] == quote)
  ------------------
  |  Branch (307:16): [True: 5.50M, False: 1.59M]
  |  Branch (307:38): [True: 24.1k, False: 5.47M]
  |  Branch (307:60): [True: 24.1k, False: 0]
  ------------------
  308|  24.1k|            {
  309|  24.1k|                token.type = TID_QUOTE;
  310|  24.1k|            }
  311|  7.07M|            else if(lexeme.size() > 1 && lexeme[0] == var)
  ------------------
  |  Branch (311:21): [True: 5.47M, False: 1.59M]
  |  Branch (311:42): [True: 1.66M, False: 3.80M]
  ------------------
  312|  1.66M|                token.type = TID_VARIABLE;
  313|  5.40M|            else
  314|  5.40M|            {
  315|  5.40M|                token.type = TID_WORD;
  316|  5.40M|            }
  317|  7.10M|        }
  318|       |
  319|  7.95M|        if(!ignore)
  ------------------
  |  Branch (319:12): [True: 7.90M, False: 54.6k]
  ------------------
  320|  7.90M|            tokens.push_back(token);
  321|  7.95M|    }
_ZN4Ogre11ScriptLexer12isWhitespaceEc:
  324|  58.6M|    {
  325|  58.6M|        return c == ' ' || c == '\r' || c == '\t';
  ------------------
  |  Branch (325:16): [True: 9.75M, False: 48.8M]
  |  Branch (325:28): [True: 0, False: 48.8M]
  |  Branch (325:41): [True: 689k, False: 48.1M]
  ------------------
  326|  58.6M|    }
_ZN4Ogre11ScriptLexer9isNewlineEc:
  329|  61.8M|    {
  330|  61.8M|        return c == '\n' || c == '\r';
  ------------------
  |  Branch (330:16): [True: 941k, False: 60.8M]
  |  Branch (330:29): [True: 15.2k, False: 60.8M]
  ------------------
  331|  61.8M|    }

_ZN4Ogre12ScriptParser5parseERKNSt3__16vectorINS_11ScriptTokenENS1_9allocatorIS3_EEEERKNS1_12basic_stringIcNS1_11char_traitsIcEENS4_IcEEEE:
   42|  15.8k|    {
   43|  15.8k|        auto nodes = std::make_shared<ConcreteNodeList>();
   44|       |
   45|  15.8k|        enum{READY, OBJECT};
   46|  15.8k|        uint32 state = READY;
   47|       |
   48|  15.8k|        ConcreteNode *parent = 0;
   49|  15.8k|        ConcreteNodePtr node;
   50|  15.8k|        const ScriptToken *token = 0;
   51|  15.8k|        ScriptTokenList::const_iterator i = tokens.begin(), end = tokens.end();
   52|  2.07M|        while(i != end)
  ------------------
  |  Branch (52:15): [True: 2.06M, False: 15.8k]
  ------------------
   53|  2.06M|        {
   54|  2.06M|            token = &*i;
   55|       |
   56|  2.06M|            switch(state)
  ------------------
  |  Branch (56:20): [True: 2.06M, False: 0]
  ------------------
   57|  2.06M|            {
   58|   717k|            case READY:
  ------------------
  |  Branch (58:13): [True: 717k, False: 1.34M]
  ------------------
   59|   717k|                if(token->type == TID_WORD)
  ------------------
  |  Branch (59:20): [True: 424k, False: 292k]
  ------------------
   60|   424k|                {
   61|   424k|                    if(token->lexeme == "import")
  ------------------
  |  Branch (61:24): [True: 10.2k, False: 414k]
  ------------------
   62|  10.2k|                    {
   63|  10.2k|                        node = std::make_shared<ConcreteNode>();
   64|  10.2k|                        node->token = token->lexeme;
   65|  10.2k|                        node->file = file;
   66|  10.2k|                        node->line = token->line;
   67|  10.2k|                        node->type = CNT_IMPORT;
   68|       |
   69|       |                        // The next token is the target
   70|  10.2k|                        ++i;
   71|  10.2k|                        if(i == end || (i->type != TID_WORD && i->type != TID_QUOTE))
  ------------------
  |  Branch (71:28): [True: 1, False: 10.2k]
  |  Branch (71:41): [True: 1.27k, False: 8.98k]
  |  Branch (71:64): [True: 3, False: 1.27k]
  ------------------
   72|  10.2k|                            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 
   73|  10.2k|                                Ogre::String("expected import target at line ") + 
   74|  10.2k|                                    Ogre::StringConverter::toString(node->line),
   75|  10.2k|                                "ScriptParser::parse");
   76|  10.2k|                        ConcreteNodePtr temp(OGRE_NEW ConcreteNode());
   77|  10.2k|                        temp->parent = node.get();
   78|  10.2k|                        temp->file = file;
   79|  10.2k|                        temp->line = i->line;
   80|  10.2k|                        temp->type = i->type == TID_WORD ? CNT_WORD : CNT_QUOTE;
  ------------------
  |  Branch (80:38): [True: 8.98k, False: 1.27k]
  ------------------
   81|  10.2k|                        temp->token = unquoted(i->lexeme, temp->type == CNT_QUOTE);
   82|  10.2k|                        node->children.push_back(temp);
   83|       |
   84|       |                        // The next token must be "from"
   85|  10.2k|                        ++i;
   86|  10.2k|                        if (i == end || i->type != TID_WORD || i->lexeme != "from")
  ------------------
  |  Branch (86:29): [True: 7, False: 10.2k]
  |  Branch (86:41): [True: 1, False: 10.2k]
  |  Branch (86:64): [True: 16, False: 10.2k]
  ------------------
   87|  10.2k|                            OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
   88|  10.2k|                                        StringUtil::format("expected 'from' at line %d", node->line));
   89|       |                        // The token after "from" is the source
   90|  10.2k|                        ++i;
   91|  10.2k|                        if(i == end || (i->type != TID_WORD && i->type != TID_QUOTE))
  ------------------
  |  Branch (91:28): [True: 3, False: 10.2k]
  |  Branch (91:41): [True: 3.69k, False: 6.54k]
  |  Branch (91:64): [True: 3, False: 3.68k]
  ------------------
   92|  10.2k|                            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 
   93|  10.2k|                                Ogre::String("expected import source at line ") + 
   94|  10.2k|                                    Ogre::StringConverter::toString(node->line),
   95|  10.2k|                                "ScriptParser::parse");
   96|  10.2k|                        temp = std::make_shared<ConcreteNode>();
   97|  10.2k|                        temp->parent = node.get();
   98|  10.2k|                        temp->file = file;
   99|  10.2k|                        temp->line = i->line;
  100|  10.2k|                        temp->type = i->type == TID_WORD ? CNT_WORD : CNT_QUOTE;
  ------------------
  |  Branch (100:38): [True: 6.54k, False: 3.68k]
  ------------------
  101|  10.2k|                        temp->token = unquoted(i->lexeme, temp->type == CNT_QUOTE);
  102|  10.2k|                        node->children.push_back(temp);
  103|       |
  104|       |                        // Consume all the newlines
  105|  10.2k|                        i = skipNewlines(i, end);
  106|       |
  107|       |                        // Insert the node
  108|  10.2k|                        if(parent)
  ------------------
  |  Branch (108:28): [True: 747, False: 9.48k]
  ------------------
  109|    747|                        {
  110|    747|                            node->parent = parent;
  111|    747|                            parent->children.push_back(node);
  112|    747|                        }
  113|  9.48k|                        else
  114|  9.48k|                        {
  115|  9.48k|                            node->parent = 0;
  116|  9.48k|                            nodes->push_back(node);
  117|  9.48k|                        }
  118|  10.2k|                        node = ConcreteNodePtr();
  119|  10.2k|                    }
  120|   414k|                    else if(token->lexeme == "set")
  ------------------
  |  Branch (120:29): [True: 5.30k, False: 408k]
  ------------------
  121|  5.30k|                    {
  122|  5.30k|                        node = std::make_shared<ConcreteNode>();
  123|  5.30k|                        node->token = token->lexeme;
  124|  5.30k|                        node->file = file;
  125|  5.30k|                        node->line = token->line;
  126|  5.30k|                        node->type = CNT_VARIABLE_ASSIGN;
  127|       |
  128|       |                        // The next token is the variable
  129|  5.30k|                        ++i;
  130|  5.30k|                        if(i == end || i->type != TID_VARIABLE)
  ------------------
  |  Branch (130:28): [True: 4, False: 5.29k]
  |  Branch (130:40): [True: 3, False: 5.29k]
  ------------------
  131|  5.30k|                            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 
  132|  5.29k|                                Ogre::String("expected variable name at line ") + 
  133|  5.29k|                                    Ogre::StringConverter::toString(node->line),
  134|  5.29k|                                "ScriptParser::parse");
  135|  5.29k|                        ConcreteNodePtr temp(OGRE_NEW ConcreteNode());
  136|  5.29k|                        temp->parent = node.get();
  137|  5.29k|                        temp->file = file;
  138|  5.29k|                        temp->line = i->line;
  139|  5.29k|                        temp->type = CNT_VARIABLE;
  140|  5.29k|                        temp->token = i->lexeme;
  141|  5.29k|                        node->children.push_back(temp);
  142|       |
  143|       |                        // The next token is the assignment
  144|  5.29k|                        ++i;
  145|  5.29k|                        if(i == end || (i->type != TID_WORD && i->type != TID_QUOTE))
  ------------------
  |  Branch (145:28): [True: 7, False: 5.28k]
  |  Branch (145:41): [True: 1.22k, False: 4.06k]
  |  Branch (145:64): [True: 4, False: 1.21k]
  ------------------
  146|  5.29k|                            OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 
  147|  5.28k|                                Ogre::String("expected variable value at line ") + 
  148|  5.28k|                                    Ogre::StringConverter::toString(node->line),
  149|  5.28k|                                "ScriptParser::parse");
  150|  5.28k|                        temp = std::make_shared<ConcreteNode>();
  151|  5.28k|                        temp->parent = node.get();
  152|  5.28k|                        temp->file = file;
  153|  5.28k|                        temp->line = i->line;
  154|  5.28k|                        temp->type = i->type == TID_WORD ? CNT_WORD : CNT_QUOTE;
  ------------------
  |  Branch (154:38): [True: 4.06k, False: 1.21k]
  ------------------
  155|  5.28k|                        temp->token = unquoted(i->lexeme, temp->type == CNT_QUOTE);
  156|  5.28k|                        node->children.push_back(temp);
  157|       |
  158|       |                        // Consume all the newlines
  159|  5.28k|                        i = skipNewlines(i, end);
  160|       |
  161|       |                        // Insert the node
  162|  5.28k|                        if(parent)
  ------------------
  |  Branch (162:28): [True: 4.03k, False: 1.24k]
  ------------------
  163|  4.03k|                        {
  164|  4.03k|                            node->parent = parent;
  165|  4.03k|                            parent->children.push_back(node);
  166|  4.03k|                        }
  167|  1.24k|                        else
  168|  1.24k|                        {
  169|  1.24k|                            node->parent = 0;
  170|  1.24k|                            nodes->push_back(node);
  171|  1.24k|                        }
  172|  5.28k|                        node = ConcreteNodePtr();
  173|  5.28k|                    }
  174|   408k|                    else
  175|   408k|                    {
  176|   408k|                        node = std::make_shared<ConcreteNode>();
  177|   408k|                        node->file = file;
  178|   408k|                        node->line = token->line;
  179|   408k|                        node->type = token->type == TID_WORD ? CNT_WORD : CNT_QUOTE;
  ------------------
  |  Branch (179:38): [True: 408k, False: 0]
  ------------------
  180|   408k|                        node->token = unquoted(token->lexeme, node->type == CNT_QUOTE);
  181|       |
  182|       |                        // Insert the node
  183|   408k|                        if(parent)
  ------------------
  |  Branch (183:28): [True: 344k, False: 64.2k]
  ------------------
  184|   344k|                        {
  185|   344k|                            node->parent = parent;
  186|   344k|                            parent->children.push_back(node);
  187|   344k|                        }
  188|  64.2k|                        else
  189|  64.2k|                        {
  190|  64.2k|                            node->parent = 0;
  191|  64.2k|                            nodes->push_back(node);
  192|  64.2k|                        }
  193|       |
  194|       |                        // Set the parent
  195|   408k|                        parent = node.get();
  196|       |
  197|       |                        // Switch states
  198|   408k|                        state = OBJECT;
  199|       |
  200|   408k|                        node = ConcreteNodePtr();
  201|   408k|                    }
  202|   424k|                }
  203|   292k|                else if(token->type == TID_RBRACKET)
  ------------------
  |  Branch (203:25): [True: 88.1k, False: 204k]
  ------------------
  204|  88.1k|                {
  205|       |                    // Go up one level if we can
  206|  88.1k|                    if(parent)
  ------------------
  |  Branch (206:24): [True: 81.9k, False: 6.20k]
  ------------------
  207|  81.9k|                        parent = parent->parent;
  208|       |
  209|  88.1k|                    node = std::make_shared<ConcreteNode>();
  210|  88.1k|                    node->token = token->lexeme;
  211|  88.1k|                    node->file = file;
  212|  88.1k|                    node->line = token->line;
  213|  88.1k|                    node->type = CNT_RBRACE;
  214|       |
  215|       |                    // Consume all the newlines
  216|  88.1k|                    i = skipNewlines(i, end);
  217|       |
  218|       |                    // Insert the node
  219|  88.1k|                    if(parent)
  ------------------
  |  Branch (219:24): [True: 81.9k, False: 6.20k]
  ------------------
  220|  81.9k|                    {
  221|  81.9k|                        node->parent = parent;
  222|  81.9k|                        parent->children.push_back(node);
  223|  81.9k|                    }
  224|  6.20k|                    else
  225|  6.20k|                    {
  226|  6.20k|                        node->parent = 0;
  227|  6.20k|                        nodes->push_back(node);
  228|  6.20k|                    }
  229|       |
  230|       |                    // Move up another level
  231|  88.1k|                    if(parent)
  ------------------
  |  Branch (231:24): [True: 81.9k, False: 6.20k]
  ------------------
  232|  81.9k|                        parent = parent->parent;
  233|       |
  234|  88.1k|                    node = ConcreteNodePtr();
  235|  88.1k|                }
  236|   717k|                break;
  237|  1.34M|            case OBJECT:
  ------------------
  |  Branch (237:13): [True: 1.34M, False: 717k]
  ------------------
  238|  1.34M|                if(token->type == TID_NEWLINE)
  ------------------
  |  Branch (238:20): [True: 247k, False: 1.09M]
  ------------------
  239|   247k|                {
  240|       |                    // Look ahead to the next non-newline token and if it isn't an {, this was a property
  241|   247k|                    ScriptTokenList::const_iterator next = skipNewlines(i, end);
  242|   247k|                    if(next == end || next->type != TID_LBRACKET)
  ------------------
  |  Branch (242:24): [True: 709, False: 246k]
  |  Branch (242:39): [True: 183k, False: 63.0k]
  ------------------
  243|   183k|                    {
  244|       |                        // Ended a property here
  245|   183k|                        if(parent)
  ------------------
  |  Branch (245:28): [True: 183k, False: 0]
  ------------------
  246|   183k|                            parent = parent->parent;
  247|   183k|                        state = READY;
  248|   183k|                    }
  249|   247k|                }
  250|  1.09M|                else if(token->type == TID_COLON)
  ------------------
  |  Branch (250:25): [True: 36.4k, False: 1.05M]
  ------------------
  251|  36.4k|                {
  252|  36.4k|                    node = std::make_shared<ConcreteNode>();
  253|  36.4k|                    node->token = token->lexeme;
  254|  36.4k|                    node->file = file;
  255|  36.4k|                    node->line = token->line;
  256|  36.4k|                    node->type = CNT_COLON;
  257|       |
  258|       |                    // The following token are the parent objects (base classes).
  259|       |                    // Require at least one of them.
  260|       |
  261|  36.4k|                    ScriptTokenList::const_iterator j = i + 1;
  262|  36.4k|                    j = skipNewlines(j, end);
  263|  36.4k|                    if(j == end || (j->type != TID_WORD && j->type != TID_QUOTE)) {
  ------------------
  |  Branch (263:24): [True: 22, False: 36.4k]
  |  Branch (263:37): [True: 374, False: 36.0k]
  |  Branch (263:60): [True: 16, False: 358]
  ------------------
  264|     38|                        OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 
  265|     38|                            Ogre::String("expected object identifier at line ") + 
  266|     38|                                    Ogre::StringConverter::toString(node->line),
  267|     38|                            "ScriptParser::parse");
  268|     38|                    }
  269|       |
  270|   235k|                    while(j != end && (j->type == TID_WORD || j->type == TID_QUOTE))
  ------------------
  |  Branch (270:27): [True: 235k, False: 129]
  |  Branch (270:40): [True: 198k, False: 36.9k]
  |  Branch (270:63): [True: 656, False: 36.3k]
  ------------------
  271|   199k|                    {
  272|   199k|                        ConcreteNodePtr tempNode = std::make_shared<ConcreteNode>();
  273|   199k|                        tempNode->token = j->lexeme;
  274|   199k|                        tempNode->file = file;
  275|   199k|                        tempNode->line = j->line;
  276|   199k|                        tempNode->type = j->type == TID_WORD ? CNT_WORD : CNT_QUOTE;
  ------------------
  |  Branch (276:42): [True: 198k, False: 656]
  ------------------
  277|   199k|                        tempNode->parent = node.get();
  278|   199k|                        node->children.push_back(tempNode);
  279|   199k|                        ++j;
  280|   199k|                    }
  281|       |
  282|       |                    // Move it backwards once, since the end of the loop moves it forwards again anyway
  283|  36.4k|                    i = --j;
  284|       |
  285|       |                    // Insert the node
  286|  36.4k|                    if(parent)
  ------------------
  |  Branch (286:24): [True: 36.4k, False: 0]
  ------------------
  287|  36.4k|                    {
  288|  36.4k|                        node->parent = parent;
  289|  36.4k|                        parent->children.push_back(node);
  290|  36.4k|                    }
  291|      0|                    else
  292|      0|                    {
  293|      0|                        node->parent = 0;
  294|      0|                        nodes->push_back(node);
  295|      0|                    }
  296|  36.4k|                    node = ConcreteNodePtr();
  297|  36.4k|                }
  298|  1.05M|                else if(token->type == TID_LBRACKET)
  ------------------
  |  Branch (298:25): [True: 167k, False: 891k]
  ------------------
  299|   167k|                {
  300|   167k|                    node = std::make_shared<ConcreteNode>();
  301|   167k|                    node->token = token->lexeme;
  302|   167k|                    node->file = file;
  303|   167k|                    node->line = token->line;
  304|   167k|                    node->type = CNT_LBRACE;
  305|       |
  306|       |                    // Consume all the newlines
  307|   167k|                    i = skipNewlines(i, end);
  308|       |
  309|       |                    // Insert the node
  310|   167k|                    if(parent)
  ------------------
  |  Branch (310:24): [True: 167k, False: 0]
  ------------------
  311|   167k|                    {
  312|   167k|                        node->parent = parent;
  313|   167k|                        parent->children.push_back(node);
  314|   167k|                    }
  315|      0|                    else
  316|      0|                    {
  317|      0|                        node->parent = 0;
  318|      0|                        nodes->push_back(node);
  319|      0|                    }
  320|       |
  321|       |                    // Set the parent
  322|   167k|                    parent = node.get();
  323|       |
  324|       |                    // Change the state
  325|   167k|                    state = READY;
  326|       |
  327|   167k|                    node = ConcreteNodePtr();
  328|   167k|                }
  329|   891k|                else if(token->type == TID_RBRACKET)
  ------------------
  |  Branch (329:25): [True: 51.7k, False: 839k]
  ------------------
  330|  51.7k|                {
  331|       |                    // Go up one level if we can
  332|  51.7k|                    if(parent)
  ------------------
  |  Branch (332:24): [True: 51.7k, False: 0]
  ------------------
  333|  51.7k|                        parent = parent->parent;
  334|       |
  335|       |                    // If the parent is currently a { then go up again
  336|  51.7k|                    if(parent && parent->type == CNT_LBRACE && parent->parent)
  ------------------
  |  Branch (336:24): [True: 33.1k, False: 18.6k]
  |  Branch (336:34): [True: 33.1k, False: 0]
  |  Branch (336:64): [True: 33.1k, False: 0]
  ------------------
  337|  33.1k|                        parent = parent->parent;
  338|       |
  339|  51.7k|                    node = std::make_shared<ConcreteNode>();
  340|  51.7k|                    node->token = token->lexeme;
  341|  51.7k|                    node->file = file;
  342|  51.7k|                    node->line = token->line;
  343|  51.7k|                    node->type = CNT_RBRACE;
  344|       |
  345|       |                    // Consume all the newlines
  346|  51.7k|                    i = skipNewlines(i, end);
  347|       |
  348|       |                    // Insert the node
  349|  51.7k|                    if(parent)
  ------------------
  |  Branch (349:24): [True: 33.1k, False: 18.6k]
  ------------------
  350|  33.1k|                    {
  351|  33.1k|                        node->parent = parent;
  352|  33.1k|                        parent->children.push_back(node);
  353|  33.1k|                    }
  354|  18.6k|                    else
  355|  18.6k|                    {
  356|  18.6k|                        node->parent = 0;
  357|  18.6k|                        nodes->push_back(node);
  358|  18.6k|                    }
  359|       |
  360|       |                    // Move up another level
  361|  51.7k|                    if(parent)
  ------------------
  |  Branch (361:24): [True: 33.1k, False: 18.6k]
  ------------------
  362|  33.1k|                        parent = parent->parent;
  363|       |
  364|  51.7k|                    node = ConcreteNodePtr();
  365|  51.7k|                    state = READY;
  366|  51.7k|                }
  367|   839k|                else if(token->type == TID_VARIABLE)
  ------------------
  |  Branch (367:25): [True: 47.9k, False: 791k]
  ------------------
  368|  47.9k|                {
  369|  47.9k|                    node = std::make_shared<ConcreteNode>();
  370|  47.9k|                    node->token = token->lexeme;
  371|  47.9k|                    node->file = file;
  372|  47.9k|                    node->line = token->line;
  373|  47.9k|                    node->type = CNT_VARIABLE;
  374|       |
  375|       |                    // Insert the node
  376|  47.9k|                    if(parent)
  ------------------
  |  Branch (376:24): [True: 47.9k, False: 0]
  ------------------
  377|  47.9k|                    {
  378|  47.9k|                        node->parent = parent;
  379|  47.9k|                        parent->children.push_back(node);
  380|  47.9k|                    }
  381|      0|                    else
  382|      0|                    {
  383|      0|                        node->parent = 0;
  384|      0|                        nodes->push_back(node);
  385|      0|                    }
  386|  47.9k|                    node = ConcreteNodePtr();
  387|  47.9k|                }
  388|   791k|                else if(token->type == TID_QUOTE)
  ------------------
  |  Branch (388:25): [True: 13.8k, False: 777k]
  ------------------
  389|  13.8k|                {
  390|  13.8k|                    node = std::make_shared<ConcreteNode>();
  391|  13.8k|                    node->token = unquoted(token->lexeme);
  392|  13.8k|                    node->file = file;
  393|  13.8k|                    node->line = token->line;
  394|  13.8k|                    node->type = CNT_QUOTE;
  395|       |
  396|       |                    // Insert the node
  397|  13.8k|                    if(parent)
  ------------------
  |  Branch (397:24): [True: 13.8k, False: 0]
  ------------------
  398|  13.8k|                    {
  399|  13.8k|                        node->parent = parent;
  400|  13.8k|                        parent->children.push_back(node);
  401|  13.8k|                    }
  402|      0|                    else
  403|      0|                    {
  404|      0|                        node->parent = 0;
  405|      0|                        nodes->push_back(node);
  406|      0|                    }
  407|  13.8k|                    node = ConcreteNodePtr();
  408|  13.8k|                }
  409|   777k|                else if(token->type == TID_WORD)
  ------------------
  |  Branch (409:25): [True: 777k, False: 0]
  ------------------
  410|   777k|                {
  411|   777k|                    node = std::make_shared<ConcreteNode>();
  412|   777k|                    node->token = token->lexeme;
  413|   777k|                    node->file = file;
  414|   777k|                    node->line = token->line;
  415|   777k|                    node->type = CNT_WORD;
  416|       |
  417|       |                    // Insert the node
  418|   777k|                    if(parent)
  ------------------
  |  Branch (418:24): [True: 777k, False: 0]
  ------------------
  419|   777k|                    {
  420|   777k|                        node->parent = parent;
  421|   777k|                        parent->children.push_back(node);
  422|   777k|                    }
  423|      0|                    else
  424|      0|                    {
  425|      0|                        node->parent = 0;
  426|      0|                        nodes->push_back(node);
  427|      0|                    }
  428|   777k|                    node = ConcreteNodePtr();
  429|   777k|                }
  430|  1.34M|                break;
  431|  2.06M|            }
  432|       |
  433|  2.06M|            ++i;
  434|  2.06M|        }
  435|       |
  436|  15.8k|        return nodes;
  437|  15.8k|    }
_ZN4Ogre12ScriptParser10parseChunkERKNSt3__16vectorINS_11ScriptTokenENS1_9allocatorIS3_EEEERKNS1_12basic_stringIcNS1_11char_traitsIcEENS4_IcEEEE:
  440|   536k|    {
  441|   536k|        auto nodes = std::make_shared<ConcreteNodeList>();
  442|       |
  443|   536k|        ConcreteNodePtr node;
  444|   536k|        for(const auto& token : tokens)
  ------------------
  |  Branch (444:31): [True: 5.59M, False: 536k]
  ------------------
  445|  5.59M|        {
  446|  5.59M|            switch(token.type)
  447|  5.59M|            {
  448|  1.61M|            case TID_VARIABLE:
  ------------------
  |  Branch (448:13): [True: 1.61M, False: 3.97M]
  ------------------
  449|  1.61M|                node = std::make_shared<ConcreteNode>();
  450|  1.61M|                node->file = file;
  451|  1.61M|                node->line = token.line;
  452|  1.61M|                node->parent = 0;
  453|  1.61M|                node->token = token.lexeme;
  454|  1.61M|                node->type = CNT_VARIABLE;
  455|  1.61M|                break;
  456|  3.97M|            case TID_WORD:
  ------------------
  |  Branch (456:13): [True: 3.97M, False: 1.61M]
  ------------------
  457|  3.97M|                node = std::make_shared<ConcreteNode>();
  458|  3.97M|                node->file = file;
  459|  3.97M|                node->line = token.line;
  460|  3.97M|                node->parent = 0;
  461|  3.97M|                node->token = token.lexeme;
  462|  3.97M|                node->type = CNT_WORD;
  463|  3.97M|                break;
  464|  1.79k|            case TID_QUOTE:
  ------------------
  |  Branch (464:13): [True: 1.79k, False: 5.59M]
  ------------------
  465|  1.79k|                node = std::make_shared<ConcreteNode>();
  466|  1.79k|                node->file = file;
  467|  1.79k|                node->line = token.line;
  468|  1.79k|                node->parent = 0;
  469|  1.79k|                node->token= unquoted(token.lexeme);
  470|  1.79k|                node->type = CNT_QUOTE;
  471|  1.79k|                break;
  472|     23|            default:
  ------------------
  |  Branch (472:13): [True: 23, False: 5.59M]
  ------------------
  473|     23|                OGRE_EXCEPT(Exception::ERR_INVALID_STATE,
  474|  5.59M|                    Ogre::String("unexpected token") + token.lexeme + " at line " +
  475|  5.59M|                        Ogre::StringConverter::toString(token.line),
  476|  5.59M|                    "ScriptParser::parseChunk");
  477|  5.59M|            }
  478|       |
  479|  5.59M|            if(node)
  ------------------
  |  Branch (479:16): [True: 5.59M, False: 0]
  ------------------
  480|  5.59M|                nodes->push_back(node);
  481|  5.59M|        }
  482|       |
  483|   536k|        return nodes;
  484|   536k|    }
_ZN4Ogre12ScriptParser12skipNewlinesENSt3__111__wrap_iterIPKNS_11ScriptTokenEEES6_:
  496|   606k|    {
  497|   854k|        while(i != end && i->type == TID_NEWLINE)
  ------------------
  |  Branch (497:15): [True: 853k, False: 731]
  |  Branch (497:27): [True: 247k, False: 606k]
  ------------------
  498|   247k|            ++i;
  499|   606k|        return i;
  500|   606k|    }
OgreScriptParser.cpp:_ZN4OgreL8unquotedERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEb:
   37|   450k|    {
   38|   450k|        return trim ? str.substr(1, str.size() - 2) : str;
  ------------------
  |  Branch (38:16): [True: 21.8k, False: 428k]
  ------------------
   39|   450k|    }

_ZN4Ogre8getValueIfEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
   94|  77.4k|    {
   95|  77.4k|        return StringConverter::parse(node->getString(), result);
   96|  77.4k|    }
_ZN4Ogre8getValueIdEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
   98|      8|    {
   99|      8|        return StringConverter::parse(node->getString(), result);
  100|      8|    }
_ZN4Ogre8getValueIbEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  102|  69.3k|    {
  103|  69.3k|        return ScriptTranslator::getBoolean(node, &result);
  104|  69.3k|    }
_ZN4Ogre8getValueIjEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  106|  42.2k|    {
  107|  42.2k|        return StringConverter::parse(node->getString(), result);
  108|  42.2k|    }
_ZN4Ogre8getValueIiEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  110|  2.41k|    {
  111|  2.41k|        return StringConverter::parse(node->getString(), result);
  112|  2.41k|    }
_ZN4Ogre8getValueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  114|  2.28M|    {
  115|  2.28M|        return ScriptTranslator::getString(node, &result);
  116|  2.28M|    }
_ZN4Ogre8getValueINS_15CompareFunctionEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  119|  3.22k|    {
  120|  3.22k|        return ScriptTranslator::getCompareFunction(node, &result);
  121|  3.22k|    }
_ZN4Ogre8getValueINS_16StencilOperationEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  124|  3.03k|    {
  125|  3.03k|        return ScriptTranslator::getStencilOp(node, &result);
  126|  3.03k|    }
_ZN4Ogre8getValueINS_17IlluminationStageEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  129|  2.26k|    {
  130|  2.26k|        switch (getAtomId(node))
  131|  2.26k|        {
  132|    291|        case ID_AMBIENT:
  ------------------
  |  Branch (132:9): [True: 291, False: 1.97k]
  ------------------
  133|    291|            result = IS_AMBIENT;
  134|    291|            return true;
  135|    476|        case ID_PER_LIGHT:
  ------------------
  |  Branch (135:9): [True: 476, False: 1.78k]
  ------------------
  136|    476|            result = IS_PER_LIGHT;
  137|    476|            return true;
  138|    249|        case ID_DECAL:
  ------------------
  |  Branch (138:9): [True: 249, False: 2.01k]
  ------------------
  139|    249|            result = IS_DECAL;
  140|    249|            return true;
  141|  1.24k|        default:
  ------------------
  |  Branch (141:9): [True: 1.24k, False: 1.01k]
  ------------------
  142|  1.24k|            return false;
  143|  2.26k|        }
  144|  2.26k|    }
_ZN4Ogre8getValueINS_14SceneBlendTypeEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  147|  18.3k|    {
  148|  18.3k|        switch (getAtomId(node))
  149|  18.3k|        {
  150|  10.3k|        case ID_ADD:
  ------------------
  |  Branch (150:9): [True: 10.3k, False: 7.98k]
  ------------------
  151|  10.3k|            result = SBT_ADD;
  152|  10.3k|            break;
  153|  1.18k|        case ID_MODULATE:
  ------------------
  |  Branch (153:9): [True: 1.18k, False: 17.1k]
  ------------------
  154|  1.18k|            result = SBT_MODULATE;
  155|  1.18k|            break;
  156|    678|        case ID_COLOUR_BLEND:
  ------------------
  |  Branch (156:9): [True: 678, False: 17.6k]
  ------------------
  157|    678|            result = SBT_TRANSPARENT_COLOUR;
  158|    678|            break;
  159|  1.53k|        case ID_ALPHA_BLEND:
  ------------------
  |  Branch (159:9): [True: 1.53k, False: 16.7k]
  ------------------
  160|  1.53k|            result = SBT_TRANSPARENT_ALPHA;
  161|  1.53k|            break;
  162|  4.58k|        default:
  ------------------
  |  Branch (162:9): [True: 4.58k, False: 13.7k]
  ------------------
  163|  4.58k|            return false;
  164|  18.3k|        }
  165|  13.7k|        return true;
  166|  18.3k|    }
_ZN4Ogre8getValueINS_19SceneBlendOperationEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  169|  7.98k|    {
  170|  7.98k|        switch (getAtomId(node))
  171|  7.98k|        {
  172|  1.10k|        case ID_ADD:
  ------------------
  |  Branch (172:9): [True: 1.10k, False: 6.87k]
  ------------------
  173|  1.10k|            result = SBO_ADD;
  174|  1.10k|            break;
  175|  1.25k|        case ID_SUBTRACT:
  ------------------
  |  Branch (175:9): [True: 1.25k, False: 6.72k]
  ------------------
  176|  1.25k|            result = SBO_SUBTRACT;
  177|  1.25k|            break;
  178|    655|        case ID_REVERSE_SUBTRACT:
  ------------------
  |  Branch (178:9): [True: 655, False: 7.32k]
  ------------------
  179|    655|            result = SBO_REVERSE_SUBTRACT;
  180|    655|            break;
  181|    748|        case ID_MIN:
  ------------------
  |  Branch (181:9): [True: 748, False: 7.23k]
  ------------------
  182|    748|            result = SBO_MIN;
  183|    748|            break;
  184|    888|        case ID_MAX:
  ------------------
  |  Branch (184:9): [True: 888, False: 7.09k]
  ------------------
  185|    888|            result = SBO_MAX;
  186|    888|            break;
  187|  3.32k|        default:
  ------------------
  |  Branch (187:9): [True: 3.32k, False: 4.65k]
  ------------------
  188|  3.32k|            return false;
  189|  7.98k|        }
  190|  4.65k|        return true;
  191|  7.98k|    }
_ZN4Ogre8getValueINS_11CullingModeEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  194|  38.5k|    {
  195|  38.5k|        switch (getAtomId(node))
  196|  38.5k|        {
  197|    277|        case ID_CLOCKWISE:
  ------------------
  |  Branch (197:9): [True: 277, False: 38.2k]
  ------------------
  198|    277|            result = CULL_CLOCKWISE;
  199|    277|            break;
  200|    319|        case ID_ANTICLOCKWISE:
  ------------------
  |  Branch (200:9): [True: 319, False: 38.2k]
  ------------------
  201|    319|            result = CULL_ANTICLOCKWISE;
  202|    319|            break;
  203|  33.8k|        case ID_NONE:
  ------------------
  |  Branch (203:9): [True: 33.8k, False: 4.66k]
  ------------------
  204|  33.8k|            result = CULL_NONE;
  205|  33.8k|            break;
  206|  4.06k|        default:
  ------------------
  |  Branch (206:9): [True: 4.06k, False: 34.4k]
  ------------------
  207|  4.06k|            return false;
  208|  38.5k|        }
  209|  34.4k|        return true;
  210|  38.5k|    }
_ZN4Ogre8getValueINS_17ManualCullingModeEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  213|  1.33k|    {
  214|  1.33k|        switch (getAtomId(node))
  215|  1.33k|        {
  216|      0|        case ID_FRONT:
  ------------------
  |  Branch (216:9): [True: 0, False: 1.33k]
  ------------------
  217|      0|            result = MANUAL_CULL_FRONT;
  218|      0|            break;
  219|      0|        case ID_BACK:
  ------------------
  |  Branch (219:9): [True: 0, False: 1.33k]
  ------------------
  220|      0|            result = MANUAL_CULL_BACK;
  221|      0|            break;
  222|    683|        case ID_NONE:
  ------------------
  |  Branch (222:9): [True: 683, False: 653]
  ------------------
  223|    683|            result = MANUAL_CULL_NONE;
  224|    683|            break;
  225|    653|        default:
  ------------------
  |  Branch (225:9): [True: 653, False: 683]
  ------------------
  226|    653|            return false;
  227|  1.33k|        }
  228|    683|        return true;
  229|  1.33k|    }
_ZN4Ogre8getValueINS_12ShadeOptionsEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  232|  1.12k|    {
  233|  1.12k|        switch (getAtomId(node))
  234|  1.12k|        {
  235|    273|        case ID_FLAT:
  ------------------
  |  Branch (235:9): [True: 273, False: 849]
  ------------------
  236|    273|            result = SO_FLAT;
  237|    273|            break;
  238|      3|        case ID_GOURAUD:
  ------------------
  |  Branch (238:9): [True: 3, False: 1.11k]
  ------------------
  239|      3|            result = SO_GOURAUD;
  240|      3|            break;
  241|     33|        case ID_PHONG:
  ------------------
  |  Branch (241:9): [True: 33, False: 1.08k]
  ------------------
  242|     33|            result = SO_PHONG;
  243|     33|            break;
  244|    813|        default:
  ------------------
  |  Branch (244:9): [True: 813, False: 309]
  ------------------
  245|    813|            return false;
  246|  1.12k|        }
  247|    309|        return true;
  248|  1.12k|    }
_ZN4Ogre8getValueINS_11PolygonModeEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  251|  1.69k|    {
  252|  1.69k|        switch (getAtomId(node))
  253|  1.69k|        {
  254|      0|        case ID_SOLID:
  ------------------
  |  Branch (254:9): [True: 0, False: 1.69k]
  ------------------
  255|      0|            result = PM_SOLID;
  256|      0|            break;
  257|      0|        case ID_POINTS:
  ------------------
  |  Branch (257:9): [True: 0, False: 1.69k]
  ------------------
  258|      0|            result = PM_POINTS;
  259|      0|            break;
  260|    308|        case ID_WIREFRAME:
  ------------------
  |  Branch (260:9): [True: 308, False: 1.39k]
  ------------------
  261|    308|            result = PM_WIREFRAME;
  262|    308|            break;
  263|  1.39k|        default:
  ------------------
  |  Branch (263:9): [True: 1.39k, False: 308]
  ------------------
  264|  1.39k|            return false;
  265|  1.69k|        }
  266|    308|        return true;
  267|  1.69k|    }
_ZN4Ogre8getValueINS_19LayerBlendOperationEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  270|  5.51k|    {
  271|  5.51k|        switch (getAtomId(node))
  272|  5.51k|        {
  273|    203|        case ID_REPLACE:
  ------------------
  |  Branch (273:9): [True: 203, False: 5.30k]
  ------------------
  274|    203|            result = LBO_REPLACE;
  275|    203|            break;
  276|     66|        case ID_ADD:
  ------------------
  |  Branch (276:9): [True: 66, False: 5.44k]
  ------------------
  277|     66|            result = LBO_ADD;
  278|     66|            break;
  279|     44|        case ID_MODULATE:
  ------------------
  |  Branch (279:9): [True: 44, False: 5.46k]
  ------------------
  280|     44|            result = LBO_MODULATE;
  281|     44|            break;
  282|     88|        case ID_ALPHA_BLEND:
  ------------------
  |  Branch (282:9): [True: 88, False: 5.42k]
  ------------------
  283|     88|            result = LBO_ALPHA_BLEND;
  284|     88|            break;
  285|  5.10k|        default:
  ------------------
  |  Branch (285:9): [True: 5.10k, False: 401]
  ------------------
  286|  5.10k|            return false;
  287|  5.51k|        }
  288|    401|        return true;
  289|  5.51k|    }
_ZN4Ogre8getValueINS_21LayerBlendOperationExEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  292|  21.0k|    {
  293|  21.0k|        switch (getAtomId(node))
  294|  21.0k|        {
  295|  3.73k|        case ID_SOURCE1:
  ------------------
  |  Branch (295:9): [True: 3.73k, False: 17.3k]
  ------------------
  296|  3.73k|            op = LBX_SOURCE1;
  297|  3.73k|            break;
  298|  1.89k|        case ID_SOURCE2:
  ------------------
  |  Branch (298:9): [True: 1.89k, False: 19.2k]
  ------------------
  299|  1.89k|            op = LBX_SOURCE2;
  300|  1.89k|            break;
  301|  1.47k|        case ID_MODULATE:
  ------------------
  |  Branch (301:9): [True: 1.47k, False: 19.6k]
  ------------------
  302|  1.47k|            op = LBX_MODULATE;
  303|  1.47k|            break;
  304|    514|        case ID_MODULATE_X2:
  ------------------
  |  Branch (304:9): [True: 514, False: 20.5k]
  ------------------
  305|    514|            op = LBX_MODULATE_X2;
  306|    514|            break;
  307|    318|        case ID_MODULATE_X4:
  ------------------
  |  Branch (307:9): [True: 318, False: 20.7k]
  ------------------
  308|    318|            op = LBX_MODULATE_X4;
  309|    318|            break;
  310|  2.68k|        case ID_ADD:
  ------------------
  |  Branch (310:9): [True: 2.68k, False: 18.4k]
  ------------------
  311|  2.68k|            op = LBX_ADD;
  312|  2.68k|            break;
  313|    526|        case ID_ADD_SIGNED:
  ------------------
  |  Branch (313:9): [True: 526, False: 20.5k]
  ------------------
  314|    526|            op = LBX_ADD_SIGNED;
  315|    526|            break;
  316|    412|        case ID_ADD_SMOOTH:
  ------------------
  |  Branch (316:9): [True: 412, False: 20.6k]
  ------------------
  317|    412|            op = LBX_ADD_SMOOTH;
  318|    412|            break;
  319|  1.52k|        case ID_SUBTRACT:
  ------------------
  |  Branch (319:9): [True: 1.52k, False: 19.5k]
  ------------------
  320|  1.52k|            op = LBX_SUBTRACT;
  321|  1.52k|            break;
  322|    541|        case ID_BLEND_DIFFUSE_ALPHA:
  ------------------
  |  Branch (322:9): [True: 541, False: 20.5k]
  ------------------
  323|    541|            op = LBX_BLEND_DIFFUSE_ALPHA;
  324|    541|            break;
  325|    385|        case ID_BLEND_TEXTURE_ALPHA:
  ------------------
  |  Branch (325:9): [True: 385, False: 20.7k]
  ------------------
  326|    385|            op = LBX_BLEND_TEXTURE_ALPHA;
  327|    385|            break;
  328|    351|        case ID_BLEND_CURRENT_ALPHA:
  ------------------
  |  Branch (328:9): [True: 351, False: 20.7k]
  ------------------
  329|    351|            op = LBX_BLEND_CURRENT_ALPHA;
  330|    351|            break;
  331|  2.59k|        case ID_BLEND_MANUAL:
  ------------------
  |  Branch (331:9): [True: 2.59k, False: 18.4k]
  ------------------
  332|  2.59k|            op = LBX_BLEND_MANUAL;
  333|  2.59k|            break;
  334|    463|        case ID_DOT_PRODUCT:
  ------------------
  |  Branch (334:9): [True: 463, False: 20.6k]
  ------------------
  335|    463|            op = LBX_DOTPRODUCT;
  336|    463|            break;
  337|    491|        case ID_BLEND_DIFFUSE_COLOUR:
  ------------------
  |  Branch (337:9): [True: 491, False: 20.6k]
  ------------------
  338|    491|            op = LBX_BLEND_DIFFUSE_COLOUR;
  339|    491|            break;
  340|  3.20k|        default:
  ------------------
  |  Branch (340:9): [True: 3.20k, False: 17.8k]
  ------------------
  341|  3.20k|            return false;
  342|  21.0k|        }
  343|  17.8k|        return true;
  344|  21.0k|    }
_ZN4Ogre8getValueINS_16LayerBlendSourceEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  347|  28.2k|    {
  348|  28.2k|        switch (getAtomId(node))
  349|  28.2k|        {
  350|  2.33k|        case ID_SRC_CURRENT:
  ------------------
  |  Branch (350:9): [True: 2.33k, False: 25.8k]
  ------------------
  351|  2.33k|            source1 = LBS_CURRENT;
  352|  2.33k|            break;
  353|  5.51k|        case ID_SRC_TEXTURE:
  ------------------
  |  Branch (353:9): [True: 5.51k, False: 22.6k]
  ------------------
  354|  5.51k|            source1 = LBS_TEXTURE;
  355|  5.51k|            break;
  356|  2.36k|        case ID_SRC_DIFFUSE:
  ------------------
  |  Branch (356:9): [True: 2.36k, False: 25.8k]
  ------------------
  357|  2.36k|            source1 = LBS_DIFFUSE;
  358|  2.36k|            break;
  359|  1.22k|        case ID_SRC_SPECULAR:
  ------------------
  |  Branch (359:9): [True: 1.22k, False: 26.9k]
  ------------------
  360|  1.22k|            source1 = LBS_SPECULAR;
  361|  1.22k|            break;
  362|  6.14k|        case ID_SRC_MANUAL:
  ------------------
  |  Branch (362:9): [True: 6.14k, False: 22.0k]
  ------------------
  363|  6.14k|            source1 = LBS_MANUAL;
  364|  6.14k|            break;
  365|  10.6k|        default:
  ------------------
  |  Branch (365:9): [True: 10.6k, False: 17.5k]
  ------------------
  366|  10.6k|            return false;
  367|  28.2k|        }
  368|  17.5k|        return true;
  369|  28.2k|    }
_ZN4Ogre8getValueINS_21CompositionTargetPass9InputModeEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  372|  2.85k|    {
  373|  2.85k|        switch (getAtomId(node))
  374|  2.85k|        {
  375|  1.40k|        case ID_NONE:
  ------------------
  |  Branch (375:9): [True: 1.40k, False: 1.45k]
  ------------------
  376|  1.40k|            result = CompositionTargetPass::IM_NONE;
  377|  1.40k|            break;
  378|    367|        case ID_PREVIOUS:
  ------------------
  |  Branch (378:9): [True: 367, False: 2.49k]
  ------------------
  379|    367|            result = CompositionTargetPass::IM_PREVIOUS;
  380|    367|            break;
  381|  1.08k|        default:
  ------------------
  |  Branch (381:9): [True: 1.08k, False: 1.77k]
  ------------------
  382|  1.08k|            return false;
  383|  2.85k|        }
  384|  1.77k|        return true;
  385|  2.85k|    }
_ZN4Ogre8getValueINS_13FilterOptionsEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  388|  23.1k|    {
  389|  23.1k|        switch (getAtomId(node))
  390|  23.1k|        {
  391|  1.65k|        case ID_NONE:
  ------------------
  |  Branch (391:9): [True: 1.65k, False: 21.4k]
  ------------------
  392|  1.65k|            tmip = FO_NONE;
  393|  1.65k|            break;
  394|  1.99k|        case ID_POINT:
  ------------------
  |  Branch (394:9): [True: 1.99k, False: 21.1k]
  ------------------
  395|  1.99k|            tmip = FO_POINT;
  396|  1.99k|            break;
  397|  8.36k|        case ID_LINEAR:
  ------------------
  |  Branch (397:9): [True: 8.36k, False: 14.7k]
  ------------------
  398|  8.36k|            tmip = FO_LINEAR;
  399|  8.36k|            break;
  400|  4.64k|        case ID_ANISOTROPIC:
  ------------------
  |  Branch (400:9): [True: 4.64k, False: 18.5k]
  ------------------
  401|  4.64k|            tmip = FO_ANISOTROPIC;
  402|  4.64k|            break;
  403|  6.49k|        default:
  ------------------
  |  Branch (403:9): [True: 6.49k, False: 16.6k]
  ------------------
  404|  6.49k|            return false;
  405|  23.1k|        }
  406|  16.6k|        return true;
  407|  23.1k|    }
_ZN4Ogre8getValueINS_21TextureAddressingModeEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_:
  410|  13.1k|    {
  411|  13.1k|        switch (getAtomId(node))
  412|  13.1k|        {
  413|  1.07k|        case ID_WRAP:
  ------------------
  |  Branch (413:9): [True: 1.07k, False: 12.1k]
  ------------------
  414|  1.07k|            result = TextureUnitState::TAM_WRAP;
  415|  1.07k|            break;
  416|  4.18k|        case ID_CLAMP:
  ------------------
  |  Branch (416:9): [True: 4.18k, False: 8.98k]
  ------------------
  417|  4.18k|            result = TextureUnitState::TAM_CLAMP;
  418|  4.18k|            break;
  419|  1.57k|        case ID_MIRROR:
  ------------------
  |  Branch (419:9): [True: 1.57k, False: 11.5k]
  ------------------
  420|  1.57k|            result = TextureUnitState::TAM_MIRROR;
  421|  1.57k|            break;
  422|    310|        case ID_BORDER:
  ------------------
  |  Branch (422:9): [True: 310, False: 12.8k]
  ------------------
  423|    310|            result = TextureUnitState::TAM_BORDER;
  424|    310|            break;
  425|  6.03k|        default:
  ------------------
  |  Branch (425:9): [True: 6.03k, False: 7.14k]
  ------------------
  426|  6.03k|            return false;
  427|  13.1k|        }
  428|  7.14k|        return true;
  429|  13.1k|    }
_ZN4Ogre16ScriptTranslator11processNodeEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE:
  506|   320k|    {
  507|   320k|        if(node->type != ANT_OBJECT)
  ------------------
  |  Branch (507:12): [True: 0, False: 320k]
  ------------------
  508|      0|            return;
  509|       |
  510|       |        // Abstract objects are completely skipped
  511|   320k|        if((static_cast<ObjectAbstractNode*>(node.get()))->abstract)
  ------------------
  |  Branch (511:12): [True: 413, False: 319k]
  ------------------
  512|    413|            return;
  513|       |
  514|       |        // Retrieve the translator to use
  515|   319k|        ScriptTranslator *translator =
  516|   319k|            ScriptCompilerManager::getSingleton().getTranslator(node);
  517|       |
  518|   319k|        if(translator)
  ------------------
  |  Branch (518:12): [True: 214k, False: 105k]
  ------------------
  519|   214k|            translator->translate(compiler, node);
  520|   105k|        else
  521|   105k|            compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, node->file, node->line,
  522|   105k|                               "token \"" + static_cast<ObjectAbstractNode*>(node.get())->cls + "\" is not recognized");
  523|   319k|    }
_ZN4Ogre16ScriptTranslator9getNodeAtERKNSt3__14listINS_9SharedPtrINS_12AbstractNodeEEENS1_9allocatorIS5_EEEEm:
  526|   541k|    {
  527|   541k|        if(index >= nodes.size())
  ------------------
  |  Branch (527:12): [True: 28.4k, False: 513k]
  ------------------
  528|  28.4k|            return nodes.end();
  529|       |
  530|   513k|        return std::next(nodes.begin(), index);
  531|   541k|    }
_ZN4Ogre16ScriptTranslator10getBooleanERKNS_9SharedPtrINS_12AbstractNodeEEEPb:
  534|  91.4k|    {
  535|  91.4k|        if (node->type != ANT_ATOM)
  ------------------
  |  Branch (535:13): [True: 1.71k, False: 89.7k]
  ------------------
  536|  1.71k|            return false;
  537|  89.7k|        AtomAbstractNode *atom = (AtomAbstractNode*)node.get();
  538|  89.7k|		 if (atom->id == 1 || atom->id == 2)
  ------------------
  |  Branch (538:8): [True: 18.9k, False: 70.8k]
  |  Branch (538:25): [True: 54.6k, False: 16.1k]
  ------------------
  539|  73.5k|		{
  540|  73.5k|			*result = atom->id == 1 ? true : false;
  ------------------
  |  Branch (540:14): [True: 18.9k, False: 54.6k]
  ------------------
  541|  73.5k|			return true;
  542|  73.5k|		}
  543|       |        //     return false;
  544|  16.1k|		return false;
  545|  89.7k|    }
_ZN4Ogre16ScriptTranslator9getStringERKNS_9SharedPtrINS_12AbstractNodeEEEPNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEE:
  548|  2.43M|    {
  549|  2.43M|        if(node->type != ANT_ATOM)
  ------------------
  |  Branch (549:12): [True: 11.2k, False: 2.42M]
  ------------------
  550|  11.2k|            return false;
  551|  2.42M|        AtomAbstractNode *atom = (AtomAbstractNode*)node.get();
  552|  2.42M|        *result = atom->value;
  553|  2.42M|        return true;
  554|  2.43M|    }
_ZN4Ogre16ScriptTranslator8getFloatERKNS_9SharedPtrINS_12AbstractNodeEEEPf:
  557|   242k|    {
  558|   242k|        return StringConverter::parse(node->getString(), *result);
  559|   242k|    }
_ZN4Ogre16ScriptTranslator6getIntERKNS_9SharedPtrINS_12AbstractNodeEEEPi:
  567|  18.2k|    {
  568|  18.2k|        return StringConverter::parse(node->getString(), *result);
  569|  18.2k|    }
_ZN4Ogre16ScriptTranslator7getUIntERKNS_9SharedPtrINS_12AbstractNodeEEEPj:
  572|  16.0k|    {
  573|  16.0k|        return StringConverter::parse(node->getString(), *result);
  574|  16.0k|    }
_ZN4Ogre16ScriptTranslator9getColourENSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEES7_PNS_11ColourValueEi:
  577|  43.9k|    {
  578|  43.9k|        int n = 0;
  579|   100k|        while(i != end && n < maxEntries)
  ------------------
  |  Branch (579:15): [True: 87.3k, False: 12.8k]
  |  Branch (579:27): [True: 84.7k, False: 2.54k]
  ------------------
  580|  84.7k|        {
  581|  84.7k|            float v = 0;
  582|  84.7k|            if(getFloat(*i, &v))
  ------------------
  |  Branch (582:16): [True: 56.1k, False: 28.5k]
  ------------------
  583|  56.1k|            {
  584|  56.1k|                switch(n)
  ------------------
  |  Branch (584:24): [True: 56.1k, False: 0]
  ------------------
  585|  56.1k|                {
  586|  25.4k|                case 0:
  ------------------
  |  Branch (586:17): [True: 25.4k, False: 30.7k]
  ------------------
  587|  25.4k|                    result->r = v;
  588|  25.4k|                    break;
  589|  17.0k|                case 1:
  ------------------
  |  Branch (589:17): [True: 17.0k, False: 39.0k]
  ------------------
  590|  17.0k|                    result->g = v;
  591|  17.0k|                    break;
  592|  10.5k|                case 2:
  ------------------
  |  Branch (592:17): [True: 10.5k, False: 45.6k]
  ------------------
  593|  10.5k|                    result->b = v;
  594|  10.5k|                    break;
  595|  3.14k|                case 3:
  ------------------
  |  Branch (595:17): [True: 3.14k, False: 53.0k]
  ------------------
  596|  3.14k|                    result->a = v;
  597|  3.14k|                    break;
  598|  56.1k|                }
  599|  56.1k|            }
  600|  28.5k|            else
  601|  28.5k|            {
  602|  28.5k|                return false;
  603|  28.5k|            }
  604|  56.1k|            ++n;
  605|  56.1k|            ++i;
  606|  56.1k|        }
  607|       |        // return error if we found less than rgb before end, unless constrained
  608|  15.3k|        return (n >= 3 || n == maxEntries);
  ------------------
  |  Branch (608:17): [True: 8.88k, False: 6.48k]
  |  Branch (608:27): [True: 0, False: 6.48k]
  ------------------
  609|  43.9k|    }
_ZN4Ogre16ScriptTranslator19getSceneBlendFactorERKNS_9SharedPtrINS_12AbstractNodeEEEPNS_16SceneBlendFactorE:
  612|  18.8k|    {
  613|  18.8k|        switch(getAtomId(node))
  614|  18.8k|        {
  615|  1.91k|        case ID_ONE:
  ------------------
  |  Branch (615:9): [True: 1.91k, False: 16.8k]
  ------------------
  616|  1.91k|            *sbf = SBF_ONE;
  617|  1.91k|            break;
  618|  3.48k|        case ID_ZERO:
  ------------------
  |  Branch (618:9): [True: 3.48k, False: 15.3k]
  ------------------
  619|  3.48k|            *sbf = SBF_ZERO;
  620|  3.48k|            break;
  621|    909|        case ID_DEST_COLOUR:
  ------------------
  |  Branch (621:9): [True: 909, False: 17.9k]
  ------------------
  622|    909|            *sbf = SBF_DEST_COLOUR;
  623|    909|            break;
  624|    640|        case ID_DEST_ALPHA:
  ------------------
  |  Branch (624:9): [True: 640, False: 18.1k]
  ------------------
  625|    640|            *sbf = SBF_DEST_ALPHA;
  626|    640|            break;
  627|  1.14k|        case ID_SRC_ALPHA:
  ------------------
  |  Branch (627:9): [True: 1.14k, False: 17.6k]
  ------------------
  628|  1.14k|            *sbf = SBF_SOURCE_ALPHA;
  629|  1.14k|            break;
  630|    967|        case ID_SRC_COLOUR:
  ------------------
  |  Branch (630:9): [True: 967, False: 17.8k]
  ------------------
  631|    967|            *sbf = SBF_SOURCE_COLOUR;
  632|    967|            break;
  633|    464|        case ID_ONE_MINUS_DEST_COLOUR:
  ------------------
  |  Branch (633:9): [True: 464, False: 18.3k]
  ------------------
  634|    464|            *sbf = SBF_ONE_MINUS_DEST_COLOUR;
  635|    464|            break;
  636|    245|        case ID_ONE_MINUS_SRC_COLOUR:
  ------------------
  |  Branch (636:9): [True: 245, False: 18.5k]
  ------------------
  637|    245|            *sbf = SBF_ONE_MINUS_SOURCE_COLOUR;
  638|    245|            break;
  639|    127|        case ID_ONE_MINUS_DEST_ALPHA:
  ------------------
  |  Branch (639:9): [True: 127, False: 18.6k]
  ------------------
  640|    127|            *sbf = SBF_ONE_MINUS_DEST_ALPHA;
  641|    127|            break;
  642|    770|        case ID_ONE_MINUS_SRC_ALPHA:
  ------------------
  |  Branch (642:9): [True: 770, False: 18.0k]
  ------------------
  643|    770|            *sbf = SBF_ONE_MINUS_SOURCE_ALPHA;
  644|    770|            break;
  645|  8.14k|        default:
  ------------------
  |  Branch (645:9): [True: 8.14k, False: 10.6k]
  ------------------
  646|  8.14k|            return false;
  647|  18.8k|        }
  648|  10.6k|        return true;
  649|  18.8k|    }
_ZN4Ogre16ScriptTranslator18getCompareFunctionERKNS_9SharedPtrINS_12AbstractNodeEEEPNS_15CompareFunctionE:
  652|  8.73k|    {
  653|  8.73k|        switch(getAtomId(node))
  654|  8.73k|        {
  655|    593|        case ID_ALWAYS_FAIL:
  ------------------
  |  Branch (655:9): [True: 593, False: 8.13k]
  ------------------
  656|    593|            *func = CMPF_ALWAYS_FAIL;
  657|    593|            break;
  658|    300|        case ID_ALWAYS_PASS:
  ------------------
  |  Branch (658:9): [True: 300, False: 8.43k]
  ------------------
  659|    300|            *func = CMPF_ALWAYS_PASS;
  660|    300|            break;
  661|    189|        case ID_LESS:
  ------------------
  |  Branch (661:9): [True: 189, False: 8.54k]
  ------------------
  662|    189|            *func = CMPF_LESS;
  663|    189|            break;
  664|     71|        case ID_LESS_EQUAL:
  ------------------
  |  Branch (664:9): [True: 71, False: 8.66k]
  ------------------
  665|     71|            *func = CMPF_LESS_EQUAL;
  666|     71|            break;
  667|    378|        case ID_EQUAL:
  ------------------
  |  Branch (667:9): [True: 378, False: 8.35k]
  ------------------
  668|    378|            *func = CMPF_EQUAL;
  669|    378|            break;
  670|     90|        case ID_NOT_EQUAL:
  ------------------
  |  Branch (670:9): [True: 90, False: 8.64k]
  ------------------
  671|     90|            *func = CMPF_NOT_EQUAL;
  672|     90|            break;
  673|  3.72k|        case ID_GREATER_EQUAL:
  ------------------
  |  Branch (673:9): [True: 3.72k, False: 5.01k]
  ------------------
  674|  3.72k|            *func = CMPF_GREATER_EQUAL;
  675|  3.72k|            break;
  676|    438|        case ID_GREATER:
  ------------------
  |  Branch (676:9): [True: 438, False: 8.29k]
  ------------------
  677|    438|            *func = CMPF_GREATER;
  678|    438|            break;
  679|  2.95k|        default:
  ------------------
  |  Branch (679:9): [True: 2.95k, False: 5.78k]
  ------------------
  680|  2.95k|            return false;
  681|  8.73k|        }
  682|  5.78k|        return true;
  683|  8.73k|    }
_ZN4Ogre16ScriptTranslator10getMatrix4ENSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEES7_PNS_7Matrix4E:
  686|  2.39k|    {
  687|  2.39k|        int n = 0;
  688|  23.3k|        while (i != end && n < 16)
  ------------------
  |  Branch (688:16): [True: 22.3k, False: 1.01k]
  |  Branch (688:28): [True: 21.8k, False: 484]
  ------------------
  689|  21.8k|        {
  690|  21.8k|            Real r = 0;
  691|  21.8k|            if (!getReal(*i, &r))
  ------------------
  |  Branch (691:17): [True: 893, False: 21.0k]
  ------------------
  692|    893|                return false;
  693|       |
  694|  21.0k|            (*m)[n/4][n%4] = r;
  695|  21.0k|            ++i;
  696|  21.0k|            ++n;
  697|  21.0k|        }
  698|  1.50k|        return n == 16;
  699|  2.39k|    }
_ZN4Ogre16ScriptTranslator9getVectorENSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEES7_RNS1_6vectorIfNS1_9allocatorIfEEEEm:
  757|  28.7k|    {
  758|  28.7k|        return _getVector(i, end, vals, count);
  759|  28.7k|    }
_ZN4Ogre16ScriptTranslator12getStencilOpERKNS_9SharedPtrINS_12AbstractNodeEEEPNS_16StencilOperationE:
  840|  3.03k|    {
  841|  3.03k|        switch(getAtomId(node))
  842|  3.03k|        {
  843|    273|        case ID_KEEP:
  ------------------
  |  Branch (843:9): [True: 273, False: 2.76k]
  ------------------
  844|    273|            *op = SOP_KEEP;
  845|    273|            break;
  846|    273|        case ID_ZERO:
  ------------------
  |  Branch (846:9): [True: 273, False: 2.76k]
  ------------------
  847|    273|            *op = SOP_ZERO;
  848|    273|            break;
  849|     82|        case ID_REPLACE:
  ------------------
  |  Branch (849:9): [True: 82, False: 2.95k]
  ------------------
  850|     82|            *op = SOP_REPLACE;
  851|     82|            break;
  852|    256|        case ID_INCREMENT:
  ------------------
  |  Branch (852:9): [True: 256, False: 2.78k]
  ------------------
  853|    256|            *op = SOP_INCREMENT;
  854|    256|            break;
  855|    235|        case ID_DECREMENT:
  ------------------
  |  Branch (855:9): [True: 235, False: 2.80k]
  ------------------
  856|    235|            *op = SOP_DECREMENT;
  857|    235|            break;
  858|    211|        case ID_INCREMENT_WRAP:
  ------------------
  |  Branch (858:9): [True: 211, False: 2.82k]
  ------------------
  859|    211|            *op = SOP_INCREMENT_WRAP;
  860|    211|            break;
  861|    425|        case ID_DECREMENT_WRAP:
  ------------------
  |  Branch (861:9): [True: 425, False: 2.61k]
  ------------------
  862|    425|            *op = SOP_DECREMENT_WRAP;
  863|    425|            break;
  864|    152|        case ID_INVERT:
  ------------------
  |  Branch (864:9): [True: 152, False: 2.88k]
  ------------------
  865|    152|            *op = SOP_INVERT;
  866|    152|            break;
  867|  1.12k|        default:
  ------------------
  |  Branch (867:9): [True: 1.12k, False: 1.90k]
  ------------------
  868|  1.12k|            return false;
  869|  3.03k|        }
  870|  1.90k|        return true;
  871|  3.03k|    }
_ZN4Ogre16ScriptTranslator15getConstantTypeENSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEEPNS_15GpuConstantTypeE:
  874|  13.7k|    {
  875|  13.7k|        const String& val = (*i)->getString();
  876|  13.7k|        if(val.empty())
  ------------------
  |  Branch (876:12): [True: 167, False: 13.5k]
  ------------------
  877|    167|            return false;
  878|       |
  879|  13.5k|        if (val.find("float") != String::npos)
  ------------------
  |  Branch (879:13): [True: 2.46k, False: 11.1k]
  ------------------
  880|  2.46k|        {
  881|  2.46k|            int count = 1;
  882|  2.46k|            if (val.size() == 6)
  ------------------
  |  Branch (882:17): [True: 2.03k, False: 425]
  ------------------
  883|  2.03k|                count = StringConverter::parseInt(val.substr(5));
  884|    425|            else if (val.size() > 6)
  ------------------
  |  Branch (884:22): [True: 209, False: 216]
  ------------------
  885|    209|                return false;
  886|       |
  887|  2.25k|            if (count > 4 || count == 0)
  ------------------
  |  Branch (887:17): [True: 308, False: 1.94k]
  |  Branch (887:30): [True: 359, False: 1.58k]
  ------------------
  888|    667|                return false;
  889|       |
  890|  1.58k|            *op = (GpuConstantType)(GCT_FLOAT1 + count - 1);
  891|  1.58k|        }
  892|  11.1k|        else if (val.find("double") != String::npos)
  ------------------
  |  Branch (892:18): [True: 657, False: 10.4k]
  ------------------
  893|    657|        {
  894|    657|            int count = 1;
  895|    657|            if (val.size() == 7)
  ------------------
  |  Branch (895:17): [True: 543, False: 114]
  ------------------
  896|    543|                count = StringConverter::parseInt(val.substr(6));
  897|    114|            else if (val.size() > 7)
  ------------------
  |  Branch (897:22): [True: 109, False: 5]
  ------------------
  898|    109|                return false;
  899|       |
  900|    548|            if (count > 4 || count == 0)
  ------------------
  |  Branch (900:17): [True: 77, False: 471]
  |  Branch (900:30): [True: 290, False: 181]
  ------------------
  901|    367|                return false;
  902|       |
  903|    181|            *op = (GpuConstantType)(GCT_DOUBLE1 + count - 1);
  904|    181|        }
  905|  10.4k|        else if (val.find("uint") != String::npos)
  ------------------
  |  Branch (905:18): [True: 726, False: 9.75k]
  ------------------
  906|    726|        {
  907|    726|            int count = 1;
  908|    726|            if (val.size() == 5)
  ------------------
  |  Branch (908:17): [True: 377, False: 349]
  ------------------
  909|    377|                count = StringConverter::parseInt(val.substr(4));
  910|    349|            else if (val.size() > 5)
  ------------------
  |  Branch (910:22): [True: 154, False: 195]
  ------------------
  911|    154|                return false;
  912|       |
  913|    572|            if (count > 4 || count == 0)
  ------------------
  |  Branch (913:17): [True: 94, False: 478]
  |  Branch (913:30): [True: 57, False: 421]
  ------------------
  914|    151|                return false;
  915|       |
  916|    421|            *op = (GpuConstantType)(GCT_UINT1 + count - 1);
  917|    421|        }
  918|  9.75k|        else if (val.find("int") != String::npos)
  ------------------
  |  Branch (918:18): [True: 4.93k, False: 4.82k]
  ------------------
  919|  4.93k|        {
  920|  4.93k|            int count = 1;
  921|  4.93k|            if (val.size() == 4)
  ------------------
  |  Branch (921:17): [True: 577, False: 4.35k]
  ------------------
  922|    577|                count = StringConverter::parseInt(val.substr(3));
  923|  4.35k|            else if (val.size() > 4)
  ------------------
  |  Branch (923:22): [True: 402, False: 3.95k]
  ------------------
  924|    402|                return false;
  925|       |
  926|  4.53k|            if (count > 4 || count == 0)
  ------------------
  |  Branch (926:17): [True: 358, False: 4.17k]
  |  Branch (926:30): [True: 168, False: 4.00k]
  ------------------
  927|    526|                return false;
  928|       |
  929|  4.00k|            *op = (GpuConstantType)(GCT_INT1 + count - 1);
  930|  4.00k|        }
  931|  4.82k|        else if (val.find("bool") != String::npos)
  ------------------
  |  Branch (931:18): [True: 371, False: 4.44k]
  ------------------
  932|    371|        {
  933|    371|            int count = 1;
  934|    371|            if (val.size() == 5)
  ------------------
  |  Branch (934:17): [True: 1, False: 370]
  ------------------
  935|      1|                count = StringConverter::parseInt(val.substr(4));
  936|    370|            else if (val.size() > 5)
  ------------------
  |  Branch (936:22): [True: 370, False: 0]
  ------------------
  937|    370|                return false;
  938|       |
  939|      1|            if (count > 4 || count == 0)
  ------------------
  |  Branch (939:17): [True: 0, False: 1]
  |  Branch (939:30): [True: 1, False: 0]
  ------------------
  940|      1|                return false;
  941|       |
  942|      0|            *op = (GpuConstantType)(GCT_BOOL1 + count - 1);
  943|      0|        }
  944|  4.44k|        else if(val.find("matrix") != String::npos)
  ------------------
  |  Branch (944:17): [True: 2.16k, False: 2.28k]
  ------------------
  945|  2.16k|        {
  946|  2.16k|            int count1, count2;
  947|       |
  948|  2.16k|            if (val.size() == 9)
  ------------------
  |  Branch (948:17): [True: 1.53k, False: 625]
  ------------------
  949|  1.53k|            {
  950|  1.53k|                count1 = StringConverter::parseInt(val.substr(6, 1));
  951|  1.53k|                count2 = StringConverter::parseInt(val.substr(8, 1));
  952|  1.53k|            }
  953|    625|            else
  954|    625|                return false;
  955|       |
  956|  1.53k|            if (count1 > 4 || count1 < 2 || count2 > 4 || count2 < 2)
  ------------------
  |  Branch (956:17): [True: 135, False: 1.40k]
  |  Branch (956:31): [True: 323, False: 1.07k]
  |  Branch (956:45): [True: 105, False: 974]
  |  Branch (956:59): [True: 79, False: 895]
  ------------------
  957|    642|                return false;
  958|       |
  959|    895|            switch(count1)
  ------------------
  |  Branch (959:20): [True: 895, False: 0]
  ------------------
  960|    895|            {
  961|    199|            case 2:
  ------------------
  |  Branch (961:13): [True: 199, False: 696]
  ------------------
  962|    199|                *op = (GpuConstantType)(GCT_MATRIX_2X2 + count2 - 2);
  963|    199|                break;
  964|    319|            case 3:
  ------------------
  |  Branch (964:13): [True: 319, False: 576]
  ------------------
  965|    319|                *op = (GpuConstantType)(GCT_MATRIX_3X2 + count2 - 2);
  966|    319|                break;
  967|    377|            case 4:
  ------------------
  |  Branch (967:13): [True: 377, False: 518]
  ------------------
  968|    377|                *op = (GpuConstantType)(GCT_MATRIX_4X2 + count2 - 2);
  969|    377|                break;
  970|    895|            }
  971|       |
  972|    895|        }
  973|  2.28k|        else
  974|  2.28k|        {
  975|  2.28k|            return false;
  976|  2.28k|        }
  977|       |
  978|  7.08k|        return true;
  979|  13.5k|    }
_ZN4Ogre18MaterialTranslatorC2Ev:
  985|      1|    {
  986|      1|    }
_ZN4Ogre18MaterialTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE:
  989|  15.3k|    {
  990|  15.3k|        ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(node.get());
  991|  15.3k|        if(obj->name.empty())
  ------------------
  |  Branch (991:12): [True: 119, False: 15.2k]
  ------------------
  992|    119|        {
  993|    119|            compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line);
  994|    119|            return;
  995|    119|        }
  996|       |
  997|  15.2k|        Material* mMaterial = 0;
  998|       |
  999|       |        // Create a material with the given name
 1000|  15.2k|        CreateMaterialScriptCompilerEvent evt(node->file, obj->name, compiler->getResourceGroup());
 1001|  15.2k|        bool processed = compiler->_fireEvent(&evt, (void*)&mMaterial);
 1002|       |
 1003|  15.2k|        if(!processed)
  ------------------
  |  Branch (1003:12): [True: 15.2k, False: 0]
  ------------------
 1004|  15.2k|        {
 1005|  15.2k|            mMaterial = MaterialManager::getSingleton().create(obj->name, compiler->getResourceGroup()).get();
 1006|  15.2k|        }
 1007|       |
 1008|  15.2k|        if(!mMaterial)
  ------------------
  |  Branch (1008:12): [True: 0, False: 15.2k]
  ------------------
 1009|      0|        {
 1010|      0|            compiler->addError(ScriptCompiler::CE_OBJECTALLOCATIONERROR, obj->file, obj->line, obj->name);
 1011|      0|            return;
 1012|      0|        }
 1013|       |
 1014|  15.2k|        mMaterial->removeAllTechniques();
 1015|  15.2k|        obj->context = mMaterial;
 1016|  15.2k|        mMaterial->_notifyOrigin(obj->file);
 1017|       |
 1018|  15.2k|        bool bval;
 1019|  15.2k|        String sval;
 1020|       |
 1021|  15.2k|        for(auto & i : obj->children)
  ------------------
  |  Branch (1021:22): [True: 226k, False: 15.2k]
  ------------------
 1022|   226k|        {
 1023|   226k|            if(i->type == ANT_PROPERTY)
  ------------------
  |  Branch (1023:16): [True: 101k, False: 124k]
  ------------------
 1024|   101k|            {
 1025|   101k|                PropertyAbstractNode *prop = static_cast<PropertyAbstractNode*>(i.get());
 1026|   101k|                switch(prop->id)
 1027|   101k|                {
 1028|  5.41k|                case ID_LOD_VALUES:
  ------------------
  |  Branch (1028:17): [True: 5.41k, False: 96.2k]
  ------------------
 1029|  5.41k|                    {
 1030|  5.41k|                        Material::LodValueList lods;
 1031|  5.41k|                        for(const auto& j : prop->values)
  ------------------
  |  Branch (1031:43): [True: 74.3k, False: 5.41k]
  ------------------
 1032|  74.3k|                        {
 1033|  74.3k|                            Real v = 0;
 1034|  74.3k|                            if(getReal(j, &v))
  ------------------
  |  Branch (1034:32): [True: 49.9k, False: 24.4k]
  ------------------
 1035|  49.9k|                                lods.push_back(v);
 1036|  24.4k|                            else
 1037|  24.4k|                                compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line,
 1038|  24.4k|                                                   "lod_values expects only numbers as arguments");
 1039|  74.3k|                        }
 1040|  5.41k|                        mMaterial->setLodLevels(lods);
 1041|  5.41k|                    }
 1042|  5.41k|                    break;
 1043|      0|                case ID_LOD_DISTANCES:
  ------------------
  |  Branch (1043:17): [True: 0, False: 101k]
  ------------------
 1044|      0|                    {
 1045|       |                        // Deprecated! Only for backwards compatibility.
 1046|       |                        // Set strategy hard-coded to 'distance' strategy, since that was the only one available back then,
 1047|       |                        // when using this material keyword was still current.
 1048|      0|                        LodStrategy *strategy = DistanceLodSphereStrategy::getSingletonPtr();
 1049|      0|                        mMaterial->setLodStrategy(strategy);
 1050|       |
 1051|      0|                        compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file,
 1052|      0|                                           prop->line,
 1053|      0|                                           "lod_distances. Use lod_values.");
 1054|       |                        // Read in LOD distances
 1055|      0|                        Material::LodValueList lods;
 1056|      0|                        for(auto& j : prop->values)
  ------------------
  |  Branch (1056:37): [True: 0, False: 0]
  ------------------
 1057|      0|                        {
 1058|      0|                            Real v = 0;
 1059|      0|                            if(getReal(j, &v))
  ------------------
  |  Branch (1059:32): [True: 0, False: 0]
  ------------------
 1060|      0|                                lods.push_back(v);
 1061|      0|                            else
 1062|      0|                                compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line,
 1063|      0|                                                   "lod_values expects only numbers as arguments");
 1064|      0|                        }
 1065|      0|                        mMaterial->setLodLevels(lods);
 1066|      0|                    }
 1067|      0|                    break;
 1068|  9.87k|                case ID_LOD_STRATEGY:
  ------------------
  |  Branch (1068:17): [True: 9.87k, False: 91.7k]
  ------------------
 1069|  9.87k|                    if(getValue(prop, compiler, sval))
  ------------------
  |  Branch (1069:24): [True: 8.02k, False: 1.85k]
  ------------------
 1070|  8.02k|                    {
 1071|  8.02k|                            if (sval == "Distance" || sval == "PixelCount")
  ------------------
  |  Branch (1071:33): [True: 872, False: 7.14k]
  |  Branch (1071:55): [True: 531, False: 6.61k]
  ------------------
 1072|  1.40k|                                compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line,
 1073|  1.40k|                                                   sval + ". use distance_box or pixel_count");
 1074|       |
 1075|  8.02k|                            LodStrategy* strategy = LodStrategyManager::getSingleton().getStrategy(sval);
 1076|  8.02k|                            if (strategy)
  ------------------
  |  Branch (1076:33): [True: 1.94k, False: 6.07k]
  ------------------
 1077|  1.94k|                                mMaterial->setLodStrategy(strategy);
 1078|  6.07k|                            else
 1079|  6.07k|                                compiler->addError(*prop, sval);
 1080|  8.02k|                    }
 1081|  9.87k|                    break;
 1082|    797|                case ID_RECEIVE_SHADOWS:
  ------------------
  |  Branch (1082:17): [True: 797, False: 100k]
  ------------------
 1083|    797|                    if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (1083:24): [True: 424, False: 373]
  ------------------
 1084|    424|                        mMaterial->setReceiveShadows(bval);
 1085|    797|                    break;
 1086|    917|                case ID_TRANSPARENCY_CASTS_SHADOWS:
  ------------------
  |  Branch (1086:17): [True: 917, False: 100k]
  ------------------
 1087|    917|                    if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (1087:24): [True: 578, False: 339]
  ------------------
 1088|    578|                        mMaterial->setTransparencyCastsShadows(bval);
 1089|    917|                    break;
 1090|  4.02k|                case ID_SET_TEXTURE_ALIAS:
  ------------------
  |  Branch (1090:17): [True: 4.02k, False: 97.6k]
  ------------------
 1091|  4.02k|                    if(prop->values.size() != 2)
  ------------------
  |  Branch (1091:24): [True: 971, False: 3.05k]
  ------------------
 1092|    971|                    {
 1093|    971|                        compiler->addError(*prop, "set_texture_alias must have 2 string arguments");
 1094|    971|                    }
 1095|  3.05k|                    else
 1096|  3.05k|                    {
 1097|  3.05k|                        compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line,
 1098|  3.05k|                                            "set_texture_alias. Use 'set $variable value'");
 1099|       |
 1100|  3.05k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1);
 1101|  3.05k|                        String name, value;
 1102|  3.05k|                        if(getString(*i0, &name) && getString(*i1, &value))
  ------------------
  |  Branch (1102:28): [True: 2.81k, False: 238]
  |  Branch (1102:53): [True: 2.63k, False: 181]
  ------------------
 1103|  2.63k|                            mTextureAliases.insert(std::make_pair(name, value));
 1104|  3.05k|                    }
 1105|  4.02k|                    break;
 1106|  80.6k|                default:
  ------------------
  |  Branch (1106:17): [True: 80.6k, False: 21.0k]
  ------------------
 1107|  80.6k|                    compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line,
 1108|  80.6k|                                       "token \"" + prop->name + "\" is not recognized");
 1109|   101k|                }
 1110|   101k|            }
 1111|   124k|            else if(i->type == ANT_OBJECT)
  ------------------
  |  Branch (1111:21): [True: 44.5k, False: 79.8k]
  ------------------
 1112|  44.5k|            {
 1113|  44.5k|                processNode(compiler, i);
 1114|  44.5k|            }
 1115|   226k|        }
 1116|       |
 1117|  15.2k|        applyTextureAliases(compiler, mMaterial, mTextureAliases);
 1118|  15.2k|        mTextureAliases.clear();
 1119|  15.2k|    }
_ZN4Ogre19TechniqueTranslatorC2Ev:
 1125|      1|        :mTechnique(0)
 1126|      1|    {
 1127|      1|    }
_ZN4Ogre19TechniqueTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE:
 1130|  36.7k|    {
 1131|  36.7k|        ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(node.get());
 1132|       |
 1133|       |        // Create the technique from the material
 1134|  36.7k|        Ogre::Material *material = Ogre::any_cast<Ogre::Material*>(obj->parent->context);
 1135|  36.7k|        mTechnique = material->createTechnique();
 1136|  36.7k|        obj->context = mTechnique;
 1137|       |
 1138|       |        // Get the name of the technique
 1139|  36.7k|        if(!obj->name.empty())
  ------------------
  |  Branch (1139:12): [True: 26.0k, False: 10.7k]
  ------------------
 1140|  26.0k|            mTechnique->setName(obj->name);
 1141|       |
 1142|  36.7k|        uint32 uival;
 1143|  36.7k|        String sval;
 1144|       |
 1145|       |        // Set the properties for the material
 1146|  36.7k|        for(auto & i : obj->children)
  ------------------
  |  Branch (1146:22): [True: 290k, False: 36.7k]
  ------------------
 1147|   290k|        {
 1148|   290k|            if(i->type == ANT_PROPERTY)
  ------------------
  |  Branch (1148:16): [True: 113k, False: 176k]
  ------------------
 1149|   113k|            {
 1150|   113k|                PropertyAbstractNode *prop = static_cast<PropertyAbstractNode*>(i.get());
 1151|   113k|                switch(prop->id)
 1152|   113k|                {
 1153|  9.07k|                case ID_SCHEME:
  ------------------
  |  Branch (1153:17): [True: 9.07k, False: 104k]
  ------------------
 1154|  9.07k|                    if(getValue(prop, compiler, sval))
  ------------------
  |  Branch (1154:24): [True: 7.38k, False: 1.69k]
  ------------------
 1155|  7.38k|                        mTechnique->setSchemeName(sval);
 1156|  9.07k|                    break;
 1157|    690|                case ID_LOD_INDEX:
  ------------------
  |  Branch (1157:17): [True: 690, False: 113k]
  ------------------
 1158|    690|                    if(getValue(prop, compiler, uival))
  ------------------
  |  Branch (1158:24): [True: 192, False: 498]
  ------------------
 1159|    192|                        mTechnique->setLodIndex(static_cast<uint16>(uival));
 1160|    690|                    break;
 1161|  3.73k|                case ID_SHADOW_CASTER_MATERIAL:
  ------------------
  |  Branch (1161:17): [True: 3.73k, False: 110k]
  ------------------
 1162|  3.73k|                    if (getValue(prop, compiler, sval))
  ------------------
  |  Branch (1162:25): [True: 3.04k, False: 690]
  ------------------
 1163|  3.04k|                    {
 1164|  3.04k|                        try
 1165|  3.04k|                        {
 1166|  3.04k|                            mTechnique->setShadowCasterMaterial(processResourceName(compiler, ResourceType::MATERIAL, sval));
 1167|  3.04k|                        }
 1168|  3.04k|                        catch (Exception& e)
 1169|  3.04k|                        {
 1170|    552|                            compiler->addError(*prop, e.getDescription());
 1171|    552|                        }
 1172|  3.04k|                    }
 1173|  3.73k|                    break;
 1174|  3.73k|                case ID_SHADOW_RECEIVER_MATERIAL:
  ------------------
  |  Branch (1174:17): [True: 2.81k, False: 111k]
  ------------------
 1175|  2.81k|                    if (getValue(prop, compiler, sval))
  ------------------
  |  Branch (1175:25): [True: 2.17k, False: 646]
  ------------------
 1176|  2.17k|                    {
 1177|  2.17k|                        try
 1178|  2.17k|                        {
 1179|  2.17k|                            mTechnique->setShadowReceiverMaterial(processResourceName(compiler, ResourceType::MATERIAL, sval));
 1180|  2.17k|                        }
 1181|  2.17k|                        catch (Exception& e)
 1182|  2.17k|                        {
 1183|    325|                            compiler->addError(*prop, e.getDescription());
 1184|    325|                        }
 1185|  2.17k|                    }
 1186|  2.81k|                    break;
 1187|  5.63k|                case ID_GPU_VENDOR_RULE:
  ------------------
  |  Branch (1187:17): [True: 5.63k, False: 108k]
  ------------------
 1188|  5.63k|                    if(prop->values.size() < 2)
  ------------------
  |  Branch (1188:24): [True: 644, False: 4.98k]
  ------------------
 1189|    644|                    {
 1190|    644|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line,
 1191|    644|                                           "gpu_vendor_rule must have 2 arguments");
 1192|    644|                    }
 1193|  4.98k|                    else if(prop->values.size() > 2)
  ------------------
  |  Branch (1193:29): [True: 670, False: 4.31k]
  ------------------
 1194|    670|                    {
 1195|    670|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 1196|    670|                                           "gpu_vendor_rule must have 2 arguments");
 1197|    670|                    }
 1198|  4.31k|                    else
 1199|  4.31k|                    {
 1200|  4.31k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0);
 1201|  4.31k|                        AbstractNodeList::const_iterator i1 = getNodeAt(prop->values, 1);
 1202|       |
 1203|  4.31k|                        Technique::GPUVendorRule rule;
 1204|  4.31k|                        uint32 id0 = getAtomId(*i0);
 1205|  4.31k|                        if (id0 == ID_INCLUDE)
  ------------------
  |  Branch (1205:29): [True: 61, False: 4.25k]
  ------------------
 1206|     61|                        {
 1207|     61|                            rule.includeOrExclude = Technique::INCLUDE;
 1208|     61|                        }
 1209|  4.25k|                        else if (id0 == ID_EXCLUDE)
  ------------------
  |  Branch (1209:34): [True: 260, False: 3.99k]
  ------------------
 1210|    260|                        {
 1211|    260|                            rule.includeOrExclude = Technique::EXCLUDE;
 1212|    260|                        }
 1213|  3.99k|                        else
 1214|  3.99k|                        {
 1215|  3.99k|                            compiler->addError(*prop, "gpu_vendor_rule cannot accept \"" + (*i0)->getValue() + "\" as first argument");
 1216|  3.99k|                        }
 1217|       |
 1218|  4.31k|                        String vendor;
 1219|  4.31k|                        if(!getString(*i1, &vendor))
  ------------------
  |  Branch (1219:28): [True: 300, False: 4.01k]
  ------------------
 1220|    300|                            compiler->addError(*prop, "gpu_vendor_rule cannot accept \"" + (*i1)->getValue() + "\" as second argument");
 1221|       |
 1222|  4.31k|                        rule.vendor = RenderSystemCapabilities::vendorFromString(vendor);
 1223|       |
 1224|  4.31k|                        if (rule.vendor != GPU_UNKNOWN)
  ------------------
  |  Branch (1224:29): [True: 2.33k, False: 1.98k]
  ------------------
 1225|  2.33k|                        {
 1226|  2.33k|                            mTechnique->addGPUVendorRule(rule);
 1227|  2.33k|                        }
 1228|  4.31k|                    }
 1229|  5.63k|                    break;
 1230|  8.34k|                case ID_GPU_DEVICE_RULE:
  ------------------
  |  Branch (1230:17): [True: 8.34k, False: 105k]
  ------------------
 1231|  8.34k|                    if(prop->values.size() < 2)
  ------------------
  |  Branch (1231:24): [True: 770, False: 7.57k]
  ------------------
 1232|    770|                    {
 1233|    770|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line,
 1234|    770|                                           "gpu_device_rule must have at least 2 arguments");
 1235|    770|                    }
 1236|  7.57k|                    else if(prop->values.size() > 3)
  ------------------
  |  Branch (1236:29): [True: 992, False: 6.58k]
  ------------------
 1237|    992|                    {
 1238|    992|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 1239|    992|                                           "gpu_device_rule must have at most 3 arguments");
 1240|    992|                    }
 1241|  6.58k|                    else
 1242|  6.58k|                    {
 1243|  6.58k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0);
 1244|  6.58k|                        AbstractNodeList::const_iterator i1 = getNodeAt(prop->values, 1);
 1245|       |
 1246|  6.58k|                        Technique::GPUDeviceNameRule rule;
 1247|  6.58k|                        uint32 id0 = getAtomId(*i0);
 1248|  6.58k|                        if (id0 == ID_INCLUDE)
  ------------------
  |  Branch (1248:29): [True: 183, False: 6.40k]
  ------------------
 1249|    183|                        {
 1250|    183|                            rule.includeOrExclude = Technique::INCLUDE;
 1251|    183|                        }
 1252|  6.40k|                        else if (id0 == ID_EXCLUDE)
  ------------------
  |  Branch (1252:34): [True: 197, False: 6.20k]
  ------------------
 1253|    197|                        {
 1254|    197|                            rule.includeOrExclude = Technique::EXCLUDE;
 1255|    197|                        }
 1256|  6.20k|                        else
 1257|  6.20k|                        {
 1258|  6.20k|                            compiler->addError(*prop, "gpu_device_rule cannot accept \"" + (*i0)->getValue() + "\" as first argument");
 1259|  6.20k|                        }
 1260|       |
 1261|  6.58k|                        if(!getString(*i1, &rule.devicePattern))
  ------------------
  |  Branch (1261:28): [True: 915, False: 5.67k]
  ------------------
 1262|    915|                            compiler->addError(*prop, "gpu_device_rule cannot accept \"" + (*i1)->getValue() + "\" as second argument");
 1263|       |
 1264|  6.58k|                        if (prop->values.size() == 3)
  ------------------
  |  Branch (1264:29): [True: 2.92k, False: 3.65k]
  ------------------
 1265|  2.92k|                        {
 1266|  2.92k|                            AbstractNodeList::const_iterator i2 = getNodeAt(prop->values, 2);
 1267|  2.92k|                            if (!getBoolean(*i2, &rule.caseSensitive))
  ------------------
  |  Branch (1267:33): [True: 2.44k, False: 483]
  ------------------
 1268|  2.44k|                                compiler->addError(*prop, "gpu_device_rule third argument must be \"true\", \"false\", \"yes\", \"no\", \"on\", or \"off\"");
 1269|  2.92k|                        }
 1270|       |
 1271|  6.58k|                        mTechnique->addGPUDeviceNameRule(rule);
 1272|  6.58k|                    }
 1273|  8.34k|                    break;
 1274|  83.6k|                default:
  ------------------
  |  Branch (1274:17): [True: 83.6k, False: 30.2k]
  ------------------
 1275|  83.6k|                    compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line,
 1276|  83.6k|                                       "token \"" + prop->name + "\" is not recognized");
 1277|   113k|                }
 1278|   113k|            }
 1279|   176k|            else if(i->type == ANT_OBJECT)
  ------------------
  |  Branch (1279:21): [True: 82.7k, False: 93.6k]
  ------------------
 1280|  82.7k|            {
 1281|  82.7k|                processNode(compiler, i);
 1282|  82.7k|            }
 1283|   290k|        }
 1284|  36.7k|    }
_ZN4Ogre14PassTranslatorC2Ev:
 1290|      1|        :mPass(0)
 1291|      1|    {
 1292|      1|    }
_ZN4Ogre14PassTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE:
 1295|  69.5k|    {
 1296|  69.5k|        ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(node.get());
 1297|       |
 1298|  69.5k|        Technique *technique = any_cast<Technique*>(obj->parent->context);
 1299|  69.5k|        mPass = technique->createPass();
 1300|  69.5k|        obj->context = mPass;
 1301|       |
 1302|       |        // Get the name of the technique
 1303|  69.5k|        if(!obj->name.empty())
  ------------------
  |  Branch (1303:12): [True: 58.1k, False: 11.4k]
  ------------------
 1304|  58.1k|            mPass->setName(obj->name);
 1305|       |
 1306|  69.5k|        Real fval;
 1307|  69.5k|        bool bval;
 1308|  69.5k|        uint32 uival;
 1309|       |
 1310|       |        // Set the properties for the material
 1311|  69.5k|        for(auto & i : obj->children)
  ------------------
  |  Branch (1311:22): [True: 930k, False: 68.4k]
  ------------------
 1312|   930k|        {
 1313|   930k|            if(i->type == ANT_PROPERTY)
  ------------------
  |  Branch (1313:16): [True: 620k, False: 310k]
  ------------------
 1314|   620k|            {
 1315|   620k|                PropertyAbstractNode *prop = static_cast<PropertyAbstractNode*>(i.get());
 1316|   620k|                switch(prop->id)
 1317|   620k|                {
 1318|  6.77k|                case ID_AMBIENT:
  ------------------
  |  Branch (1318:17): [True: 6.77k, False: 613k]
  ------------------
 1319|  6.77k|                    if(prop->values.empty())
  ------------------
  |  Branch (1319:24): [True: 867, False: 5.90k]
  ------------------
 1320|    867|                    {
 1321|    867|                        compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line);
 1322|    867|                    }
 1323|  5.90k|                    else if(prop->values.size() > 4)
  ------------------
  |  Branch (1323:29): [True: 333, False: 5.57k]
  ------------------
 1324|    333|                    {
 1325|    333|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 1326|    333|                                           "ambient must have at most 4 parameters");
 1327|    333|                    }
 1328|  5.57k|                    else
 1329|  5.57k|                    {
 1330|  5.57k|                        if(getAtomId(prop->values.front()) == ID_VERTEXCOLOUR)
  ------------------
  |  Branch (1330:28): [True: 383, False: 5.19k]
  ------------------
 1331|    383|                        {
 1332|    383|                            mPass->setVertexColourTracking(mPass->getVertexColourTracking() | TVC_AMBIENT);
 1333|    383|                        }
 1334|  5.19k|                        else
 1335|  5.19k|                        {
 1336|  5.19k|                            ColourValue val = ColourValue::White;
 1337|  5.19k|                            if(getColour(prop->values.begin(), prop->values.end(), &val))
  ------------------
  |  Branch (1337:32): [True: 577, False: 4.61k]
  ------------------
 1338|    577|                                mPass->setAmbient(val);
 1339|  4.61k|                            else
 1340|  4.61k|                                compiler->addError(*prop, "ambient requires 3 or 4 colour arguments, or a \"vertexcolour\" directive");
 1341|  5.19k|                        }
 1342|  5.57k|                    }
 1343|  6.77k|                    break;
 1344|  6.15k|                case ID_DIFFUSE:
  ------------------
  |  Branch (1344:17): [True: 6.15k, False: 614k]
  ------------------
 1345|  6.15k|                    if(prop->values.empty())
  ------------------
  |  Branch (1345:24): [True: 231, False: 5.92k]
  ------------------
 1346|    231|                    {
 1347|    231|                        compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line);
 1348|    231|                    }
 1349|  5.92k|                    else if(prop->values.size() > 4)
  ------------------
  |  Branch (1349:29): [True: 588, False: 5.33k]
  ------------------
 1350|    588|                    {
 1351|    588|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 1352|    588|                                           "diffuse must have at most 4 arguments");
 1353|    588|                    }
 1354|  5.33k|                    else
 1355|  5.33k|                    {
 1356|  5.33k|                        if(getAtomId(prop->values.front()) == ID_VERTEXCOLOUR)
  ------------------
  |  Branch (1356:28): [True: 679, False: 4.65k]
  ------------------
 1357|    679|                        {
 1358|    679|                            mPass->setVertexColourTracking(mPass->getVertexColourTracking() | TVC_DIFFUSE);
 1359|    679|                        }
 1360|  4.65k|                        else
 1361|  4.65k|                        {
 1362|  4.65k|                            ColourValue val = ColourValue::White;
 1363|  4.65k|                            if(getColour(prop->values.begin(), prop->values.end(), &val))
  ------------------
  |  Branch (1363:32): [True: 871, False: 3.78k]
  ------------------
 1364|    871|                                mPass->setDiffuse(val);
 1365|  3.78k|                            else
 1366|  3.78k|                                compiler->addError(*prop, "diffuse requires 3 or 4 colour arguments, or a \"vertexcolour\" directive");
 1367|  4.65k|                        }
 1368|  5.33k|                    }
 1369|  6.15k|                    break;
 1370|  4.54k|                case ID_SPECULAR:
  ------------------
  |  Branch (1370:17): [True: 4.54k, False: 615k]
  ------------------
 1371|  4.54k|                    if(prop->values.empty())
  ------------------
  |  Branch (1371:24): [True: 226, False: 4.31k]
  ------------------
 1372|    226|                    {
 1373|    226|                        compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line);
 1374|    226|                    }
 1375|  4.31k|                    else if(prop->values.size() > 5)
  ------------------
  |  Branch (1375:29): [True: 381, False: 3.93k]
  ------------------
 1376|    381|                    {
 1377|    381|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 1378|    381|                                           "specular must have at most 5 arguments");
 1379|    381|                    }
 1380|  3.93k|                    else
 1381|  3.93k|                    {
 1382|  3.93k|                        if(getAtomId(prop->values.front()) == ID_VERTEXCOLOUR)
  ------------------
  |  Branch (1382:28): [True: 782, False: 3.15k]
  ------------------
 1383|    782|                        {
 1384|    782|                            mPass->setVertexColourTracking(mPass->getVertexColourTracking() | TVC_SPECULAR);
 1385|       |
 1386|    782|                            if(prop->values.size() >= 2)
  ------------------
  |  Branch (1386:32): [True: 549, False: 233]
  ------------------
 1387|    549|                            {
 1388|    549|                                Real val = 0;
 1389|    549|                                if(getReal(prop->values.back(), &val))
  ------------------
  |  Branch (1389:36): [True: 110, False: 439]
  ------------------
 1390|    110|                                    mPass->setShininess(val);
 1391|    439|                                else
 1392|    439|                                    compiler->addError(*prop, "specular does not support \"" + prop->values.back()->getValue() + "\" as its second argument");
 1393|    549|                            }
 1394|    782|                        }
 1395|  3.15k|                        else
 1396|  3.15k|                        {
 1397|  3.15k|                            if(prop->values.size() < 4)
  ------------------
  |  Branch (1397:32): [True: 1.09k, False: 2.06k]
  ------------------
 1398|  1.09k|                            {
 1399|  1.09k|                                compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line,
 1400|  1.09k|                                                   "specular expects at least 4 arguments");
 1401|  1.09k|                            }
 1402|  2.06k|                            else
 1403|  2.06k|                            {
 1404|  2.06k|                                ColourValue val;
 1405|  2.06k|                                if(getColour(prop->values.begin(), prop->values.end(), &val))
  ------------------
  |  Branch (1405:36): [True: 1.55k, False: 508]
  ------------------
 1406|  1.55k|                                {
 1407|  1.55k|                                    if(prop->values.size() == 4)
  ------------------
  |  Branch (1407:40): [True: 917, False: 636]
  ------------------
 1408|    917|                                    {
 1409|    917|                                        mPass->setShininess(val.a);
 1410|    917|                                        val.a = 1.0f;
 1411|    917|                                        mPass->setSpecular(val);
 1412|    917|                                    }
 1413|    636|                                    else
 1414|    636|                                    {
 1415|    636|                                        mPass->setSpecular(val);
 1416|       |
 1417|    636|                                        Real shininess;
 1418|    636|                                        if(getReal(*getNodeAt(prop->values, 4), &shininess))
  ------------------
  |  Branch (1418:44): [True: 407, False: 229]
  ------------------
 1419|    407|                                            mPass->setShininess(shininess);
 1420|    229|                                        else
 1421|    229|                                            compiler->addError(*prop, "specular fourth argument must be a valid number for shininess attribute");
 1422|    636|                                    }
 1423|  1.55k|                                }
 1424|    508|                                else
 1425|    508|                                {
 1426|    508|                                    compiler->addError(*prop, "specular must have first 3 arguments be a valid colour");
 1427|    508|                                }
 1428|  2.06k|                            }
 1429|       |
 1430|  3.15k|                        }
 1431|  3.93k|                    }
 1432|  4.54k|                    break;
 1433|  38.2k|                case ID_EMISSIVE:
  ------------------
  |  Branch (1433:17): [True: 38.2k, False: 581k]
  ------------------
 1434|  38.2k|                    if(prop->values.empty())
  ------------------
  |  Branch (1434:24): [True: 259, False: 38.0k]
  ------------------
 1435|    259|                    {
 1436|    259|                        compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line);
 1437|    259|                    }
 1438|  38.0k|                    else if(prop->values.size() > 4)
  ------------------
  |  Branch (1438:29): [True: 19.8k, False: 18.2k]
  ------------------
 1439|  19.8k|                    {
 1440|  19.8k|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 1441|  19.8k|                                           "emissive must have at most 4 arguments");
 1442|  19.8k|                    }
 1443|  18.2k|                    else
 1444|  18.2k|                    {
 1445|  18.2k|                        if(getAtomId(prop->values.front()) == ID_VERTEXCOLOUR)
  ------------------
  |  Branch (1445:28): [True: 414, False: 17.7k]
  ------------------
 1446|    414|                        {
 1447|    414|                            mPass->setVertexColourTracking(mPass->getVertexColourTracking() | TVC_EMISSIVE);
 1448|    414|                        }
 1449|  17.7k|                        else
 1450|  17.7k|                        {
 1451|  17.7k|                            ColourValue val(0.0f, 0.0f, 0.0f, 1.0f);
 1452|  17.7k|                            if(getColour(prop->values.begin(), prop->values.end(), &val))
  ------------------
  |  Branch (1452:32): [True: 1.59k, False: 16.1k]
  ------------------
 1453|  1.59k|                                mPass->setSelfIllumination(val);
 1454|  16.1k|                            else
 1455|  16.1k|                                compiler->addError(*prop, "emissive requires 3 or 4 colour arguments, or a \"vertexcolour\" directive");
 1456|  17.7k|                        }
 1457|  18.2k|                    }
 1458|  38.2k|                    break;
 1459|  13.8k|                case ID_SCENE_BLEND:
  ------------------
  |  Branch (1459:17): [True: 13.8k, False: 606k]
  ------------------
 1460|  13.8k|                    if(prop->values.size() == 1)
  ------------------
  |  Branch (1460:24): [True: 9.59k, False: 4.23k]
  ------------------
 1461|  9.59k|                    {
 1462|  9.59k|                        SceneBlendType enval;
 1463|  9.59k|                        if(getValue(prop->values.front(), enval))
  ------------------
  |  Branch (1463:28): [True: 8.73k, False: 869]
  ------------------
 1464|  8.73k|                        {
 1465|  8.73k|                            mPass->setSceneBlending(enval);
 1466|  8.73k|                        }
 1467|    869|                        else
 1468|    869|                        {
 1469|    869|                            compiler->addError(*prop, prop->values.front()->getString());
 1470|    869|                        }
 1471|  9.59k|                    }
 1472|  4.23k|                    else if(prop->values.size() == 2)
  ------------------
  |  Branch (1472:29): [True: 3.33k, False: 893]
  ------------------
 1473|  3.33k|                    {
 1474|  3.33k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1);
 1475|  3.33k|                        SceneBlendFactor sbf0, sbf1;
 1476|  3.33k|                        if(getSceneBlendFactor(*i0, &sbf0) && getSceneBlendFactor(*i1, &sbf1))
  ------------------
  |  Branch (1476:28): [True: 1.59k, False: 1.74k]
  |  Branch (1476:63): [True: 509, False: 1.08k]
  ------------------
 1477|    509|                        {
 1478|    509|                            mPass->setSceneBlending(sbf0, sbf1);
 1479|    509|                        }
 1480|  2.83k|                        else
 1481|  2.83k|                        {
 1482|  2.83k|                            compiler->addError(*prop, "scene_blend does not support \"" + (*i0)->getValue() + "\" and \"" + (*i1)->getValue() + "\" as arguments");
 1483|  2.83k|                        }
 1484|  3.33k|                    }
 1485|    893|                    else
 1486|    893|                    {
 1487|    893|                        compiler->addError(*prop, "scene_blend must have 1 or 2 arguments");
 1488|    893|                    }
 1489|  13.8k|                    break;
 1490|  8.87k|                case ID_SEPARATE_SCENE_BLEND:
  ------------------
  |  Branch (1490:17): [True: 8.87k, False: 611k]
  ------------------
 1491|  8.87k|                    if(prop->values.size() == 2)
  ------------------
  |  Branch (1491:24): [True: 4.70k, False: 4.17k]
  ------------------
 1492|  4.70k|                    {
 1493|  4.70k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1);
 1494|  4.70k|                        SceneBlendType sbt0, sbt1;
 1495|  4.70k|                        if (getValue(*i0, sbt0) && getValue(*i1, sbt1))
  ------------------
  |  Branch (1495:29): [True: 4.02k, False: 683]
  |  Branch (1495:52): [True: 986, False: 3.03k]
  ------------------
 1496|    986|                        {
 1497|    986|                            mPass->setSeparateSceneBlending(sbt0, sbt1);
 1498|    986|                        }
 1499|  3.71k|                        else
 1500|  3.71k|                        {
 1501|  3.71k|                            compiler->addError(*prop, "one of the arguments to separate_scene_blend is not a valid "
 1502|  3.71k|                                                      "scene blend factor directive");
 1503|  3.71k|                        }
 1504|  4.70k|                    }
 1505|  4.17k|                    else if(prop->values.size() == 4)
  ------------------
  |  Branch (1505:29): [True: 3.53k, False: 636]
  ------------------
 1506|  3.53k|                    {
 1507|  3.53k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1),
 1508|  3.53k|                            i2 = getNodeAt(prop->values, 2), i3 = getNodeAt(prop->values, 3);
 1509|  3.53k|                        SceneBlendFactor sbf0, sbf1, sbf2, sbf3;
 1510|  3.53k|                        if(getSceneBlendFactor(*i0, &sbf0) && getSceneBlendFactor(*i1, &sbf1) && getSceneBlendFactor(*i2, &sbf2) &&
  ------------------
  |  Branch (1510:28): [True: 2.89k, False: 642]
  |  Branch (1510:63): [True: 1.96k, False: 927]
  |  Branch (1510:98): [True: 1.15k, False: 812]
  ------------------
 1511|  1.15k|                            getSceneBlendFactor(*i3, &sbf3))
  ------------------
  |  Branch (1511:29): [True: 227, False: 930]
  ------------------
 1512|    227|                        {
 1513|    227|                            mPass->setSeparateSceneBlending(sbf0, sbf1, sbf2, sbf3);
 1514|    227|                        }
 1515|  3.31k|                        else
 1516|  3.31k|                        {
 1517|  3.31k|                            compiler->addError(*prop, "one of the arguments to separate_scene_blend is not a valid "
 1518|  3.31k|                                                      "scene blend factor");
 1519|  3.31k|                        }
 1520|  3.53k|                    }
 1521|    636|                    else
 1522|    636|                    {
 1523|    636|                        compiler->addError(*prop, "separate_scene_blend must have 2 or 4 arguments");
 1524|    636|                    }
 1525|  8.87k|                    break;
 1526|  2.78k|                case ID_SCENE_BLEND_OP:
  ------------------
  |  Branch (1526:17): [True: 2.78k, False: 617k]
  ------------------
 1527|  2.78k|                    SceneBlendOperation sop;
 1528|  2.78k|                    if(getValue(prop, compiler, sop))
  ------------------
  |  Branch (1528:24): [True: 1.20k, False: 1.57k]
  ------------------
 1529|  1.20k|                        mPass->setSceneBlendingOperation(sop);
 1530|  2.78k|                    break;
 1531|  4.61k|                case ID_SEPARATE_SCENE_BLEND_OP:
  ------------------
  |  Branch (1531:17): [True: 4.61k, False: 615k]
  ------------------
 1532|  4.61k|                    if(prop->values.empty())
  ------------------
  |  Branch (1532:24): [True: 528, False: 4.09k]
  ------------------
 1533|    528|                    {
 1534|    528|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 1535|    528|                    }
 1536|  4.09k|                    else if(prop->values.size() != 2)
  ------------------
  |  Branch (1536:29): [True: 752, False: 3.33k]
  ------------------
 1537|    752|                    {
 1538|    752|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 1539|    752|                                           "separate_scene_blend_op must have 2 arguments");
 1540|    752|                    }
 1541|  3.33k|                    else
 1542|  3.33k|                    {
 1543|  3.33k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1);
 1544|  3.33k|                        SceneBlendOperation op, alphaOp;
 1545|  3.33k|                        if(getValue(*i0, op) && getValue(*i1, alphaOp))
  ------------------
  |  Branch (1545:28): [True: 2.32k, False: 1.01k]
  |  Branch (1545:49): [True: 1.12k, False: 1.20k]
  ------------------
 1546|  1.12k|                        {
 1547|  1.12k|                            mPass->setSeparateSceneBlendingOperation(op, alphaOp);
 1548|  1.12k|                        }
 1549|  2.21k|                        else
 1550|  2.21k|                        {
 1551|  2.21k|                            compiler->addError(*prop, prop->values.front()->getValue() + ": unrecognized argument");
 1552|  2.21k|                        }
 1553|  3.33k|                    }
 1554|  4.61k|                    break;
 1555|  31.4k|                case ID_DEPTH_CHECK:
  ------------------
  |  Branch (1555:17): [True: 31.4k, False: 588k]
  ------------------
 1556|  31.4k|                    if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (1556:24): [True: 27.9k, False: 3.53k]
  ------------------
 1557|  27.9k|                        mPass->setDepthCheckEnabled(bval);
 1558|  31.4k|                    break;
 1559|  29.2k|                case ID_DEPTH_WRITE:
  ------------------
  |  Branch (1559:17): [True: 29.2k, False: 591k]
  ------------------
 1560|  29.2k|                    if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (1560:24): [True: 27.9k, False: 1.30k]
  ------------------
 1561|  27.9k|                        mPass->setDepthWriteEnabled(bval);
 1562|  29.2k|                    break;
 1563|  3.32k|                case ID_DEPTH_BIAS:
  ------------------
  |  Branch (1563:17): [True: 3.32k, False: 616k]
  ------------------
 1564|  3.32k|                    if(prop->values.empty())
  ------------------
  |  Branch (1564:24): [True: 397, False: 2.93k]
  ------------------
 1565|    397|                    {
 1566|    397|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 1567|    397|                    }
 1568|  2.93k|                    else if(prop->values.size() > 2)
  ------------------
  |  Branch (1568:29): [True: 510, False: 2.42k]
  ------------------
 1569|    510|                    {
 1570|    510|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 1571|    510|                                           "depth_bias must have at most 2 arguments");
 1572|    510|                    }
 1573|  2.42k|                    else
 1574|  2.42k|                    {
 1575|  2.42k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1);
 1576|  2.42k|                        float val0, val1 = 0.0f;
 1577|  2.42k|                        if(getFloat(*i0, &val0))
  ------------------
  |  Branch (1577:28): [True: 1.45k, False: 962]
  ------------------
 1578|  1.45k|                        {
 1579|  1.45k|                            if(i1 != prop->values.end())
  ------------------
  |  Branch (1579:32): [True: 1.07k, False: 384]
  ------------------
 1580|  1.07k|                                getFloat(*i1, &val1);
 1581|  1.45k|                            mPass->setDepthBias(val0, val1);
 1582|  1.45k|                        }
 1583|    962|                        else
 1584|    962|                        {
 1585|    962|                            compiler->addError(*prop, "depth_bias does not support \"" + (*i0)->getValue() + "\" for argument 1");
 1586|    962|                        }
 1587|  2.42k|                    }
 1588|  3.32k|                    break;
 1589|  1.58k|                case ID_DEPTH_FUNC:
  ------------------
  |  Branch (1589:17): [True: 1.58k, False: 618k]
  ------------------
 1590|  1.58k|                    CompareFunction dfunc;
 1591|  1.58k|                    if(getValue(prop, compiler, dfunc))
  ------------------
  |  Branch (1591:24): [True: 557, False: 1.03k]
  ------------------
 1592|    557|                        mPass->setDepthFunction(dfunc);
 1593|  1.58k|                    break;
 1594|    681|                case ID_ITERATION_DEPTH_BIAS:
  ------------------
  |  Branch (1594:17): [True: 681, False: 619k]
  ------------------
 1595|    681|                    if(getValue(prop, compiler, fval))
  ------------------
  |  Branch (1595:24): [True: 259, False: 422]
  ------------------
 1596|    259|                        mPass->setIterationDepthBias(fval);
 1597|    681|                    break;
 1598|  6.16k|                case ID_ALPHA_REJECTION:
  ------------------
  |  Branch (1598:17): [True: 6.16k, False: 614k]
  ------------------
 1599|  6.16k|                    if(prop->values.empty())
  ------------------
  |  Branch (1599:24): [True: 279, False: 5.88k]
  ------------------
 1600|    279|                    {
 1601|    279|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 1602|    279|                    }
 1603|  5.88k|                    else if(prop->values.size() > 2)
  ------------------
  |  Branch (1603:29): [True: 376, False: 5.50k]
  ------------------
 1604|    376|                    {
 1605|    376|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 1606|    376|                                           "alpha_rejection must have at most 2 arguments");
 1607|    376|                    }
 1608|  5.50k|                    else
 1609|  5.50k|                    {
 1610|  5.50k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1);
 1611|  5.50k|                        CompareFunction func;
 1612|  5.50k|                        if(getCompareFunction(*i0, &func))
  ------------------
  |  Branch (1612:28): [True: 4.32k, False: 1.18k]
  ------------------
 1613|  4.32k|                        {
 1614|  4.32k|                            if(i1 != prop->values.end())
  ------------------
  |  Branch (1614:32): [True: 4.09k, False: 235]
  ------------------
 1615|  4.09k|                            {
 1616|  4.09k|                                uint32 val = 0;
 1617|  4.09k|                                if(getUInt(*i1, &val))
  ------------------
  |  Branch (1617:36): [True: 241, False: 3.84k]
  ------------------
 1618|    241|                                    mPass->setAlphaRejectSettings(func, static_cast<unsigned char>(val));
 1619|  3.84k|                                else
 1620|  3.84k|                                    compiler->addError(*prop, (*i1)->getValue() + " is not a valid integer");
 1621|  4.09k|                            }
 1622|    235|                            else
 1623|    235|                                mPass->setAlphaRejectFunction(func);
 1624|  4.32k|                        }
 1625|  1.18k|                        else
 1626|  1.18k|                            compiler->addError(*prop, (*i0)->getValue() + " is not a valid CompareFunction");
 1627|  5.50k|                    }
 1628|  6.16k|                    break;
 1629|    895|                case ID_ALPHA_TO_COVERAGE:
  ------------------
  |  Branch (1629:17): [True: 895, False: 619k]
  ------------------
 1630|    895|                    if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (1630:24): [True: 334, False: 561]
  ------------------
 1631|    334|                        mPass->setAlphaToCoverageEnabled(bval);
 1632|    895|                    break;
 1633|  1.31k|                case ID_LIGHT_SCISSOR:
  ------------------
  |  Branch (1633:17): [True: 1.31k, False: 618k]
  ------------------
 1634|  1.31k|                    if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (1634:24): [True: 250, False: 1.06k]
  ------------------
 1635|    250|                        mPass->setLightScissoringEnabled(bval);
 1636|  1.31k|                    break;
 1637|    737|                case ID_LIGHT_CLIP_PLANES:
  ------------------
  |  Branch (1637:17): [True: 737, False: 619k]
  ------------------
 1638|    737|                    if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (1638:24): [True: 178, False: 559]
  ------------------
 1639|    178|                        mPass->setLightClipPlanesEnabled(bval);
 1640|    737|                    break;
 1641|  3.35k|                case ID_TRANSPARENT_SORTING:
  ------------------
  |  Branch (1641:17): [True: 3.35k, False: 616k]
  ------------------
 1642|  3.35k|                    if(prop->values.empty())
  ------------------
  |  Branch (1642:24): [True: 328, False: 3.02k]
  ------------------
 1643|    328|                    {
 1644|    328|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 1645|    328|                    }
 1646|  3.02k|                    else if(prop->values.size() > 1)
  ------------------
  |  Branch (1646:29): [True: 545, False: 2.48k]
  ------------------
 1647|    545|                    {
 1648|    545|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 1649|    545|                                           "transparent_sorting must have at most 1 argument");
 1650|    545|                    }
 1651|  2.48k|                    else
 1652|  2.48k|                    {
 1653|  2.48k|                        bool val = true;
 1654|  2.48k|                        if(getBoolean(prop->values.front(), &val))
  ------------------
  |  Branch (1654:28): [True: 346, False: 2.13k]
  ------------------
 1655|    346|                        {
 1656|    346|                            mPass->setTransparentSortingEnabled(val);
 1657|    346|                            mPass->setTransparentSortingForced(false);
 1658|    346|                        }
 1659|  2.13k|                        else
 1660|  2.13k|                        {
 1661|  2.13k|                            String val2;
 1662|  2.13k|                            if (prop->values.front()->getString()=="force")
  ------------------
  |  Branch (1662:33): [True: 569, False: 1.56k]
  ------------------
 1663|    569|                            {
 1664|    569|                                mPass->setTransparentSortingEnabled(true);
 1665|    569|                                mPass->setTransparentSortingForced(true);
 1666|    569|                            }
 1667|  1.56k|                            else
 1668|  1.56k|                            {
 1669|  1.56k|                                compiler->addError(*prop, prop->values.front()->getValue() + " must be boolean or force");
 1670|  1.56k|                            }
 1671|  2.13k|                        }
 1672|  2.48k|                    }
 1673|  3.35k|                    break;
 1674|  3.59k|                case ID_ILLUMINATION_STAGE:
  ------------------
  |  Branch (1674:17): [True: 3.59k, False: 616k]
  ------------------
 1675|  3.59k|                    IlluminationStage is;
 1676|  3.59k|                    if(getValue(prop, compiler, is))
  ------------------
  |  Branch (1676:24): [True: 1.01k, False: 2.57k]
  ------------------
 1677|  1.01k|                        mPass->setIlluminationStage(is);
 1678|  3.59k|                    break;
 1679|  39.0k|                case ID_CULL_HARDWARE:
  ------------------
  |  Branch (1679:17): [True: 39.0k, False: 581k]
  ------------------
 1680|  39.0k|                    CullingMode cmode;
 1681|  39.0k|                    if(getValue(prop, compiler, cmode))
  ------------------
  |  Branch (1681:24): [True: 34.4k, False: 4.56k]
  ------------------
 1682|  34.4k|                        mPass->setCullingMode(cmode);
 1683|  39.0k|                    break;
 1684|  1.73k|                case ID_CULL_SOFTWARE:
  ------------------
  |  Branch (1684:17): [True: 1.73k, False: 618k]
  ------------------
 1685|  1.73k|                    ManualCullingMode mmode;
 1686|  1.73k|                    if(getValue(prop, compiler, mmode))
  ------------------
  |  Branch (1686:24): [True: 683, False: 1.05k]
  ------------------
 1687|    683|                        mPass->setManualCullingMode(mmode);
 1688|  1.73k|                    compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line,
 1689|  1.73k|                                       prop->name + ". Only used by the BSP scene manager.");
 1690|  1.73k|                    break;
 1691|  3.75k|                case ID_LIGHTING:
  ------------------
  |  Branch (1691:17): [True: 3.75k, False: 616k]
  ------------------
 1692|  3.75k|                    if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (1692:24): [True: 1.48k, False: 2.27k]
  ------------------
 1693|  1.48k|                        mPass->setLightingEnabled(bval);
 1694|  3.75k|                    break;
 1695|  1.53k|                case ID_SHADING:
  ------------------
  |  Branch (1695:17): [True: 1.53k, False: 618k]
  ------------------
 1696|  1.53k|                    ShadeOptions smode;
 1697|  1.53k|                    if(getValue(prop, compiler, smode))
  ------------------
  |  Branch (1697:24): [True: 309, False: 1.22k]
  ------------------
 1698|    309|                        mPass->setShadingMode(smode);
 1699|  1.53k|                    break;
 1700|  2.74k|                case ID_POLYGON_MODE:
  ------------------
  |  Branch (1700:17): [True: 2.74k, False: 617k]
  ------------------
 1701|  2.74k|                    PolygonMode pmode;
 1702|  2.74k|                    if(getValue(prop, compiler, pmode))
  ------------------
  |  Branch (1702:24): [True: 308, False: 2.43k]
  ------------------
 1703|    308|                        mPass->setPolygonMode(pmode);
 1704|  2.74k|                    break;
 1705|    386|                case ID_POLYGON_MODE_OVERRIDEABLE:
  ------------------
  |  Branch (1705:17): [True: 386, False: 619k]
  ------------------
 1706|    386|                    if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (1706:24): [True: 99, False: 287]
  ------------------
 1707|     99|                        mPass->setPolygonModeOverrideable(bval);
 1708|    386|                    break;
 1709|  8.90k|                case ID_FOG_OVERRIDE:
  ------------------
  |  Branch (1709:17): [True: 8.90k, False: 611k]
  ------------------
 1710|  8.90k|                    if(prop->values.empty())
  ------------------
  |  Branch (1710:24): [True: 294, False: 8.61k]
  ------------------
 1711|    294|                    {
 1712|    294|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 1713|    294|                    }
 1714|  8.61k|                    else if(prop->values.size() > 8)
  ------------------
  |  Branch (1714:29): [True: 377, False: 8.23k]
  ------------------
 1715|    377|                    {
 1716|    377|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 1717|    377|                                           "fog_override must have at most 8 arguments");
 1718|    377|                    }
 1719|  8.23k|                    else
 1720|  8.23k|                    {
 1721|  8.23k|                        AbstractNodeList::const_iterator i1 = getNodeAt(prop->values, 1), i2 = getNodeAt(prop->values, 2);
 1722|  8.23k|                        bool val = false;
 1723|  8.23k|                        if(getBoolean(prop->values.front(), &val))
  ------------------
  |  Branch (1723:28): [True: 6.19k, False: 2.04k]
  ------------------
 1724|  6.19k|                        {
 1725|  6.19k|                            FogMode mode = FOG_NONE;
 1726|  6.19k|                            ColourValue clr = ColourValue::White;
 1727|  6.19k|                            Real dens = 0.001, start = 0.0f, end = 1.0f;
 1728|       |
 1729|  6.19k|                            if(i1 != prop->values.end())
  ------------------
  |  Branch (1729:32): [True: 5.90k, False: 285]
  ------------------
 1730|  5.90k|                            {
 1731|  5.90k|                                if((*i1)->type == ANT_ATOM)
  ------------------
  |  Branch (1731:36): [True: 5.69k, False: 215]
  ------------------
 1732|  5.69k|                                {
 1733|  5.69k|                                    AtomAbstractNode *atom = (AtomAbstractNode*)(*i1).get();
 1734|  5.69k|                                    switch(atom->id)
 1735|  5.69k|                                    {
 1736|     77|                                    case ID_NONE:
  ------------------
  |  Branch (1736:37): [True: 77, False: 5.61k]
  ------------------
 1737|     77|                                        mode = FOG_NONE;
 1738|     77|                                        break;
 1739|    533|                                    case ID_LINEAR:
  ------------------
  |  Branch (1739:37): [True: 533, False: 5.16k]
  ------------------
 1740|    533|                                        mode = FOG_LINEAR;
 1741|    533|                                        break;
 1742|    403|                                    case ID_EXP:
  ------------------
  |  Branch (1742:37): [True: 403, False: 5.29k]
  ------------------
 1743|    403|                                        mode = FOG_EXP;
 1744|    403|                                        break;
 1745|      1|                                    case ID_EXP2:
  ------------------
  |  Branch (1745:37): [True: 1, False: 5.69k]
  ------------------
 1746|      1|                                        mode = FOG_EXP2;
 1747|      1|                                        break;
 1748|  4.68k|                                    default:
  ------------------
  |  Branch (1748:37): [True: 4.68k, False: 1.01k]
  ------------------
 1749|  4.68k|                                        compiler->addError(*prop, (*i1)->getValue() + " is not a valid FogMode");
 1750|  4.68k|                                        break;
 1751|  5.69k|                                    }
 1752|  5.69k|                                }
 1753|    215|                                else
 1754|    215|                                {
 1755|    215|                                    compiler->addError(*prop, (*i1)->getValue() + " is not a valid FogMode");
 1756|    215|                                    break;
 1757|    215|                                }
 1758|  5.90k|                            }
 1759|       |
 1760|  5.97k|                            if(i2 != prop->values.end())
  ------------------
  |  Branch (1760:32): [True: 4.97k, False: 1.00k]
  ------------------
 1761|  4.97k|                            {
 1762|  4.97k|                                if(!getColour(i2, prop->values.end(), &clr, 3))
  ------------------
  |  Branch (1762:36): [True: 3.09k, False: 1.87k]
  ------------------
 1763|  3.09k|                                {
 1764|  3.09k|                                    compiler->addError(*prop, (*i2)->getValue() + " is not a valid colour");
 1765|  3.09k|                                    break;
 1766|  3.09k|                                }
 1767|       |
 1768|  1.87k|                                i2 = getNodeAt(prop->values, 5);
 1769|  1.87k|                            }
 1770|       |
 1771|  2.88k|                            if(i2 != prop->values.end())
  ------------------
  |  Branch (1771:32): [True: 1.57k, False: 1.30k]
  ------------------
 1772|  1.57k|                            {
 1773|  1.57k|                                if(!getReal(*i2, &dens))
  ------------------
  |  Branch (1773:36): [True: 643, False: 928]
  ------------------
 1774|    643|                                {
 1775|    643|                                    compiler->addError(*prop, (*i2)->getValue() + " is not a valid number");
 1776|    643|                                    break;
 1777|    643|                                }
 1778|    928|                                ++i2;
 1779|    928|                            }
 1780|       |
 1781|  2.23k|                            if(i2 != prop->values.end())
  ------------------
  |  Branch (1781:32): [True: 927, False: 1.31k]
  ------------------
 1782|    927|                            {
 1783|    927|                                if(!getReal(*i2, &start))
  ------------------
  |  Branch (1783:36): [True: 393, False: 534]
  ------------------
 1784|    393|                                {
 1785|    393|                                    compiler->addError(*prop, (*i2)->getValue() + " is not a valid number");
 1786|    393|                                    return;
 1787|    393|                                }
 1788|    534|                                ++i2;
 1789|    534|                            }
 1790|       |
 1791|  1.84k|                            if(i2 != prop->values.end())
  ------------------
  |  Branch (1791:32): [True: 502, False: 1.34k]
  ------------------
 1792|    502|                            {
 1793|    502|                                if(!getReal(*i2, &end))
  ------------------
  |  Branch (1793:36): [True: 207, False: 295]
  ------------------
 1794|    207|                                {
 1795|    207|                                    compiler->addError(*prop, (*i2)->getValue() + " is not a valid number");
 1796|    207|                                    return;
 1797|    207|                                }
 1798|    295|                                ++i2;
 1799|    295|                            }
 1800|       |
 1801|  1.63k|                            mPass->setFog(val, mode, clr, dens, start, end);
 1802|  1.63k|                        }
 1803|  2.04k|                        else
 1804|  2.04k|                            compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid boolean");
 1805|  8.23k|                    }
 1806|  4.34k|                    break;
 1807|  6.05k|                case ID_COLOUR_WRITE:
  ------------------
  |  Branch (1807:17): [True: 6.05k, False: 614k]
  ------------------
 1808|  6.05k|                    if(prop->values.empty())
  ------------------
  |  Branch (1808:24): [True: 922, False: 5.12k]
  ------------------
 1809|    922|                    {
 1810|    922|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 1811|    922|                    }
 1812|  5.12k|                    else if(prop->values.size() == 1)
  ------------------
  |  Branch (1812:29): [True: 1.53k, False: 3.59k]
  ------------------
 1813|  1.53k|                    {
 1814|  1.53k|                        if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (1814:28): [True: 553, False: 983]
  ------------------
 1815|    553|                            mPass->setColourWriteEnabled(bval);
 1816|  1.53k|                    }
 1817|  3.59k|                    else if(prop->values.size() != 4)
  ------------------
  |  Branch (1817:29): [True: 1.05k, False: 2.53k]
  ------------------
 1818|  1.05k|                    {
 1819|  1.05k|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 1820|  1.05k|                                           "colour_write must have exactly 1 or 4 arguments");
 1821|  1.05k|                    }
 1822|  2.53k|                    else
 1823|  2.53k|                    {
 1824|  2.53k|                        bool colourMask[] = {false ,false ,false, false};
 1825|       |
 1826|  2.53k|                        uint8 channelIndex = 0;
 1827|  2.53k|                        for(const AbstractNodePtr& abstractNode : prop->values)
  ------------------
  |  Branch (1827:65): [True: 5.32k, False: 316]
  ------------------
 1828|  5.32k|                        {
 1829|  5.32k|                            if(!getBoolean(abstractNode, &colourMask[channelIndex++]))
  ------------------
  |  Branch (1829:32): [True: 2.22k, False: 3.10k]
  ------------------
 1830|  2.22k|                            {
 1831|  2.22k|                                compiler->addError(*prop, abstractNode->getValue() + " is not a valid boolean");
 1832|  2.22k|                                break;
 1833|  2.22k|                            }
 1834|  5.32k|                        }
 1835|       |
 1836|  2.53k|                        mPass->setColourWriteEnabled(colourMask[0], colourMask[1], colourMask[2], colourMask[3]);
 1837|  2.53k|                    }
 1838|  6.05k|                    break;
 1839|  1.93k|                case ID_MAX_LIGHTS:
  ------------------
  |  Branch (1839:17): [True: 1.93k, False: 618k]
  ------------------
 1840|  1.93k|                    if(getValue(prop, compiler, uival))
  ------------------
  |  Branch (1840:24): [True: 814, False: 1.12k]
  ------------------
 1841|    814|                        mPass->setMaxSimultaneousLights(Math::uint16Cast(uival));
 1842|  1.93k|                    break;
 1843|    733|                case ID_START_LIGHT:
  ------------------
  |  Branch (1843:17): [True: 733, False: 619k]
  ------------------
 1844|    733|                    if(getValue(prop, compiler, uival))
  ------------------
  |  Branch (1844:24): [True: 220, False: 513]
  ------------------
 1845|    220|                        mPass->setStartLight(static_cast<uint16>(uival));
 1846|    733|                    break;
 1847|  1.44k|                case ID_LIGHT_MASK:
  ------------------
  |  Branch (1847:17): [True: 1.44k, False: 618k]
  ------------------
 1848|  1.44k|                    if(getValue(prop, compiler, uival))
  ------------------
  |  Branch (1848:24): [True: 842, False: 602]
  ------------------
 1849|    842|                        mPass->setLightMask(static_cast<uint16>(uival));
 1850|  1.44k|                    break;
 1851|  6.96k|                case ID_ITERATION:
  ------------------
  |  Branch (1851:17): [True: 6.96k, False: 613k]
  ------------------
 1852|  6.96k|                {
 1853|  6.96k|                    if(prop->values.empty())
  ------------------
  |  Branch (1853:24): [True: 257, False: 6.70k]
  ------------------
 1854|    257|                    {
 1855|    257|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 1856|    257|                        break;
 1857|    257|                    }
 1858|       |
 1859|  6.70k|                    auto setLightType = [this, prop, compiler](AbstractNodeList::const_iterator it)
 1860|  6.70k|                    {
 1861|  6.70k|                        if(it == prop->values.end())
 1862|  6.70k|                        {
 1863|  6.70k|                            mPass->setIteratePerLight(true, false);
 1864|  6.70k|                            return;
 1865|  6.70k|                        }
 1866|  6.70k|                        switch(getAtomId(*it))
 1867|  6.70k|                        {
 1868|  6.70k|                        case ID_POINT:
 1869|  6.70k|                            mPass->setIteratePerLight(true, true, Light::LT_POINT);
 1870|  6.70k|                            break;
 1871|  6.70k|                        case ID_DIRECTIONAL:
 1872|  6.70k|                            mPass->setIteratePerLight(true, true, Light::LT_DIRECTIONAL);
 1873|  6.70k|                            break;
 1874|  6.70k|                        case ID_SPOT:
 1875|  6.70k|                            mPass->setIteratePerLight(true, true, Light::LT_SPOTLIGHT);
 1876|  6.70k|                            break;
 1877|  6.70k|                        default:
 1878|       |                            // no ID_RECT to keep the header ABI stable
 1879|  6.70k|                            if ((*it)->getValue() == "rect")
 1880|  6.70k|                                mPass->setIteratePerLight(true, true, Light::LT_RECTLIGHT);
 1881|  6.70k|                            else
 1882|  6.70k|                                compiler->addError(*prop, (*it)->getValue() + " is not a valid light type (point, directional, spot, or rect)");
 1883|  6.70k|                        }
 1884|  6.70k|                    };
 1885|       |
 1886|  6.70k|                    AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0);
 1887|  6.70k|                    auto atomid = getAtomId(*i0);
 1888|  6.70k|                    if(atomid == ID_ONCE)
  ------------------
  |  Branch (1888:24): [True: 332, False: 6.37k]
  ------------------
 1889|    332|                    {
 1890|    332|                        mPass->setIteratePerLight(false);
 1891|    332|                    }
 1892|  6.37k|                    else if(atomid == ID_ONCE_PER_LIGHT)
  ------------------
  |  Branch (1892:29): [True: 668, False: 5.70k]
  ------------------
 1893|    668|                    {
 1894|    668|                        setLightType(getNodeAt(prop->values, 1));
 1895|    668|                    }
 1896|  5.70k|                    else if(getValue(*i0, uival))
  ------------------
  |  Branch (1896:29): [True: 4.90k, False: 800]
  ------------------
 1897|  4.90k|                    {
 1898|  4.90k|                        mPass->setPassIterationCount(uival);
 1899|       |
 1900|  4.90k|                        AbstractNodeList::const_iterator i1 = getNodeAt(prop->values, 1);
 1901|  4.90k|                        if(i1 != prop->values.end())
  ------------------
  |  Branch (1901:28): [True: 4.44k, False: 459]
  ------------------
 1902|  4.44k|                        {
 1903|  4.44k|                            atomid = getAtomId(*i1);
 1904|  4.44k|                            if(atomid == ID_PER_LIGHT)
  ------------------
  |  Branch (1904:32): [True: 488, False: 3.96k]
  ------------------
 1905|    488|                            {
 1906|    488|                                setLightType(getNodeAt(prop->values, 2));
 1907|    488|                            }
 1908|  3.96k|                            else if(atomid == ID_PER_N_LIGHTS)
  ------------------
  |  Branch (1908:37): [True: 2.27k, False: 1.68k]
  ------------------
 1909|  2.27k|                            {
 1910|  2.27k|                                AbstractNodeList::const_iterator i2 = getNodeAt(prop->values, 2);
 1911|  2.27k|                                if(i2 != prop->values.end() && getValue(*i2, uival))
  ------------------
  |  Branch (1911:36): [True: 2.09k, False: 179]
  |  Branch (1911:36): [True: 1.34k, False: 935]
  |  Branch (1911:64): [True: 1.34k, False: 756]
  ------------------
 1912|  1.34k|                                {
 1913|  1.34k|                                    mPass->setLightCountPerIteration(static_cast<unsigned short>(uival));
 1914|  1.34k|                                    setLightType(getNodeAt(prop->values, 3));
 1915|  1.34k|                                }
 1916|    935|                                else
 1917|    935|                                {
 1918|    935|                                    compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line,
 1919|    935|                                                       "per_n_lights requires a light count");
 1920|    935|                                }
 1921|  2.27k|                            }
 1922|  4.44k|                        }
 1923|  4.90k|                    }
 1924|    800|                    else
 1925|    800|                    {
 1926|    800|                        compiler->addError(*prop);
 1927|    800|                    }
 1928|  6.70k|                }
 1929|      0|                break;
 1930|      0|                case ID_LINE_WIDTH:
  ------------------
  |  Branch (1930:17): [True: 0, False: 620k]
  ------------------
 1931|      0|                    if(getValue(prop, compiler, fval))
  ------------------
  |  Branch (1931:24): [True: 0, False: 0]
  ------------------
 1932|      0|                        mPass->setLineWidth(fval);
 1933|      0|                    break;
 1934|    915|                case ID_POINT_SIZE:
  ------------------
  |  Branch (1934:17): [True: 915, False: 619k]
  ------------------
 1935|    915|                    if(getValue(prop, compiler, fval))
  ------------------
  |  Branch (1935:24): [True: 306, False: 609]
  ------------------
 1936|    306|                        mPass->setPointSize(fval);
 1937|    915|                    break;
 1938|    564|                case ID_POINT_SPRITES:
  ------------------
  |  Branch (1938:17): [True: 564, False: 619k]
  ------------------
 1939|    564|                    if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (1939:24): [True: 333, False: 231]
  ------------------
 1940|    333|                        mPass->setPointSpritesEnabled(bval);
 1941|    564|                    break;
 1942|  3.96k|                case ID_POINT_SIZE_ATTENUATION:
  ------------------
  |  Branch (1942:17): [True: 3.96k, False: 616k]
  ------------------
 1943|  3.96k|                    if(prop->values.empty())
  ------------------
  |  Branch (1943:24): [True: 386, False: 3.58k]
  ------------------
 1944|    386|                    {
 1945|    386|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 1946|    386|                    }
 1947|  3.58k|                    else if(prop->values.size() > 4)
  ------------------
  |  Branch (1947:29): [True: 460, False: 3.12k]
  ------------------
 1948|    460|                    {
 1949|    460|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 1950|    460|                                           "point_size_attenuation must have at most 4 arguments");
 1951|    460|                    }
 1952|  3.12k|                    else
 1953|  3.12k|                    {
 1954|  3.12k|                        bool val = false;
 1955|  3.12k|                        if(getBoolean(prop->values.front(), &val))
  ------------------
  |  Branch (1955:28): [True: 1.93k, False: 1.18k]
  ------------------
 1956|  1.93k|                        {
 1957|  1.93k|                            if(val)
  ------------------
  |  Branch (1957:32): [True: 1.70k, False: 234]
  ------------------
 1958|  1.70k|                            {
 1959|  1.70k|                                if (prop->values.size() > 1)
  ------------------
  |  Branch (1959:37): [True: 1.37k, False: 325]
  ------------------
 1960|  1.37k|                                {
 1961|  1.37k|                                    std::vector<float> data;
 1962|  1.37k|                                    if(prop->values.size() != 4 || !getVector(++prop->values.begin(), prop->values.end(), data, 3))
  ------------------
  |  Branch (1962:40): [True: 236, False: 1.14k]
  |  Branch (1962:40): [True: 348, False: 1.03k]
  |  Branch (1962:68): [True: 112, False: 1.03k]
  ------------------
 1963|    348|                                    {
 1964|    348|                                        compiler->addError(*prop);
 1965|    348|                                        return;
 1966|    348|                                    }
 1967|  1.03k|                                    mPass->setPointAttenuation(true, data[0], data[1], data[2]);
 1968|  1.03k|                                }
 1969|    325|                                else
 1970|    325|                                {
 1971|    325|                                    mPass->setPointAttenuation(true);
 1972|    325|                                }
 1973|  1.70k|                            }
 1974|    234|                            else
 1975|    234|                            {
 1976|    234|                                mPass->setPointAttenuation(false);
 1977|    234|                            }
 1978|  1.93k|                        }
 1979|  1.18k|                        else
 1980|  1.18k|                            compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid boolean");
 1981|  3.12k|                    }
 1982|  3.61k|                    break;
 1983|  3.61k|                case ID_POINT_SIZE_MIN:
  ------------------
  |  Branch (1983:17): [True: 918, False: 619k]
  ------------------
 1984|    918|                    if(getValue(prop, compiler, fval))
  ------------------
  |  Branch (1984:24): [True: 273, False: 645]
  ------------------
 1985|    273|                        mPass->setPointMinSize(fval);
 1986|    918|                    break;
 1987|    883|                case ID_POINT_SIZE_MAX:
  ------------------
  |  Branch (1987:17): [True: 883, False: 619k]
  ------------------
 1988|    883|                    if(getValue(prop, compiler, fval))
  ------------------
  |  Branch (1988:24): [True: 347, False: 536]
  ------------------
 1989|    347|                        mPass->setPointMaxSize(fval);
 1990|    883|                    break;
 1991|   369k|                default:
  ------------------
  |  Branch (1991:17): [True: 369k, False: 250k]
  ------------------
 1992|   369k|                    compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line,
 1993|   369k|                                       "token \"" + prop->name + "\" is not recognized");
 1994|   620k|                }
 1995|   620k|            }
 1996|   310k|            else if(i->type == ANT_OBJECT)
  ------------------
  |  Branch (1996:21): [True: 171k, False: 138k]
  ------------------
 1997|   171k|            {
 1998|   171k|                ObjectAbstractNode *child = static_cast<ObjectAbstractNode*>(i.get());
 1999|   171k|                switch(child->id)
 2000|   171k|                {
 2001|  1.31k|                case ID_FRAGMENT_PROGRAM_REF:
  ------------------
  |  Branch (2001:17): [True: 1.31k, False: 170k]
  ------------------
 2002|  25.0k|                case ID_VERTEX_PROGRAM_REF:
  ------------------
  |  Branch (2002:17): [True: 23.7k, False: 147k]
  ------------------
 2003|  25.3k|                case ID_GEOMETRY_PROGRAM_REF:
  ------------------
  |  Branch (2003:17): [True: 259, False: 171k]
  ------------------
 2004|  27.7k|                case ID_TESSELLATION_HULL_PROGRAM_REF:
  ------------------
  |  Branch (2004:17): [True: 2.39k, False: 169k]
  ------------------
 2005|  29.5k|                case ID_TESSELLATION_DOMAIN_PROGRAM_REF:
  ------------------
  |  Branch (2005:17): [True: 1.79k, False: 169k]
  ------------------
 2006|  29.7k|                case ID_COMPUTE_PROGRAM_REF:
  ------------------
  |  Branch (2006:17): [True: 268, False: 171k]
  ------------------
 2007|  30.6k|                case ID_MESH_PROGRAM_REF:
  ------------------
  |  Branch (2007:17): [True: 820, False: 170k]
  ------------------
 2008|  30.6k|                case ID_TASK_PROGRAM_REF:
  ------------------
  |  Branch (2008:17): [True: 0, False: 171k]
  ------------------
 2009|  30.6k|                    translateProgramRef(getProgramType(child->id), compiler, child);
 2010|  30.6k|                    break;
 2011|  1.10k|                case ID_SHADOW_CASTER_VERTEX_PROGRAM_REF:
  ------------------
  |  Branch (2011:17): [True: 1.10k, False: 170k]
  ------------------
 2012|  1.10k|                    translateShadowCasterProgramRef(GPT_VERTEX_PROGRAM, compiler, child);
 2013|  1.10k|                    break;
 2014|  21.5k|                case ID_SHADOW_CASTER_FRAGMENT_PROGRAM_REF:
  ------------------
  |  Branch (2014:17): [True: 21.5k, False: 149k]
  ------------------
 2015|  21.5k|                    translateShadowCasterProgramRef(GPT_FRAGMENT_PROGRAM, compiler, child);
 2016|  21.5k|                    break;
 2017|    364|                case ID_SHADOW_RECEIVER_VERTEX_PROGRAM_REF:
  ------------------
  |  Branch (2017:17): [True: 364, False: 171k]
  ------------------
 2018|    364|                    translateShadowReceiverProgramRef(GPT_VERTEX_PROGRAM, compiler, child);
 2019|    364|                    break;
 2020|  3.46k|                case ID_SHADOW_RECEIVER_FRAGMENT_PROGRAM_REF:
  ------------------
  |  Branch (2020:17): [True: 3.46k, False: 168k]
  ------------------
 2021|  3.46k|                    translateShadowReceiverProgramRef(GPT_FRAGMENT_PROGRAM, compiler, child);
 2022|  3.46k|                    break;
 2023|   105k|                default:
  ------------------
  |  Branch (2023:17): [True: 105k, False: 65.9k]
  ------------------
 2024|   105k|                    processNode(compiler, i);
 2025|   105k|                    break;
 2026|    243|                case ID_FRAGMENT_PROGRAM:
  ------------------
  |  Branch (2026:17): [True: 243, False: 171k]
  ------------------
 2027|  1.06k|                case ID_VERTEX_PROGRAM:
  ------------------
  |  Branch (2027:17): [True: 822, False: 170k]
  ------------------
 2028|  1.33k|                case ID_GEOMETRY_PROGRAM:
  ------------------
  |  Branch (2028:17): [True: 268, False: 171k]
  ------------------
 2029|  1.68k|                case ID_TESSELLATION_HULL_PROGRAM:
  ------------------
  |  Branch (2029:17): [True: 349, False: 171k]
  ------------------
 2030|  8.78k|                case ID_TESSELLATION_DOMAIN_PROGRAM:
  ------------------
  |  Branch (2030:17): [True: 7.10k, False: 164k]
  ------------------
 2031|  8.86k|                case ID_COMPUTE_PROGRAM:
  ------------------
  |  Branch (2031:17): [True: 83, False: 171k]
  ------------------
 2032|  8.90k|                case ID_MESH_PROGRAM:
  ------------------
  |  Branch (2032:17): [True: 35, False: 171k]
  ------------------
 2033|  8.90k|                case ID_TASK_PROGRAM:
  ------------------
  |  Branch (2033:17): [True: 0, False: 171k]
  ------------------
 2034|  8.90k|                {
 2035|       |                    // auto assign inline defined programs
 2036|  8.90k|                    processNode(compiler, i);
 2037|  8.90k|                    GpuProgramType type = getProgramType(child->id);
 2038|  8.90k|                    mPass->setGpuProgram(type, GpuProgramUsage::_getProgramByName(child->name, mPass->getResourceGroup(), type));
 2039|  8.90k|                }
 2040|   171k|                }
 2041|   171k|            }
 2042|   930k|        }
 2043|  69.5k|    }
_ZN4Ogre14PassTranslator19translateProgramRefENS_14GpuProgramTypeEPNS_14ScriptCompilerEPNS_18ObjectAbstractNodeE:
 2070|  30.6k|    {
 2071|  30.6k|        auto program = getProgram(compiler, node);
 2072|  30.6k|        if(!program) return;
  ------------------
  |  Branch (2072:12): [True: 7.18k, False: 23.4k]
  ------------------
 2073|  23.4k|        auto pass = any_cast<Pass*>(node->parent->context);
 2074|       |
 2075|  23.4k|        pass->setGpuProgram(type, program);
 2076|  23.4k|        if(program->isSupported())
  ------------------
  |  Branch (2076:12): [True: 0, False: 23.4k]
  ------------------
 2077|      0|        {
 2078|      0|            GpuProgramParametersSharedPtr params = pass->getGpuProgramParameters(type);
 2079|      0|            GpuProgramTranslator::translateProgramParameters(compiler, params, node);
 2080|      0|        }
 2081|  23.4k|    }
_ZN4Ogre14PassTranslator31translateShadowCasterProgramRefENS_14GpuProgramTypeEPNS_14ScriptCompilerEPNS_18ObjectAbstractNodeE:
 2084|  22.6k|    {
 2085|  22.6k|        auto program = getProgram(compiler, node);
 2086|  22.6k|        if(!program) return;
  ------------------
  |  Branch (2086:12): [True: 3.23k, False: 19.4k]
  ------------------
 2087|  19.4k|        auto pass = any_cast<Pass*>(node->parent->context);
 2088|       |
 2089|  19.4k|        compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, node->file, node->line,
 2090|  19.4k|                           node->cls + ". Use shadow_caster_material instead");
 2091|       |
 2092|  19.4k|        auto caster_mat = pass->getParent()->getShadowCasterMaterial();
 2093|  19.4k|        if(!caster_mat)
  ------------------
  |  Branch (2093:12): [True: 17.0k, False: 2.42k]
  ------------------
 2094|  17.0k|        {
 2095|  17.0k|            auto src_mat = pass->getParent()->getParent();
 2096|       |            // only first pass of this will be used. The caster material is technique specific.
 2097|  17.0k|            caster_mat = src_mat->clone(
 2098|  17.0k|                StringUtil::format("%s/%p/CasterFallback", src_mat->getName().c_str(), pass->getParent()));
 2099|  17.0k|            pass->getParent()->setShadowCasterMaterial(caster_mat);
 2100|  17.0k|        }
 2101|  19.4k|        auto caster_pass = caster_mat->getTechnique(0)->getPass(0);
 2102|       |
 2103|  19.4k|        caster_pass->setGpuProgram(type, program);
 2104|  19.4k|        if(program->isSupported())
  ------------------
  |  Branch (2104:12): [True: 0, False: 19.4k]
  ------------------
 2105|      0|        {
 2106|      0|            GpuProgramParametersSharedPtr params = caster_pass->getGpuProgramParameters(type);
 2107|      0|            GpuProgramTranslator::translateProgramParameters(compiler, params, node);
 2108|      0|        }
 2109|  19.4k|    }
_ZN4Ogre14PassTranslator33translateShadowReceiverProgramRefENS_14GpuProgramTypeEPNS_14ScriptCompilerEPNS_18ObjectAbstractNodeE:
 2112|  3.82k|    {
 2113|  3.82k|        auto program = getProgram(compiler, node);
 2114|  3.82k|        if(!program) return;
  ------------------
  |  Branch (2114:12): [True: 655, False: 3.17k]
  ------------------
 2115|  3.17k|        auto pass = any_cast<Pass*>(node->parent->context);
 2116|       |
 2117|  3.17k|        compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, node->file, node->line,
 2118|  3.17k|                           node->cls + ". Use shadow_receiver_material instead");
 2119|       |
 2120|  3.17k|        auto receiver_mat = pass->getParent()->getShadowReceiverMaterial();
 2121|  3.17k|        if(!receiver_mat)
  ------------------
  |  Branch (2121:12): [True: 212, False: 2.96k]
  ------------------
 2122|    212|        {
 2123|    212|            auto src_mat = pass->getParent()->getParent();
 2124|       |            // only first pass of this will be used
 2125|    212|            receiver_mat = src_mat->clone(src_mat->getName()+"/ReceiverFallback");
 2126|    212|            pass->getParent()->setShadowReceiverMaterial(receiver_mat);
 2127|    212|        }
 2128|  3.17k|        auto receiver_pass = receiver_mat->getTechnique(0)->getPass(0);
 2129|       |
 2130|  3.17k|        receiver_pass->setGpuProgram(type, program);
 2131|  3.17k|        if(program->isSupported())
  ------------------
  |  Branch (2131:12): [True: 0, False: 3.17k]
  ------------------
 2132|      0|        {
 2133|      0|            GpuProgramParametersSharedPtr params = receiver_pass->getGpuProgramParameters(type);
 2134|      0|            GpuProgramTranslator::translateProgramParameters(compiler, params, node);
 2135|      0|        }
 2136|  3.17k|    }
_ZN4Ogre21TextureUnitTranslatorC2Ev:
 2141|      1|        :mUnit(0)
 2142|      1|    {
 2143|      1|    }
_ZN4Ogre17SamplerTranslator21translateSamplerParamEPNS_14ScriptCompilerERKNSt3__110shared_ptrINS_7SamplerEEEPNS_20PropertyAbstractNodeE:
 2146|  45.6k|    {
 2147|  45.6k|        bool bval;
 2148|  45.6k|        Real fval;
 2149|  45.6k|        uint32 uival;
 2150|       |
 2151|  45.6k|        switch(prop->id)
  ------------------
  |  Branch (2151:16): [True: 45.6k, False: 0]
  ------------------
 2152|  45.6k|        {
 2153|  10.2k|        case ID_TEX_ADDRESS_MODE:
  ------------------
  |  Branch (2153:9): [True: 10.2k, False: 35.4k]
  ------------------
 2154|  10.2k|            {
 2155|  10.2k|                if(prop->values.empty())
  ------------------
  |  Branch (2155:20): [True: 416, False: 9.80k]
  ------------------
 2156|    416|                {
 2157|    416|                    compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 2158|    416|                }
 2159|  9.80k|                else
 2160|  9.80k|                {
 2161|  9.80k|                    AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0),
 2162|  9.80k|                        i1 = getNodeAt(prop->values, 1),
 2163|  9.80k|                        i2 = getNodeAt(prop->values, 2);
 2164|  9.80k|                    Sampler::UVWAddressingMode mode;
 2165|       |
 2166|  9.80k|                    if(!getValue(*i0, mode.u))
  ------------------
  |  Branch (2166:24): [True: 3.53k, False: 6.27k]
  ------------------
 2167|  3.53k|                    {
 2168|  3.53k|                        compiler->addError(*prop, (*i0)->getValue() + " not supported as first argument (must be \"wrap\", \"clamp\", \"mirror\", or \"border\")");
 2169|  3.53k|                        return;
 2170|  3.53k|                    }
 2171|  6.27k|                    mode.v = mode.u;
 2172|  6.27k|                    mode.w = mode.u;
 2173|       |
 2174|  6.27k|                    if(i1 != prop->values.end())
  ------------------
  |  Branch (2174:24): [True: 1.93k, False: 4.34k]
  ------------------
 2175|  1.93k|                    {
 2176|  1.93k|                        if(!getValue(*i1, mode.v))
  ------------------
  |  Branch (2176:28): [True: 1.40k, False: 527]
  ------------------
 2177|  1.40k|                        {
 2178|  1.40k|                            compiler->addError(*prop, (*i1)->getValue() + " not supported as second argument (must be \"wrap\", \"clamp\", \"mirror\", or \"border\")");
 2179|  1.40k|                        }
 2180|  1.93k|                    }
 2181|       |
 2182|  6.27k|                    if(i2 != prop->values.end())
  ------------------
  |  Branch (2182:24): [True: 1.42k, False: 4.85k]
  ------------------
 2183|  1.42k|                    {
 2184|  1.42k|                        if(!getValue(*i2, mode.w))
  ------------------
  |  Branch (2184:28): [True: 1.09k, False: 335]
  ------------------
 2185|  1.09k|                        {
 2186|  1.09k|                            compiler->addError(*prop, (*i2)->getValue() + " not supported as third argument (must be \"wrap\", \"clamp\", \"mirror\", or \"border\")");
 2187|  1.09k|                        }
 2188|  1.42k|                    }
 2189|       |
 2190|  6.27k|                    sampler->setAddressingMode(mode);
 2191|  6.27k|                }
 2192|  10.2k|            }
 2193|  6.69k|            break;
 2194|  6.69k|        case ID_TEX_BORDER_COLOUR:
  ------------------
  |  Branch (2194:9): [True: 6.38k, False: 39.3k]
  ------------------
 2195|  6.38k|            if(prop->values.empty())
  ------------------
  |  Branch (2195:16): [True: 534, False: 5.84k]
  ------------------
 2196|    534|            {
 2197|    534|                compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line);
 2198|    534|            }
 2199|  5.84k|            else
 2200|  5.84k|            {
 2201|  5.84k|                ColourValue val;
 2202|  5.84k|                if(getColour(prop->values.begin(), prop->values.end(), &val))
  ------------------
  |  Branch (2202:20): [True: 1.23k, False: 4.61k]
  ------------------
 2203|  1.23k|                    sampler->setBorderColour(val);
 2204|  4.61k|                else
 2205|  4.61k|                    compiler->addError(*prop, "tex_border_colour only accepts a colour argument");
 2206|  5.84k|            }
 2207|  6.38k|            break;
 2208|  22.6k|        case ID_FILTERING:
  ------------------
  |  Branch (2208:9): [True: 22.6k, False: 23.0k]
  ------------------
 2209|  22.6k|            if(prop->values.empty())
  ------------------
  |  Branch (2209:16): [True: 382, False: 22.3k]
  ------------------
 2210|    382|            {
 2211|    382|                compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 2212|    382|            }
 2213|  22.3k|            else if(prop->values.size() == 1)
  ------------------
  |  Branch (2213:21): [True: 10.5k, False: 11.7k]
  ------------------
 2214|  10.5k|            {
 2215|  10.5k|                switch(getAtomId(prop->values.front()))
 2216|  10.5k|                {
 2217|  5.14k|                case ID_NONE:
  ------------------
  |  Branch (2217:17): [True: 5.14k, False: 5.39k]
  ------------------
 2218|  5.14k|                    sampler->setFiltering(TFO_NONE);
 2219|  5.14k|                    break;
 2220|    336|                case ID_BILINEAR:
  ------------------
  |  Branch (2220:17): [True: 336, False: 10.2k]
  ------------------
 2221|    336|                    sampler->setFiltering(TFO_BILINEAR);
 2222|    336|                    break;
 2223|  1.67k|                case ID_TRILINEAR:
  ------------------
  |  Branch (2223:17): [True: 1.67k, False: 8.87k]
  ------------------
 2224|  1.67k|                    sampler->setFiltering(TFO_TRILINEAR);
 2225|  1.67k|                    break;
 2226|    169|                case ID_ANISOTROPIC:
  ------------------
  |  Branch (2226:17): [True: 169, False: 10.3k]
  ------------------
 2227|    169|                    sampler->setFiltering(TFO_ANISOTROPIC);
 2228|    169|                    break;
 2229|  3.21k|                default:
  ------------------
  |  Branch (2229:17): [True: 3.21k, False: 7.33k]
  ------------------
 2230|  3.21k|                    compiler->addError(*prop, prop->values.front()->getValue() + " not supported as first argument (must be \"none\", \"bilinear\", \"trilinear\", or \"anisotropic\")");
 2231|  10.5k|                }
 2232|  10.5k|            }
 2233|  11.7k|            else if(prop->values.size() == 3)
  ------------------
  |  Branch (2233:21): [True: 9.12k, False: 2.62k]
  ------------------
 2234|  9.12k|            {
 2235|  9.12k|                AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0),
 2236|  9.12k|                    i1 = getNodeAt(prop->values, 1),
 2237|  9.12k|                    i2 = getNodeAt(prop->values, 2);
 2238|  9.12k|                FilterOptions tmin, tmax, tmip;
 2239|  9.12k|                if (getValue(*i0, tmin) && getValue(*i1, tmax) && getValue(*i2, tmip))
  ------------------
  |  Branch (2239:21): [True: 7.66k, False: 1.46k]
  |  Branch (2239:44): [True: 6.35k, False: 1.31k]
  |  Branch (2239:67): [True: 2.63k, False: 3.71k]
  ------------------
 2240|  2.63k|                {
 2241|  2.63k|                    sampler->setFiltering(tmin, tmax, tmip);
 2242|  2.63k|                }
 2243|  6.49k|                else
 2244|  6.49k|                {
 2245|  6.49k|                    compiler->addError(*prop);
 2246|  6.49k|                }
 2247|  9.12k|            }
 2248|  2.62k|            else
 2249|  2.62k|            {
 2250|  2.62k|                compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 2251|  2.62k|                                   "filtering must have either 1 or 3 arguments");
 2252|  2.62k|            }
 2253|  22.6k|            break;
 2254|  22.6k|        case ID_CMPTEST:
  ------------------
  |  Branch (2254:9): [True: 772, False: 44.9k]
  ------------------
 2255|    772|            if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (2255:16): [True: 246, False: 526]
  ------------------
 2256|    246|                sampler->setCompareEnabled(bval);
 2257|    772|            break;
 2258|    258|        case ID_CMPFUNC:
  ------------------
  |  Branch (2258:9): [True: 258, False: 45.4k]
  ------------------
 2259|    258|            compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file,
 2260|    258|                prop->line,
 2261|    258|                "compare_func. Use comp_func.");
 2262|    258|            OGRE_FALLTHROUGH;
 2263|  1.94k|        case ID_COMP_FUNC:
  ------------------
  |  Branch (2263:9): [True: 1.68k, False: 44.0k]
  ------------------
 2264|  1.94k|            CompareFunction func;
 2265|  1.94k|            if(getValue(prop, compiler, func))
  ------------------
  |  Branch (2265:16): [True: 676, False: 1.26k]
  ------------------
 2266|    676|                sampler->setCompareFunction(func);
 2267|  1.94k|            break;
 2268|  1.44k|        case ID_MAX_ANISOTROPY:
  ------------------
  |  Branch (2268:9): [True: 1.44k, False: 44.2k]
  ------------------
 2269|  1.44k|            if(getValue(prop, compiler, uival))
  ------------------
  |  Branch (2269:16): [True: 342, False: 1.09k]
  ------------------
 2270|    342|                sampler->setAnisotropy(uival);
 2271|  1.44k|            break;
 2272|  2.24k|        case ID_MIPMAP_BIAS:
  ------------------
  |  Branch (2272:9): [True: 2.24k, False: 43.4k]
  ------------------
 2273|  2.24k|            if(getValue(prop, compiler, fval))
  ------------------
  |  Branch (2273:16): [True: 211, False: 2.03k]
  ------------------
 2274|    211|                sampler->setMipmapBias(fval);
 2275|  2.24k|            break;
 2276|  45.6k|        }
 2277|  45.6k|    }
_ZN4Ogre17SamplerTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE:
 2279|    732|    {
 2280|    732|        ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(node.get());
 2281|       |
 2282|    732|        if(obj->name.empty())
  ------------------
  |  Branch (2282:12): [True: 257, False: 475]
  ------------------
 2283|    257|        {
 2284|    257|            compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line);
 2285|    257|            return;
 2286|    257|        }
 2287|       |
 2288|    475|        SamplerPtr sampler = TextureManager::getSingleton().createSampler(obj->name);
 2289|       |
 2290|       |        // Set the properties for the material
 2291|    475|        for(auto & i : obj->children)
  ------------------
  |  Branch (2291:22): [True: 3.99k, False: 475]
  ------------------
 2292|  3.99k|        {
 2293|  3.99k|            if(i->type == ANT_PROPERTY)
  ------------------
  |  Branch (2293:16): [True: 2.68k, False: 1.31k]
  ------------------
 2294|  2.68k|            {
 2295|  2.68k|                PropertyAbstractNode *prop = static_cast<PropertyAbstractNode*>(i.get());
 2296|  2.68k|                switch(prop->id)
 2297|  2.68k|                {
 2298|    174|                case ID_TEX_ADDRESS_MODE:
  ------------------
  |  Branch (2298:17): [True: 174, False: 2.50k]
  ------------------
 2299|  1.00k|                case ID_TEX_BORDER_COLOUR:
  ------------------
  |  Branch (2299:17): [True: 830, False: 1.85k]
  ------------------
 2300|  1.35k|                case ID_FILTERING:
  ------------------
  |  Branch (2300:17): [True: 352, False: 2.33k]
  ------------------
 2301|  1.43k|                case ID_CMPTEST:
  ------------------
  |  Branch (2301:17): [True: 75, False: 2.60k]
  ------------------
 2302|  1.50k|                case ID_COMP_FUNC:
  ------------------
  |  Branch (2302:17): [True: 77, False: 2.60k]
  ------------------
 2303|  1.56k|                case ID_MAX_ANISOTROPY:
  ------------------
  |  Branch (2303:17): [True: 61, False: 2.62k]
  ------------------
 2304|  1.65k|                case ID_MIPMAP_BIAS:
  ------------------
  |  Branch (2304:17): [True: 83, False: 2.59k]
  ------------------
 2305|  1.65k|                    translateSamplerParam(compiler, sampler, prop);
 2306|  1.65k|                    break;
 2307|  1.03k|                default:
  ------------------
  |  Branch (2307:17): [True: 1.03k, False: 1.65k]
  ------------------
 2308|  1.03k|                    compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line,
 2309|  1.03k|                                       "token \"" + prop->name + "\" is not recognized");
 2310|  2.68k|                }
 2311|  2.68k|            }
 2312|  1.31k|            else if(i->type == ANT_OBJECT)
  ------------------
  |  Branch (2312:21): [True: 114, False: 1.20k]
  ------------------
 2313|    114|            {
 2314|    114|                processNode(compiler, i);
 2315|    114|            }
 2316|  3.99k|        }
 2317|    475|    }
_ZN4Ogre21TextureUnitTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE:
 2320|  41.4k|    {
 2321|  41.4k|        ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(node.get());
 2322|       |
 2323|  41.4k|        Pass *pass = any_cast<Pass*>(obj->parent->context);
 2324|  41.4k|        mUnit = pass->createTextureUnitState();
 2325|  41.4k|        obj->context = mUnit;
 2326|       |
 2327|       |        // Get the name of the technique
 2328|  41.4k|        if(!obj->name.empty())
  ------------------
  |  Branch (2328:12): [True: 13.6k, False: 27.7k]
  ------------------
 2329|  13.6k|            mUnit->setName(obj->name);
 2330|       |
 2331|  41.4k|        Real fval;
 2332|  41.4k|        uint32 uival;
 2333|  41.4k|        String sval;
 2334|       |
 2335|       |        // Set the properties for the material
 2336|  41.4k|        for(auto & i : obj->children)
  ------------------
  |  Branch (2336:22): [True: 566k, False: 41.4k]
  ------------------
 2337|   566k|        {
 2338|   566k|            if(i->type == ANT_PROPERTY)
  ------------------
  |  Branch (2338:16): [True: 467k, False: 99.5k]
  ------------------
 2339|   467k|            {
 2340|   467k|                PropertyAbstractNode *prop = static_cast<PropertyAbstractNode*>(i.get());
 2341|   467k|                switch(prop->id)
 2342|   467k|                {
 2343|  10.0k|                case ID_TEX_ADDRESS_MODE:
  ------------------
  |  Branch (2343:17): [True: 10.0k, False: 457k]
  ------------------
 2344|  15.6k|                case ID_TEX_BORDER_COLOUR:
  ------------------
  |  Branch (2344:17): [True: 5.55k, False: 461k]
  ------------------
 2345|  37.9k|                case ID_FILTERING:
  ------------------
  |  Branch (2345:17): [True: 22.3k, False: 444k]
  ------------------
 2346|  38.6k|                case ID_CMPTEST:
  ------------------
  |  Branch (2346:17): [True: 697, False: 466k]
  ------------------
 2347|  38.8k|                case ID_CMPFUNC:
  ------------------
  |  Branch (2347:17): [True: 258, False: 466k]
  ------------------
 2348|  40.4k|                case ID_COMP_FUNC:
  ------------------
  |  Branch (2348:17): [True: 1.60k, False: 465k]
  ------------------
 2349|  41.8k|                case ID_MAX_ANISOTROPY:
  ------------------
  |  Branch (2349:17): [True: 1.38k, False: 465k]
  ------------------
 2350|  44.0k|                case ID_MIPMAP_BIAS:
  ------------------
  |  Branch (2350:17): [True: 2.16k, False: 465k]
  ------------------
 2351|  44.0k|                    SamplerTranslator::translateSamplerParam(compiler, mUnit->_getLocalSampler(), prop);
 2352|  44.0k|                    break;
 2353|  11.2k|                case ID_SAMPLER_REF:
  ------------------
  |  Branch (2353:17): [True: 11.2k, False: 455k]
  ------------------
 2354|  11.2k|                    if(getValue(prop, compiler, sval))
  ------------------
  |  Branch (2354:24): [True: 9.15k, False: 2.06k]
  ------------------
 2355|  9.15k|                    {
 2356|  9.15k|                        auto sampler = TextureManager::getSingleton().getSampler(sval);
 2357|  9.15k|                        if(sampler)
  ------------------
  |  Branch (2357:28): [True: 869, False: 8.28k]
  ------------------
 2358|    869|                            mUnit->setSampler(sampler);
 2359|  8.28k|                        else
 2360|  8.28k|                            compiler->addError(ScriptCompiler::CE_REFERENCETOANONEXISTINGOBJECT,
 2361|  8.28k|                                               prop->file, prop->line, sval);
 2362|  9.15k|                    }
 2363|  11.2k|                    break;
 2364|    727|                case ID_UNORDERED_ACCESS_MIP:
  ------------------
  |  Branch (2364:17): [True: 727, False: 466k]
  ------------------
 2365|    727|                    if(getValue(prop, compiler, uival))
  ------------------
  |  Branch (2365:24): [True: 286, False: 441]
  ------------------
 2366|    286|                        mUnit->setUnorderedAccessMipLevel(uival);
 2367|    727|                    break;
 2368|    727|                case ID_TEXTURE_ALIAS:
  ------------------
  |  Branch (2368:17): [True: 727, False: 466k]
  ------------------
 2369|    727|                    compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line,
 2370|    727|                        "texture_alias. Use 'texture $variable'");
 2371|    727|                    if(getValue(prop, compiler, sval))
  ------------------
  |  Branch (2371:24): [True: 369, False: 358]
  ------------------
 2372|    369|                        mUnit->setName(sval);
 2373|    727|                    break;
 2374|  40.2k|                case ID_TEXTURE:
  ------------------
  |  Branch (2374:17): [True: 40.2k, False: 426k]
  ------------------
 2375|  40.2k|                    if(prop->values.empty())
  ------------------
  |  Branch (2375:24): [True: 460, False: 39.7k]
  ------------------
 2376|    460|                    {
 2377|    460|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 2378|    460|                    }
 2379|  39.7k|                    else if(prop->values.size() > 5)
  ------------------
  |  Branch (2379:29): [True: 1.48k, False: 38.2k]
  ------------------
 2380|  1.48k|                    {
 2381|  1.48k|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 2382|  1.48k|                                           "texture must have at most 5 arguments");
 2383|  1.48k|                    }
 2384|  38.2k|                    else
 2385|  38.2k|                    {
 2386|  38.2k|                        AbstractNodeList::const_iterator j = prop->values.begin();
 2387|  38.2k|                        String val;
 2388|  38.2k|                        if(getString(*j, &val))
  ------------------
  |  Branch (2388:28): [True: 37.6k, False: 652]
  ------------------
 2389|  37.6k|                        {
 2390|  37.6k|                            TextureType texType = TEX_TYPE_2D;
 2391|  37.6k|                            bool isAlpha = false;
 2392|  37.6k|                            bool sRGBRead = false;
 2393|  37.6k|                            PixelFormat format = PF_UNKNOWN;
 2394|  37.6k|                            int mipmaps = TextureManager::getSingleton().getDefaultNumMipmaps(); // MIP_DEFAULT
 2395|       |
 2396|  37.6k|                            ++j;
 2397|  66.4k|                            while(j != prop->values.end())
  ------------------
  |  Branch (2397:35): [True: 28.8k, False: 37.6k]
  ------------------
 2398|  28.8k|                            {
 2399|  28.8k|                                if((*j)->type == ANT_ATOM)
  ------------------
  |  Branch (2399:36): [True: 27.7k, False: 1.11k]
  ------------------
 2400|  27.7k|                                {
 2401|  27.7k|                                    AtomAbstractNode *atom = (AtomAbstractNode*)(*j).get();
 2402|  27.7k|                                    switch(atom->id)
 2403|  27.7k|                                    {
 2404|    710|                                    case ID_1D:
  ------------------
  |  Branch (2404:37): [True: 710, False: 27.0k]
  ------------------
 2405|    710|                                        texType = TEX_TYPE_1D;
 2406|    710|                                        break;
 2407|    237|                                    case ID_2D:
  ------------------
  |  Branch (2407:37): [True: 237, False: 27.5k]
  ------------------
 2408|    237|                                        texType = TEX_TYPE_2D;
 2409|    237|                                        break;
 2410|    299|                                    case ID_3D:
  ------------------
  |  Branch (2410:37): [True: 299, False: 27.4k]
  ------------------
 2411|    299|                                        texType = TEX_TYPE_3D;
 2412|    299|                                        break;
 2413|  1.05k|                                    case ID_CUBIC:
  ------------------
  |  Branch (2413:37): [True: 1.05k, False: 26.6k]
  ------------------
 2414|  1.05k|                                        texType = TEX_TYPE_CUBE_MAP;
 2415|  1.05k|                                        break;
 2416|      0|                                    case ID_2DARRAY:
  ------------------
  |  Branch (2416:37): [True: 0, False: 27.7k]
  ------------------
 2417|      0|                                        texType = TEX_TYPE_2D_ARRAY;
 2418|      0|                                        break;
 2419|      0|                                    case ID_UNLIMITED:
  ------------------
  |  Branch (2419:37): [True: 0, False: 27.7k]
  ------------------
 2420|      0|                                        mipmaps = MIP_UNLIMITED;
 2421|      0|                                        break;
 2422|    332|                                    case ID_ALPHA:
  ------------------
  |  Branch (2422:37): [True: 332, False: 27.4k]
  ------------------
 2423|    332|                                        isAlpha = true;
 2424|    332|                                        break;
 2425|    484|                                    case ID_GAMMA:
  ------------------
  |  Branch (2425:37): [True: 484, False: 27.2k]
  ------------------
 2426|    484|                                        sRGBRead = true;
 2427|    484|                                        break;
 2428|  24.6k|                                    default:
  ------------------
  |  Branch (2428:37): [True: 24.6k, False: 3.12k]
  ------------------
 2429|  24.6k|                                        if(!StringConverter::parse(atom->value, mipmaps))
  ------------------
  |  Branch (2429:44): [True: 19.5k, False: 5.07k]
  ------------------
 2430|  19.5k|                                        {
 2431|  19.5k|                                            format = PixelUtil::getFormatFromName(atom->value, true);
 2432|       |
 2433|  19.5k|                                            if (format == PF_UNKNOWN)
  ------------------
  |  Branch (2433:49): [True: 18.4k, False: 1.13k]
  ------------------
 2434|  18.4k|                                                compiler->addError(*prop, atom->value);
 2435|  19.5k|                                        }
 2436|  27.7k|                                    }
 2437|  27.7k|                                }
 2438|  1.11k|                                else
 2439|  1.11k|                                {
 2440|  1.11k|                                    compiler->addError(*prop, (*j)->getValue() + " is not a supported argument to the texture property");
 2441|  1.11k|                                }
 2442|  28.8k|                                ++j;
 2443|  28.8k|                            }
 2444|       |
 2445|  37.6k|                            String name = processResourceName(compiler, ResourceType::TEXTURE, val);
 2446|       |
 2447|  37.6k|                            if(isAlpha)
  ------------------
  |  Branch (2447:32): [True: 332, False: 37.2k]
  ------------------
 2448|    332|                            {
 2449|       |                                // format = PF_A8; should only be done, if src is luminance, which we dont know here
 2450|    332|                                compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file,
 2451|    332|                                                   prop->line, "alpha. Use PF_A8 instead");
 2452|    332|                            }
 2453|       |
 2454|  37.6k|                            if(const auto& tex = TextureManager::getSingleton().getByName(name, mUnit->getParent()->getResourceGroup()))
  ------------------
  |  Branch (2454:44): [True: 36.3k, False: 1.28k]
  ------------------
 2455|  36.3k|                            {
 2456|       |                                // the texture is shared with another texture unit, report any discrepancies
 2457|  36.3k|                                if (tex->getDesiredFormat() != format || tex->getNumMipmaps() != uint(mipmaps) ||
  ------------------
  |  Branch (2457:37): [True: 289, False: 36.0k]
  |  Branch (2457:74): [True: 1.02k, False: 35.0k]
  ------------------
 2458|  35.0k|                                    tex->isHardwareGammaEnabled() != sRGBRead || tex->getTextureType() != texType)
  ------------------
  |  Branch (2458:37): [True: 218, False: 34.7k]
  |  Branch (2458:82): [True: 502, False: 34.2k]
  ------------------
 2459|  2.03k|                                {
 2460|  2.03k|                                    compiler->addError(*prop, "overriding previous declarations of texture '" + name +
 2461|  2.03k|                                                           "' with different parameters");
 2462|  2.03k|                                }
 2463|  36.3k|                            }
 2464|       |
 2465|  37.6k|                            mUnit->setTextureName(name, texType);
 2466|  37.6k|                            mUnit->setDesiredFormat(format);
 2467|  37.6k|                            OGRE_IGNORE_DEPRECATED_BEGIN
 2468|  37.6k|                            mUnit->setIsAlpha(isAlpha);
 2469|  37.6k|                            OGRE_IGNORE_DEPRECATED_END
 2470|  37.6k|                            mUnit->setNumMipmaps(mipmaps);
 2471|  37.6k|                            mUnit->setHardwareGammaEnabled(sRGBRead);
 2472|  37.6k|                        }
 2473|    652|                        else
 2474|    652|                            compiler->addError(*prop, (*j)->getValue() + " is not a valid texture name");
 2475|  38.2k|                    }
 2476|  40.2k|                    break;
 2477|  40.2k|                case ID_ANIM_TEXTURE:
  ------------------
  |  Branch (2477:17): [True: 16.3k, False: 450k]
  ------------------
 2478|  16.3k|                    if(prop->values.size() < 3)
  ------------------
  |  Branch (2478:24): [True: 2.92k, False: 13.4k]
  ------------------
 2479|  2.92k|                    {
 2480|  2.92k|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 2481|  2.92k|                    }
 2482|  13.4k|                    else
 2483|  13.4k|                    {
 2484|  13.4k|                        AbstractNodeList::const_iterator i1 = getNodeAt(prop->values, 1);
 2485|  13.4k|                        uint32 nframes = 0;
 2486|  13.4k|                        if(getValue(*i1, nframes))
  ------------------
  |  Branch (2486:28): [True: 8.23k, False: 5.18k]
  ------------------
 2487|  8.23k|                        {
 2488|       |                            // Short form
 2489|  8.23k|                            AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i2 = getNodeAt(prop->values, 2);
 2490|  8.23k|                            String val0;
 2491|  8.23k|                            Real val2;
 2492|  8.23k|                            if(nframes && getValue(*i0, val0) && getValue(*i2, val2))
  ------------------
  |  Branch (2492:32): [True: 7.43k, False: 803]
  |  Branch (2492:43): [True: 7.19k, False: 242]
  |  Branch (2492:66): [True: 6.51k, False: 682]
  ------------------
 2493|  6.51k|                            {
 2494|  6.51k|                                mUnit->setAnimatedTextureName(processResourceName(compiler, ResourceType::TEXTURE, val0), nframes, val2);
 2495|  6.51k|                            }
 2496|  1.72k|                            else
 2497|  1.72k|                            {
 2498|  1.72k|                                compiler->addError(*prop, "anim_texture short form requires a texture name, a frame "
 2499|  1.72k|                                                          "count > 0, and animation duration");
 2500|  1.72k|                            }
 2501|  8.23k|                        }
 2502|  5.18k|                        else
 2503|  5.18k|                        {
 2504|       |                            // Long form has n number of frames
 2505|  5.18k|                            Real duration = 0;
 2506|  5.18k|                            AbstractNodeList::const_iterator in = getNodeAt(prop->values, static_cast<int>(prop->values.size()) - 1);
 2507|  5.18k|                            if(getReal(*in, &duration))
  ------------------
  |  Branch (2507:32): [True: 3.11k, False: 2.06k]
  ------------------
 2508|  3.11k|                            {
 2509|  3.11k|                                std::vector<String> names;
 2510|       |
 2511|  3.11k|                                AbstractNodeList::iterator j = prop->values.begin();
 2512|   113k|                                while(j != in)
  ------------------
  |  Branch (2512:39): [True: 110k, False: 3.11k]
  ------------------
 2513|   110k|                                {
 2514|   110k|                                    if((*j)->type == ANT_ATOM)
  ------------------
  |  Branch (2514:40): [True: 110k, False: 77]
  ------------------
 2515|   110k|                                        names.push_back(((AtomAbstractNode*)(*j).get())->value);
 2516|     77|                                    else
 2517|     77|                                        compiler->addError(*prop, (*j)->getValue() + " is not supported as a texture name");
 2518|   110k|                                    ++j;
 2519|   110k|                                }
 2520|       |
 2521|  3.11k|                                processResourceNames(compiler, ResourceType::TEXTURE, names);
 2522|  3.11k|                                mUnit->setAnimatedTextureName(names, duration);
 2523|  3.11k|                            }
 2524|  2.06k|                            else
 2525|  2.06k|                            {
 2526|  2.06k|                                compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line,
 2527|  2.06k|                                                   (*in)->getValue() + " is not supported for the duration argument");
 2528|  2.06k|                            }
 2529|  5.18k|                        }
 2530|  13.4k|                    }
 2531|  16.3k|                    break;
 2532|  12.8k|                case ID_CUBIC_TEXTURE:
  ------------------
  |  Branch (2532:17): [True: 12.8k, False: 454k]
  ------------------
 2533|  12.8k|                    if(prop->values.empty())
  ------------------
  |  Branch (2533:24): [True: 274, False: 12.5k]
  ------------------
 2534|    274|                    {
 2535|    274|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 2536|    274|                    }
 2537|  12.5k|                    else if(prop->values.size() == 2)
  ------------------
  |  Branch (2537:29): [True: 2.43k, False: 10.1k]
  ------------------
 2538|  2.43k|                    {
 2539|  2.43k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0),
 2540|  2.43k|                            i1 = getNodeAt(prop->values, 1);
 2541|  2.43k|                        if((*i0)->type == ANT_ATOM && (*i1)->type == ANT_ATOM)
  ------------------
  |  Branch (2541:28): [True: 2.40k, False: 34]
  |  Branch (2541:55): [True: 1.20k, False: 1.19k]
  ------------------
 2542|  1.20k|                        {
 2543|  1.20k|                            AtomAbstractNode *atom0 = (AtomAbstractNode*)(*i0).get();
 2544|       |
 2545|  1.20k|                            mUnit->setTextureName(processResourceName(compiler, ResourceType::TEXTURE, atom0->value), TEX_TYPE_CUBE_MAP);
 2546|       |
 2547|  1.20k|                            compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line,
 2548|  1.20k|                                                   "'cubic_texture ..'. Use 'texture .. cubic' instead.");
 2549|  1.20k|                        }
 2550|  1.23k|                        else
 2551|  1.23k|                        {
 2552|  1.23k|                            compiler->addError(*prop);
 2553|  1.23k|                        }
 2554|  2.43k|                    }
 2555|  10.1k|                    else if(prop->values.size() == 7)
  ------------------
  |  Branch (2555:29): [True: 6.67k, False: 3.47k]
  ------------------
 2556|  6.67k|                    {
 2557|  6.67k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0),
 2558|  6.67k|                            i1 = getNodeAt(prop->values, 1),
 2559|  6.67k|                            i2 = getNodeAt(prop->values, 2),
 2560|  6.67k|                            i3 = getNodeAt(prop->values, 3),
 2561|  6.67k|                            i4 = getNodeAt(prop->values, 4),
 2562|  6.67k|                            i5 = getNodeAt(prop->values, 5),
 2563|  6.67k|                            i6 = getNodeAt(prop->values, 6);
 2564|  6.67k|                        if((*i0)->type == ANT_ATOM && (*i1)->type == ANT_ATOM && (*i2)->type == ANT_ATOM && (*i3)->type == ANT_ATOM &&
  ------------------
  |  Branch (2564:28): [True: 6.47k, False: 198]
  |  Branch (2564:55): [True: 6.14k, False: 334]
  |  Branch (2564:82): [True: 5.92k, False: 215]
  |  Branch (2564:109): [True: 5.78k, False: 145]
  ------------------
 2565|  5.78k|                           (*i4)->type == ANT_ATOM && (*i5)->type == ANT_ATOM && (*i6)->type == ANT_ATOM)
  ------------------
  |  Branch (2565:28): [True: 5.45k, False: 327]
  |  Branch (2565:55): [True: 5.22k, False: 232]
  |  Branch (2565:82): [True: 3.69k, False: 1.53k]
  ------------------
 2566|  3.69k|                        {
 2567|  3.69k|                            AtomAbstractNode *atom0 = (AtomAbstractNode*)(*i0).get(), *atom1 = (AtomAbstractNode*)(*i1).get(),
 2568|  3.69k|                                *atom2 = (AtomAbstractNode*)(*i2).get(), *atom3 = (AtomAbstractNode*)(*i3).get(),
 2569|  3.69k|                                *atom4 = (AtomAbstractNode*)(*i4).get(), *atom5 = (AtomAbstractNode*)(*i5).get(),
 2570|  3.69k|                                *atom6 = (AtomAbstractNode*)(*i6).get();
 2571|  3.69k|                            std::vector<String> names(6);
 2572|       |                            // backward compatible order
 2573|  3.69k|                            names[4] = atom0->value;
 2574|  3.69k|                            names[5] = atom1->value;
 2575|  3.69k|                            names[1] = atom2->value;
 2576|  3.69k|                            names[0] = atom3->value;
 2577|  3.69k|                            names[2] = atom4->value;
 2578|  3.69k|                            names[3] = atom5->value;
 2579|       |
 2580|  3.69k|                            processResourceNames(compiler, ResourceType::TEXTURE, names);
 2581|       |
 2582|  3.69k|                            if(atom6->id != ID_COMBINED_UVW)
  ------------------
  |  Branch (2582:32): [True: 3.64k, False: 48]
  ------------------
 2583|  3.64k|                            {
 2584|  3.64k|                                compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line,
 2585|  3.64k|                                                   "separateUV is no longer supported.");
 2586|  3.64k|                            }
 2587|  3.69k|                            mUnit->setLayerArrayNames(TEX_TYPE_CUBE_MAP, names);
 2588|  3.69k|                        }
 2589|       |
 2590|  6.67k|                    }
 2591|  3.47k|                    else
 2592|  3.47k|                    {
 2593|  3.47k|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 2594|  3.47k|                                           "cubic_texture must have at most 7 arguments");
 2595|  3.47k|                    }
 2596|  12.8k|                    break;
 2597|  1.75k|                case ID_TEX_COORD_SET:
  ------------------
  |  Branch (2597:17): [True: 1.75k, False: 465k]
  ------------------
 2598|  1.75k|                    if(getValue(prop, compiler, uival))
  ------------------
  |  Branch (2598:24): [True: 1.48k, False: 274]
  ------------------
 2599|  1.48k|                        mUnit->setTextureCoordSet(uival);
 2600|  1.75k|                    break;
 2601|       |
 2602|  6.18k|                case ID_COLOUR_OP:
  ------------------
  |  Branch (2602:17): [True: 6.18k, False: 460k]
  ------------------
 2603|  6.18k|                    LayerBlendOperation cop;
 2604|  6.18k|                    if(getValue(prop, compiler, cop))
  ------------------
  |  Branch (2604:24): [True: 401, False: 5.78k]
  ------------------
 2605|    401|                        mUnit->setColourOperation(cop);
 2606|  6.18k|                    break;
 2607|  13.6k|                case ID_COLOUR_OP_EX:
  ------------------
  |  Branch (2607:17): [True: 13.6k, False: 453k]
  ------------------
 2608|  13.6k|                    if(prop->values.size() < 3)
  ------------------
  |  Branch (2608:24): [True: 2.05k, False: 11.5k]
  ------------------
 2609|  2.05k|                    {
 2610|  2.05k|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line,
 2611|  2.05k|                                           "colour_op_ex must have at least 3 arguments");
 2612|  2.05k|                    }
 2613|  11.5k|                    else if(prop->values.size() > 10)
  ------------------
  |  Branch (2613:29): [True: 135, False: 11.4k]
  ------------------
 2614|    135|                    {
 2615|    135|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 2616|    135|                                           "colour_op_ex must have at most 10 arguments");
 2617|    135|                    }
 2618|  11.4k|                    else
 2619|  11.4k|                    {
 2620|  11.4k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0),
 2621|  11.4k|                            i1 = getNodeAt(prop->values, 1),
 2622|  11.4k|                            i2 = getNodeAt(prop->values, 2);
 2623|  11.4k|                        LayerBlendOperationEx op;
 2624|  11.4k|                        LayerBlendSource source1, source2;
 2625|  11.4k|                        if (getValue(*i0, op) && getValue(*i1, source1) && getValue(*i2, source2))
  ------------------
  |  Branch (2625:29): [True: 9.67k, False: 1.78k]
  |  Branch (2625:50): [True: 6.00k, False: 3.67k]
  |  Branch (2625:76): [True: 4.10k, False: 1.89k]
  ------------------
 2626|  4.10k|                        {
 2627|  4.10k|                            ColourValue arg1 = ColourValue::White, arg2 = ColourValue::White;
 2628|  4.10k|                            Real manualBlend = 0.0f;
 2629|       |
 2630|  4.10k|                            if(op == LBX_BLEND_MANUAL)
  ------------------
  |  Branch (2630:32): [True: 784, False: 3.31k]
  ------------------
 2631|    784|                            {
 2632|    784|                                AbstractNodeList::const_iterator i3 = getNodeAt(prop->values, 3);
 2633|    784|                                if(i3 != prop->values.end())
  ------------------
  |  Branch (2633:36): [True: 678, False: 106]
  ------------------
 2634|    678|                                {
 2635|    678|                                    if(!getReal(*i3, &manualBlend))
  ------------------
  |  Branch (2635:40): [True: 344, False: 334]
  ------------------
 2636|    344|                                        compiler->addError(*prop, (*i3)->getValue() + " is not a valid number argument");
 2637|    678|                                }
 2638|    106|                                else
 2639|    106|                                {
 2640|    106|                                    compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line,
 2641|    106|                                                       "fourth argument expected when blend_manual is used");
 2642|    106|                                }
 2643|    784|                            }
 2644|       |
 2645|  4.10k|                            AbstractNodeList::const_iterator j = getNodeAt(prop->values, 3);
 2646|  4.10k|                            if(op == LBX_BLEND_MANUAL)
  ------------------
  |  Branch (2646:32): [True: 784, False: 3.31k]
  ------------------
 2647|    784|                                ++j;
 2648|  4.10k|                            if(source1 == LBS_MANUAL)
  ------------------
  |  Branch (2648:32): [True: 1.36k, False: 2.73k]
  ------------------
 2649|  1.36k|                            {
 2650|  1.36k|                                if(j != prop->values.end())
  ------------------
  |  Branch (2650:36): [True: 731, False: 636]
  ------------------
 2651|    731|                                {
 2652|    731|                                    if(!getColour(j, prop->values.end(), &arg1, 3))
  ------------------
  |  Branch (2652:40): [True: 482, False: 249]
  ------------------
 2653|    482|                                        compiler->addError(*prop, "valid colour expected when src_manual is used");
 2654|    731|                                }
 2655|    636|                                else
 2656|    636|                                {
 2657|    636|                                    compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line,
 2658|    636|                                                       "valid colour expected when src_manual is used");
 2659|    636|                                }
 2660|  1.36k|                            }
 2661|  4.10k|                            if(source2 == LBS_MANUAL)
  ------------------
  |  Branch (2661:32): [True: 1.08k, False: 3.02k]
  ------------------
 2662|  1.08k|                            {
 2663|  1.08k|                                if(j != prop->values.end())
  ------------------
  |  Branch (2663:36): [True: 847, False: 233]
  ------------------
 2664|    847|                                {
 2665|    847|                                    if(!getColour(j, prop->values.end(), &arg2, 3))
  ------------------
  |  Branch (2665:40): [True: 506, False: 341]
  ------------------
 2666|    506|                                        compiler->addError(*prop, "valid colour expected when src_manual is used");
 2667|    847|                                }
 2668|    233|                                else
 2669|    233|                                {
 2670|    233|                                    compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line,
 2671|    233|                                                       "valid colour expected when src_manual is used");
 2672|    233|                                }
 2673|  1.08k|                            }
 2674|       |
 2675|  4.10k|                            mUnit->setColourOperationEx(op, source1, source2, arg1, arg2, manualBlend);
 2676|  4.10k|                        }
 2677|  7.35k|                        else
 2678|  7.35k|                        {
 2679|  7.35k|                            compiler->addError(*prop);
 2680|  7.35k|                        }
 2681|  11.4k|                    }
 2682|  13.6k|                    break;
 2683|  5.82k|                case ID_COLOUR_OP_MULTIPASS_FALLBACK:
  ------------------
  |  Branch (2683:17): [True: 5.82k, False: 461k]
  ------------------
 2684|  5.82k|                    if(prop->values.empty())
  ------------------
  |  Branch (2684:24): [True: 409, False: 5.41k]
  ------------------
 2685|    409|                    {
 2686|    409|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 2687|    409|                    }
 2688|  5.41k|                    else if(prop->values.size() > 2)
  ------------------
  |  Branch (2688:29): [True: 530, False: 4.88k]
  ------------------
 2689|    530|                    {
 2690|    530|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 2691|    530|                                           "colour_op_multiplass_fallback must have at most 2 arguments");
 2692|    530|                    }
 2693|  4.88k|                    else if(prop->values.size() == 1)
  ------------------
  |  Branch (2693:29): [True: 2.19k, False: 2.69k]
  ------------------
 2694|  2.19k|                    {
 2695|  2.19k|                        switch(getAtomId(prop->values.front()))
 2696|  2.19k|                        {
 2697|    227|                        case ID_ADD:
  ------------------
  |  Branch (2697:25): [True: 227, False: 1.96k]
  ------------------
 2698|    227|                            mUnit->setColourOpMultipassFallback(SBF_ONE, SBF_ONE);
 2699|    227|                            break;
 2700|    246|                        case ID_MODULATE:
  ------------------
  |  Branch (2700:25): [True: 246, False: 1.94k]
  ------------------
 2701|    246|                            mUnit->setColourOpMultipassFallback(SBF_DEST_COLOUR, SBF_ZERO);
 2702|    246|                            break;
 2703|    333|                        case ID_COLOUR_BLEND:
  ------------------
  |  Branch (2703:25): [True: 333, False: 1.86k]
  ------------------
 2704|    333|                            mUnit->setColourOpMultipassFallback(SBF_SOURCE_COLOUR, SBF_ONE_MINUS_SOURCE_COLOUR);
 2705|    333|                            break;
 2706|    265|                        case ID_ALPHA_BLEND:
  ------------------
  |  Branch (2706:25): [True: 265, False: 1.92k]
  ------------------
 2707|    265|                            mUnit->setColourOpMultipassFallback(SBF_SOURCE_ALPHA, SBF_ONE_MINUS_SOURCE_ALPHA);
 2708|    265|                            break;
 2709|    429|                        case ID_REPLACE:
  ------------------
  |  Branch (2709:25): [True: 429, False: 1.76k]
  ------------------
 2710|    429|                            mUnit->setColourOpMultipassFallback(SBF_ONE, SBF_ZERO);
 2711|    429|                            break;
 2712|    694|                        default:
  ------------------
  |  Branch (2712:25): [True: 694, False: 1.50k]
  ------------------
 2713|    694|                            compiler->addError(*prop, "argument must be a valid scene blend type (add, modulate, colour_blend, alpha_blend, or replace)");
 2714|  2.19k|                        }
 2715|  2.19k|                    }
 2716|  2.69k|                    else
 2717|  2.69k|                    {
 2718|  2.69k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1);
 2719|  2.69k|                        SceneBlendFactor sbf0, sbf1;
 2720|  2.69k|                        if(getSceneBlendFactor(*i0, &sbf0) && getSceneBlendFactor(*i1, &sbf1))
  ------------------
  |  Branch (2720:28): [True: 1.63k, False: 1.05k]
  |  Branch (2720:63): [True: 687, False: 945]
  ------------------
 2721|    687|                            mUnit->setColourOpMultipassFallback(sbf0, sbf1);
 2722|  2.00k|                        else
 2723|  2.00k|                            compiler->addError(*prop, "arguments must be valid scene blend factors");
 2724|  2.69k|                    }
 2725|  5.82k|                    break;
 2726|  11.9k|                case ID_ALPHA_OP_EX:
  ------------------
  |  Branch (2726:17): [True: 11.9k, False: 455k]
  ------------------
 2727|  11.9k|                    if(prop->values.size() < 3)
  ------------------
  |  Branch (2727:24): [True: 1.26k, False: 10.6k]
  ------------------
 2728|  1.26k|                    {
 2729|  1.26k|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line,
 2730|  1.26k|                                           "alpha_op_ex must have at least 3 arguments");
 2731|  1.26k|                    }
 2732|  10.6k|                    else if(prop->values.size() > 6)
  ------------------
  |  Branch (2732:29): [True: 999, False: 9.64k]
  ------------------
 2733|    999|                    {
 2734|    999|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 2735|    999|                                           "alpha_op_ex must have at most 6 arguments");
 2736|    999|                    }
 2737|  9.64k|                    else
 2738|  9.64k|                    {
 2739|  9.64k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0),
 2740|  9.64k|                            i1 = getNodeAt(prop->values, 1),
 2741|  9.64k|                            i2 = getNodeAt(prop->values, 2);
 2742|  9.64k|                        LayerBlendOperationEx op;
 2743|  9.64k|                        LayerBlendSource source1, source2;
 2744|  9.64k|                        if (getValue(*i0, op) && getValue(*i1, source1) && getValue(*i2, source2))
  ------------------
  |  Branch (2744:29): [True: 8.22k, False: 1.41k]
  |  Branch (2744:50): [True: 4.30k, False: 3.91k]
  |  Branch (2744:76): [True: 3.16k, False: 1.14k]
  ------------------
 2745|  3.16k|                        {
 2746|  3.16k|                            Real arg1 = 0.0f, arg2 = 0.0f;
 2747|  3.16k|                            Real manualBlend = 0.0f;
 2748|       |
 2749|  3.16k|                            if(op == LBX_BLEND_MANUAL)
  ------------------
  |  Branch (2749:32): [True: 968, False: 2.20k]
  ------------------
 2750|    968|                            {
 2751|    968|                                AbstractNodeList::const_iterator i3 = getNodeAt(prop->values, 3);
 2752|    968|                                if(i3 != prop->values.end())
  ------------------
  |  Branch (2752:36): [True: 761, False: 207]
  ------------------
 2753|    761|                                {
 2754|    761|                                    if(!getReal(*i3, &manualBlend))
  ------------------
  |  Branch (2754:40): [True: 397, False: 364]
  ------------------
 2755|    397|                                        compiler->addError(*prop, "valid number expected when blend_manual is used");
 2756|    761|                                }
 2757|    207|                                else
 2758|    207|                                {
 2759|    207|                                    compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line,
 2760|    207|                                                       "valid number expected when blend_manual is used");
 2761|    207|                                }
 2762|    968|                            }
 2763|       |
 2764|  3.16k|                            AbstractNodeList::const_iterator j = getNodeAt(prop->values, 3);
 2765|  3.16k|                            if(op == LBX_BLEND_MANUAL)
  ------------------
  |  Branch (2765:32): [True: 968, False: 2.20k]
  ------------------
 2766|    968|                                ++j;
 2767|  3.16k|                            if(source1 == LBS_MANUAL)
  ------------------
  |  Branch (2767:32): [True: 2.19k, False: 976]
  ------------------
 2768|  2.19k|                            {
 2769|  2.19k|                                if(j != prop->values.end())
  ------------------
  |  Branch (2769:36): [True: 1.99k, False: 200]
  ------------------
 2770|  1.99k|                                {
 2771|  1.99k|                                    if(!getReal(*j, &arg1))
  ------------------
  |  Branch (2771:40): [True: 511, False: 1.48k]
  ------------------
 2772|    511|                                        compiler->addError(*prop, "valid colour expected when src_manual is used");
 2773|  1.48k|                                    else
 2774|  1.48k|                                        ++j;
 2775|  1.99k|                                }
 2776|    200|                                else
 2777|    200|                                {
 2778|    200|                                    compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line,
 2779|    200|                                                       "valid colour expected when src_manual is used");
 2780|    200|                                }
 2781|  2.19k|                            }
 2782|  3.16k|                            if(source2 == LBS_MANUAL)
  ------------------
  |  Branch (2782:32): [True: 1.08k, False: 2.08k]
  ------------------
 2783|  1.08k|                            {
 2784|  1.08k|                                if(j != prop->values.end())
  ------------------
  |  Branch (2784:36): [True: 794, False: 286]
  ------------------
 2785|    794|                                {
 2786|    794|                                    if(!getReal(*j, &arg2))
  ------------------
  |  Branch (2786:40): [True: 511, False: 283]
  ------------------
 2787|    511|                                        compiler->addError(*prop, "valid colour expected when src_manual is used");
 2788|    794|                                }
 2789|    286|                                else
 2790|    286|                                {
 2791|    286|                                    compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line,
 2792|    286|                                                       "valid colour expected when src_manual is used");
 2793|    286|                                }
 2794|  1.08k|                            }
 2795|       |
 2796|  3.16k|                            mUnit->setAlphaOperation(op, source1, source2, arg1, arg2, manualBlend);
 2797|  3.16k|                        }
 2798|  6.47k|                        else
 2799|  6.47k|                        {
 2800|  6.47k|                            compiler->addError(*prop);
 2801|  6.47k|                        }
 2802|  9.64k|                    }
 2803|  11.9k|                    break;
 2804|  23.9k|                case ID_ENV_MAP:
  ------------------
  |  Branch (2804:17): [True: 23.9k, False: 443k]
  ------------------
 2805|  23.9k|                    if(prop->values.empty())
  ------------------
  |  Branch (2805:24): [True: 539, False: 23.4k]
  ------------------
 2806|    539|                    {
 2807|    539|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 2808|    539|                    }
 2809|  23.4k|                    else if(prop->values.size() > 1)
  ------------------
  |  Branch (2809:29): [True: 1.48k, False: 21.9k]
  ------------------
 2810|  1.48k|                    {
 2811|  1.48k|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 2812|  1.48k|                                           "env_map must have at most 1 argument");
 2813|  1.48k|                    }
 2814|  21.9k|                    else
 2815|  21.9k|                    {
 2816|  21.9k|                        switch(getAtomId(prop->values.front()))
 2817|  21.9k|                        {
 2818|    574|                        case ScriptCompiler::ID_OFF:
  ------------------
  |  Branch (2818:25): [True: 574, False: 21.3k]
  ------------------
 2819|    574|                            mUnit->setEnvironmentMap(false);
 2820|    574|                            break;
 2821|  16.3k|                        case ID_SPHERICAL:
  ------------------
  |  Branch (2821:25): [True: 16.3k, False: 5.59k]
  ------------------
 2822|  16.3k|                            mUnit->setEnvironmentMap(true, TextureUnitState::ENV_CURVED);
 2823|  16.3k|                            break;
 2824|    545|                        case ID_PLANAR:
  ------------------
  |  Branch (2824:25): [True: 545, False: 21.4k]
  ------------------
 2825|    545|                            mUnit->setEnvironmentMap(true, TextureUnitState::ENV_PLANAR);
 2826|    545|                            break;
 2827|    252|                        case ID_CUBIC_REFLECTION:
  ------------------
  |  Branch (2827:25): [True: 252, False: 21.6k]
  ------------------
 2828|    252|                            mUnit->setEnvironmentMap(true, TextureUnitState::ENV_REFLECTION);
 2829|    252|                            break;
 2830|    516|                        case ID_CUBIC_NORMAL:
  ------------------
  |  Branch (2830:25): [True: 516, False: 21.4k]
  ------------------
 2831|    516|                            mUnit->setEnvironmentMap(true, TextureUnitState::ENV_NORMAL);
 2832|    516|                            break;
 2833|  3.70k|                        default:
  ------------------
  |  Branch (2833:25): [True: 3.70k, False: 18.2k]
  ------------------
 2834|  3.70k|                            compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid argument (must be \"off\", \"spherical\", \"planar\", \"cubic_reflection\", or \"cubic_normal\")");
 2835|  21.9k|                        }
 2836|  21.9k|                    }
 2837|  23.9k|                    break;
 2838|  23.9k|                case ID_SCROLL:
  ------------------
  |  Branch (2838:17): [True: 2.14k, False: 465k]
  ------------------
 2839|  2.14k|                    {
 2840|  2.14k|                        std::vector<float> v;
 2841|  2.14k|                        if(prop->values.size() == 2 && getVector(prop->values.begin(), prop->values.end(), v, 2))
  ------------------
  |  Branch (2841:28): [True: 869, False: 1.27k]
  |  Branch (2841:28): [True: 317, False: 1.82k]
  |  Branch (2841:56): [True: 317, False: 552]
  ------------------
 2842|    317|                            mUnit->setTextureScroll(v[0], v[1]);
 2843|  1.82k|                        else
 2844|  1.82k|                            compiler->addError(*prop, "scroll requires exactly 2 numeric arguments");
 2845|  2.14k|                    }
 2846|  2.14k|                    break;
 2847|  27.9k|                case ID_SCROLL_ANIM:
  ------------------
  |  Branch (2847:17): [True: 27.9k, False: 439k]
  ------------------
 2848|  27.9k|                    {
 2849|  27.9k|                        std::vector<float> v;
 2850|  27.9k|                        if(prop->values.size() == 2 && getVector(prop->values.begin(), prop->values.end(), v, 2))
  ------------------
  |  Branch (2850:28): [True: 25.8k, False: 2.06k]
  |  Branch (2850:28): [True: 24.5k, False: 3.40k]
  |  Branch (2850:56): [True: 24.5k, False: 1.34k]
  ------------------
 2851|  24.5k|                            mUnit->setScrollAnimation(v[0], v[1]);
 2852|  3.40k|                        else
 2853|  3.40k|                            compiler->addError(*prop, "scroll_anim requires exactly 2 numeric arguments");
 2854|  27.9k|                    }
 2855|  27.9k|                    break;
 2856|    810|                case ID_ROTATE:
  ------------------
  |  Branch (2856:17): [True: 810, False: 466k]
  ------------------
 2857|    810|                    if(getValue(prop, compiler, fval))
  ------------------
  |  Branch (2857:24): [True: 334, False: 476]
  ------------------
 2858|    334|                        mUnit->setTextureRotate(Degree(fval));
 2859|    810|                    break;
 2860|  6.37k|                case ID_ROTATE_ANIM:
  ------------------
  |  Branch (2860:17): [True: 6.37k, False: 460k]
  ------------------
 2861|  6.37k|                    if(getValue(prop, compiler, fval))
  ------------------
  |  Branch (2861:24): [True: 5.41k, False: 953]
  ------------------
 2862|  5.41k|                        mUnit->setRotateAnimation(fval);
 2863|  6.37k|                    break;
 2864|  1.24k|                case ID_SCALE:
  ------------------
  |  Branch (2864:17): [True: 1.24k, False: 465k]
  ------------------
 2865|  1.24k|                    {
 2866|  1.24k|                        std::vector<float> v;
 2867|  1.24k|                        if(prop->values.size() == 2 && getVector(prop->values.begin(), prop->values.end(), v, 2))
  ------------------
  |  Branch (2867:28): [True: 865, False: 384]
  |  Branch (2867:28): [True: 478, False: 771]
  |  Branch (2867:56): [True: 478, False: 387]
  ------------------
 2868|    478|                            mUnit->setTextureScale(v[0], v[1]);
 2869|    771|                        else
 2870|    771|                            compiler->addError(*prop, "scale requires exactly 2 numeric arguments");
 2871|  1.24k|                    }
 2872|  1.24k|                    break;
 2873|  17.7k|                case ID_WAVE_XFORM:
  ------------------
  |  Branch (2873:17): [True: 17.7k, False: 449k]
  ------------------
 2874|  17.7k|                    if(prop->values.size() != 6)
  ------------------
  |  Branch (2874:24): [True: 3.78k, False: 13.9k]
  ------------------
 2875|  3.78k|                    {
 2876|  3.78k|                        compiler->addError(*prop, "wave_xform requires exactly 6 arguments");
 2877|  3.78k|                    }
 2878|  13.9k|                    else
 2879|  13.9k|                    {
 2880|  13.9k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1),
 2881|  13.9k|                            i2 = getNodeAt(prop->values, 2), i3 = getNodeAt(prop->values, 3),
 2882|  13.9k|                            i4 = getNodeAt(prop->values, 4), i5 = getNodeAt(prop->values, 5);
 2883|  13.9k|                        if((*i0)->type == ANT_ATOM && (*i1)->type == ANT_ATOM && (*i2)->type == ANT_ATOM &&
  ------------------
  |  Branch (2883:28): [True: 13.8k, False: 92]
  |  Branch (2883:55): [True: 13.4k, False: 413]
  |  Branch (2883:82): [True: 13.2k, False: 255]
  ------------------
 2884|  13.2k|                           (*i3)->type == ANT_ATOM && (*i4)->type == ANT_ATOM && (*i5)->type == ANT_ATOM)
  ------------------
  |  Branch (2884:28): [True: 13.0k, False: 190]
  |  Branch (2884:55): [True: 12.7k, False: 284]
  |  Branch (2884:82): [True: 12.4k, False: 310]
  ------------------
 2885|  12.4k|                        {
 2886|  12.4k|                            AtomAbstractNode *atom0 = (AtomAbstractNode*)(*i0).get(), *atom1 = (AtomAbstractNode*)(*i1).get();
 2887|  12.4k|                            TextureUnitState::TextureTransformType type = TextureUnitState::TT_ROTATE;
 2888|  12.4k|                            WaveformType wave = WFT_SINE;
 2889|  12.4k|                            Real base = 0.0f, freq = 0.0f, phase = 0.0f, amp = 0.0f;
 2890|       |
 2891|  12.4k|                            switch(atom0->id)
 2892|  12.4k|                            {
 2893|    267|                            case ID_SCROLL_X:
  ------------------
  |  Branch (2893:29): [True: 267, False: 12.1k]
  ------------------
 2894|    267|                                type = TextureUnitState::TT_TRANSLATE_U;
 2895|    267|                                break;
 2896|    475|                            case ID_SCROLL_Y:
  ------------------
  |  Branch (2896:29): [True: 475, False: 11.9k]
  ------------------
 2897|    475|                                type = TextureUnitState::TT_TRANSLATE_V;
 2898|    475|                                break;
 2899|  5.22k|                            case ID_SCALE_X:
  ------------------
  |  Branch (2899:29): [True: 5.22k, False: 7.20k]
  ------------------
 2900|  5.22k|                                type = TextureUnitState::TT_SCALE_U;
 2901|  5.22k|                                break;
 2902|  1.44k|                            case ID_SCALE_Y:
  ------------------
  |  Branch (2902:29): [True: 1.44k, False: 10.9k]
  ------------------
 2903|  1.44k|                                type = TextureUnitState::TT_SCALE_V;
 2904|  1.44k|                                break;
 2905|      2|                            case ID_ROTATE:
  ------------------
  |  Branch (2905:29): [True: 2, False: 12.4k]
  ------------------
 2906|      2|                                type = TextureUnitState::TT_ROTATE;
 2907|      2|                                break;
 2908|  5.01k|                            default:
  ------------------
  |  Branch (2908:29): [True: 5.01k, False: 7.41k]
  ------------------
 2909|  5.01k|                                compiler->addError(*prop, atom0->value + " is not a valid transform type (must be \"scroll_x\", \"scroll_y\", \"scale_x\", \"scale_y\", or \"rotate\")");
 2910|  12.4k|                            }
 2911|       |
 2912|  12.4k|                            switch(atom1->id)
 2913|  12.4k|                            {
 2914|  6.72k|                            case ID_SINE:
  ------------------
  |  Branch (2914:29): [True: 6.72k, False: 5.70k]
  ------------------
 2915|  6.72k|                                wave = WFT_SINE;
 2916|  6.72k|                                break;
 2917|      9|                            case ID_TRIANGLE:
  ------------------
  |  Branch (2917:29): [True: 9, False: 12.4k]
  ------------------
 2918|      9|                                wave = WFT_TRIANGLE;
 2919|      9|                                break;
 2920|     54|                            case ID_SQUARE:
  ------------------
  |  Branch (2920:29): [True: 54, False: 12.3k]
  ------------------
 2921|     54|                                wave = WFT_SQUARE;
 2922|     54|                                break;
 2923|     95|                            case ID_SAWTOOTH:
  ------------------
  |  Branch (2923:29): [True: 95, False: 12.3k]
  ------------------
 2924|     95|                                wave = WFT_SAWTOOTH;
 2925|     95|                                break;
 2926|      0|                            case ID_INVERSE_SAWTOOTH:
  ------------------
  |  Branch (2926:29): [True: 0, False: 12.4k]
  ------------------
 2927|      0|                                wave = WFT_INVERSE_SAWTOOTH;
 2928|      0|                                break;
 2929|  5.54k|                            default:
  ------------------
  |  Branch (2929:29): [True: 5.54k, False: 6.88k]
  ------------------
 2930|  5.54k|                                compiler->addError(*prop, atom1->value + " is not a valid waveform type (must be \"sine\", \"triangle\", \"square\", \"sawtooth\", or \"inverse_sawtooth\")");
 2931|  12.4k|                            }
 2932|       |
 2933|  12.4k|                            if(!getReal(*i2, &base) || !getReal(*i3, &freq) || !getReal(*i4, &phase) || !getReal(*i5, &amp))
  ------------------
  |  Branch (2933:32): [True: 548, False: 11.8k]
  |  Branch (2933:56): [True: 1.06k, False: 10.8k]
  |  Branch (2933:80): [True: 1.79k, False: 9.02k]
  |  Branch (2933:105): [True: 3.18k, False: 5.84k]
  ------------------
 2934|  6.58k|                                compiler->addError(*prop, "arguments 3, 4, 5, and 6 must be valid numbers; received " + (*i2)->getValue() + ", " + (*i3)->getValue() + ", " + (*i4)->getValue() + ", " + (*i5)->getValue());
 2935|       |
 2936|  12.4k|                            mUnit->setTransformAnimation(type, wave, base, freq, phase, amp);
 2937|  12.4k|                        }
 2938|  1.54k|                        else
 2939|  1.54k|                        {
 2940|  1.54k|                            compiler->addError(*prop);
 2941|  1.54k|                        }
 2942|  13.9k|                    }
 2943|  17.7k|                    break;
 2944|  17.7k|                case ID_TRANSFORM:
  ------------------
  |  Branch (2944:17): [True: 2.39k, False: 464k]
  ------------------
 2945|  2.39k|                    {
 2946|  2.39k|                        Matrix4 m;
 2947|  2.39k|                        if(getMatrix4(prop->values.begin(), prop->values.end(), &m))
  ------------------
  |  Branch (2947:28): [True: 934, False: 1.45k]
  ------------------
 2948|    934|                            mUnit->setTextureTransform(m);
 2949|  1.45k|                        else
 2950|  1.45k|                            compiler->addError(*prop);
 2951|  2.39k|                    }
 2952|  2.39k|                    break;
 2953|  11.7k|                case ID_CONTENT_TYPE:
  ------------------
  |  Branch (2953:17): [True: 11.7k, False: 455k]
  ------------------
 2954|  11.7k|                    if(prop->values.empty())
  ------------------
  |  Branch (2954:24): [True: 355, False: 11.4k]
  ------------------
 2955|    355|                    {
 2956|    355|                        compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line);
 2957|    355|                    }
 2958|  11.4k|                    else if(prop->values.size() > 4)
  ------------------
  |  Branch (2958:29): [True: 998, False: 10.4k]
  ------------------
 2959|    998|                    {
 2960|    998|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line,
 2961|    998|                                           "content_type must have at most 4 arguments");
 2962|    998|                    }
 2963|  10.4k|                    else
 2964|  10.4k|                    {
 2965|  10.4k|                        switch(getAtomId(prop->values.front()))
 2966|  10.4k|                        {
 2967|    248|                        case ID_NAMED:
  ------------------
  |  Branch (2967:25): [True: 248, False: 10.1k]
  ------------------
 2968|    248|                            mUnit->setContentType(TextureUnitState::CONTENT_NAMED);
 2969|    248|                            break;
 2970|    543|                        case ID_SHADOW:
  ------------------
  |  Branch (2970:25): [True: 543, False: 9.87k]
  ------------------
 2971|    543|                            mUnit->setContentType(TextureUnitState::CONTENT_SHADOW);
 2972|    543|                            break;
 2973|  6.59k|                        case ID_COMPOSITOR:
  ------------------
  |  Branch (2973:25): [True: 6.59k, False: 3.82k]
  ------------------
 2974|  6.59k|                            mUnit->setContentType(TextureUnitState::CONTENT_COMPOSITOR);
 2975|  6.59k|                            if (prop->values.size() >= 3)
  ------------------
  |  Branch (2975:33): [True: 5.47k, False: 1.12k]
  ------------------
 2976|  5.47k|                            {
 2977|  5.47k|                                String compositorName;
 2978|  5.47k|                                getString(*getNodeAt(prop->values, 1), &compositorName);
 2979|  5.47k|                                String textureName;
 2980|  5.47k|                                getString(*getNodeAt(prop->values, 2), &textureName);
 2981|       |
 2982|  5.47k|                                if (prop->values.size() == 4)
  ------------------
  |  Branch (2982:37): [True: 4.62k, False: 852]
  ------------------
 2983|  4.62k|                                {
 2984|  4.62k|                                    uint32 mrtIndex;
 2985|  4.62k|                                    getUInt(*getNodeAt(prop->values, 3), (uint32*)&mrtIndex);
 2986|  4.62k|                                    mUnit->setCompositorReference(compositorName, textureName, mrtIndex);
 2987|  4.62k|                                }
 2988|    852|                                else
 2989|    852|                                {
 2990|    852|                                    mUnit->setCompositorReference(compositorName, textureName);
 2991|    852|                                }
 2992|  5.47k|                            }
 2993|  1.12k|                            else
 2994|  1.12k|                            {
 2995|  1.12k|                                compiler->addError(*prop, "content_type compositor must have an additional 2 or 3 parameters");
 2996|  1.12k|                            }
 2997|       |
 2998|  6.59k|                            break;
 2999|  3.02k|                        default:
  ------------------
  |  Branch (2999:25): [True: 3.02k, False: 7.38k]
  ------------------
 3000|  3.02k|                            compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid content type (must be \"named\" or \"shadow\" or \"compositor\")");
 3001|  10.4k|                        }
 3002|  10.4k|                    }
 3003|  11.7k|                    break;
 3004|   207k|                default:
  ------------------
  |  Branch (3004:17): [True: 207k, False: 259k]
  ------------------
 3005|   207k|                    compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line,
 3006|   207k|                                       "token \"" + prop->name + "\" is not recognized");
 3007|   467k|                }
 3008|   467k|            }
 3009|  99.5k|            else if(i->type == ANT_OBJECT)
  ------------------
  |  Branch (3009:21): [True: 6.32k, False: 93.2k]
  ------------------
 3010|  6.32k|            {
 3011|  6.32k|                processNode(compiler, i);
 3012|  6.32k|            }
 3013|   566k|        }
 3014|  41.4k|    }
_ZN4Ogre23TextureSourceTranslatorC2Ev:
 3020|      1|    {
 3021|      1|    }
_ZN4Ogre23TextureSourceTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE:
 3024|    746|    {
 3025|    746|        ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(node.get());
 3026|       |
 3027|       |        // It has to have one value identifying the texture source name
 3028|    746|        if(obj->values.empty())
  ------------------
  |  Branch (3028:12): [True: 219, False: 527]
  ------------------
 3029|    219|        {
 3030|    219|            compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, node->file, node->line,
 3031|    219|                               "texture_source requires a type value");
 3032|    219|            return;
 3033|    219|        }
 3034|       |
 3035|       |        // Set the value of the source
 3036|    527|        ExternalTextureSourceManager::getSingleton().setCurrentPlugIn(obj->values.front()->getValue());
 3037|       |
 3038|    527|        if (!ExternalTextureSourceManager::getSingleton().getCurrentPlugIn())
  ------------------
  |  Branch (3038:13): [True: 527, False: 0]
  ------------------
 3039|    527|        {
 3040|    527|            compiler->addError(ScriptCompiler::CE_REFERENCETOANONEXISTINGOBJECT, node->file, node->line,
 3041|    527|                               obj->values.front()->getValue());
 3042|    527|            return;
 3043|    527|        }
 3044|       |
 3045|       |        // Set up the technique, pass, and texunit levels
 3046|      0|        TextureUnitState *texunit = any_cast<TextureUnitState*>(obj->parent->context);
 3047|      0|        Pass *pass = texunit->getParent();
 3048|      0|        Technique *technique = pass->getParent();
 3049|      0|        Material *material = technique->getParent();
 3050|       |
 3051|      0|        unsigned short techniqueIndex = 0, passIndex = 0, texUnitIndex = 0;
 3052|      0|        for(unsigned short i = 0; i < material->getNumTechniques(); i++)
  ------------------
  |  Branch (3052:35): [True: 0, False: 0]
  ------------------
 3053|      0|        {
 3054|      0|            if(material->getTechnique(i) == technique)
  ------------------
  |  Branch (3054:16): [True: 0, False: 0]
  ------------------
 3055|      0|            {
 3056|      0|                techniqueIndex = i;
 3057|      0|                break;
 3058|      0|            }
 3059|      0|        }
 3060|      0|        for(unsigned short i = 0; i < technique->getNumPasses(); i++)
  ------------------
  |  Branch (3060:35): [True: 0, False: 0]
  ------------------
 3061|      0|        {
 3062|      0|            if(technique->getPass(i) == pass)
  ------------------
  |  Branch (3062:16): [True: 0, False: 0]
  ------------------
 3063|      0|            {
 3064|      0|                passIndex = i;
 3065|      0|                break;
 3066|      0|            }
 3067|      0|        }
 3068|      0|        for(unsigned short i = 0; i < pass->getNumTextureUnitStates(); i++)
  ------------------
  |  Branch (3068:35): [True: 0, False: 0]
  ------------------
 3069|      0|        {
 3070|      0|            if(pass->getTextureUnitState(i) == texunit)
  ------------------
  |  Branch (3070:16): [True: 0, False: 0]
  ------------------
 3071|      0|            {
 3072|      0|                texUnitIndex = i;
 3073|      0|                break;
 3074|      0|            }
 3075|      0|        }
 3076|       |
 3077|      0|        String tps;
 3078|      0|        tps = StringConverter::toString(techniqueIndex) + " "
 3079|      0|            + StringConverter::toString(passIndex) + " "
 3080|      0|            + StringConverter::toString(texUnitIndex);
 3081|       |
 3082|      0|        ExternalTextureSourceManager::getSingleton().getCurrentPlugIn()->setParameter( "set_T_P_S", tps );
 3083|       |
 3084|      0|        for(auto & i : obj->children)
  ------------------
  |  Branch (3084:22): [True: 0, False: 0]
  ------------------
 3085|      0|        {
 3086|      0|            if(i->type == ANT_PROPERTY)
  ------------------
  |  Branch (3086:16): [True: 0, False: 0]
  ------------------
 3087|      0|            {
 3088|      0|                auto prop = i->getProperty();
 3089|       |                // Glob the property values all together
 3090|      0|                String str = StringConverter::toString(prop.values);
 3091|      0|                ExternalTextureSourceManager::getSingleton().getCurrentPlugIn()->setParameter(prop.name, str);
 3092|      0|            }
 3093|      0|            else if(i->type == ANT_OBJECT)
  ------------------
  |  Branch (3093:21): [True: 0, False: 0]
  ------------------
 3094|      0|            {
 3095|      0|                processNode(compiler, i);
 3096|      0|            }
 3097|      0|        }
 3098|       |
 3099|      0|        ExternalTextureSourceManager::getSingleton().getCurrentPlugIn()->createDefinedTexture(material->getName(), material->getGroup());
 3100|      0|    }
_ZN4Ogre20GpuProgramTranslatorC2Ev:
 3106|      1|    {
 3107|      1|    }
_ZN4Ogre20GpuProgramTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE:
 3110|  16.4k|    {
 3111|  16.4k|        ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(node.get());
 3112|       |
 3113|       |        // Must have a name
 3114|  16.4k|        if(obj->name.empty())
  ------------------
  |  Branch (3114:12): [True: 339, False: 16.1k]
  ------------------
 3115|    339|        {
 3116|    339|            compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line,
 3117|    339|                               "gpu program object must have names");
 3118|    339|            return;
 3119|    339|        }
 3120|       |
 3121|       |        // Must have a language type
 3122|  16.1k|        if(obj->values.empty())
  ------------------
  |  Branch (3122:12): [True: 8.68k, False: 7.43k]
  ------------------
 3123|  8.68k|        {
 3124|  8.68k|            compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, obj->file, obj->line,
 3125|  8.68k|                               "gpu program object require language declarations");
 3126|  8.68k|            return;
 3127|  8.68k|        }
 3128|       |
 3129|       |        // Get the language
 3130|  7.43k|        String language;
 3131|  7.43k|        for(const auto& lnode : obj->values)
  ------------------
  |  Branch (3131:31): [True: 77.6k, False: 5.72k]
  ------------------
 3132|  77.6k|        {
 3133|  77.6k|            if(!getString(lnode, &language))
  ------------------
  |  Branch (3133:16): [True: 0, False: 77.6k]
  ------------------
 3134|      0|            {
 3135|      0|                compiler->addError(*obj);
 3136|      0|                return;
 3137|      0|            }
 3138|       |
 3139|  77.6k|            if (language == "asm")
  ------------------
  |  Branch (3139:17): [True: 742, False: 76.9k]
  ------------------
 3140|    742|            {
 3141|    742|                compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, obj->file, obj->line, "asm. Use syntax code.");
 3142|    742|                break; // always supported
 3143|    742|            }
 3144|  76.9k|            if (GpuProgramManager::getSingleton().isLanguageSupported(language))
  ------------------
  |  Branch (3144:17): [True: 969, False: 75.9k]
  ------------------
 3145|    969|                break;
 3146|  76.9k|        }
 3147|       |
 3148|  7.43k|        translateGpuProgram(compiler, obj, language);
 3149|  7.43k|    }
_ZN4Ogre20GpuProgramTranslator19translateGpuProgramEPNS_14ScriptCompilerEPNS_18ObjectAbstractNodeENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE:
 3152|  7.43k|    {
 3153|  7.43k|        String syntax;
 3154|  7.43k|        std::vector<String> delegates;
 3155|  7.43k|        std::vector<std::pair<PropertyAbstractNode*, String> > customParameters;
 3156|  7.43k|        String source, profiles, target;
 3157|  7.43k|        AbstractNodePtr params;
 3158|  7.43k|        for(auto & i : obj->children)
  ------------------
  |  Branch (3158:22): [True: 102k, False: 3.97k]
  ------------------
 3159|   102k|        {
 3160|   102k|            if(i->type == ANT_PROPERTY)
  ------------------
  |  Branch (3160:16): [True: 84.7k, False: 17.3k]
  ------------------
 3161|  84.7k|            {
 3162|  84.7k|                PropertyAbstractNode *prop = (PropertyAbstractNode*)i.get();
 3163|  84.7k|                if(prop->id == ID_SOURCE)
  ------------------
  |  Branch (3163:20): [True: 4.63k, False: 80.1k]
  ------------------
 3164|  4.63k|                {
 3165|  4.63k|                    if(!getValue(prop, compiler, source))
  ------------------
  |  Branch (3165:24): [True: 1.17k, False: 3.46k]
  ------------------
 3166|  1.17k|                        return;
 3167|  4.63k|                }
 3168|  80.1k|                else if(prop->name == "delegate")
  ------------------
  |  Branch (3168:25): [True: 13.2k, False: 66.8k]
  ------------------
 3169|  13.2k|                {
 3170|  13.2k|                    String value;
 3171|  13.2k|                    if(!getValue(prop, compiler, value))
  ------------------
  |  Branch (3171:24): [True: 2.28k, False: 10.9k]
  ------------------
 3172|  2.28k|                        return;
 3173|       |
 3174|  10.9k|                    String name = processResourceName(compiler, ResourceType::GPU_PROGRAM, value);
 3175|       |
 3176|  10.9k|                    if (name == obj->name)
  ------------------
  |  Branch (3176:25): [True: 407, False: 10.5k]
  ------------------
 3177|    407|                    {
 3178|    407|                        compiler->addError(*prop, "cannot be a delegate of itself");
 3179|    407|                        continue;
 3180|    407|                    }
 3181|       |
 3182|  10.5k|                    delegates.push_back(name);
 3183|  10.5k|                }
 3184|  66.8k|                else
 3185|  66.8k|                {
 3186|  66.8k|                    StringVector values;
 3187|  66.8k|                    _getVector(prop->values.begin(), prop->values.end(), values, prop->values.size());
 3188|       |
 3189|  66.8k|                    if(prop->name == "attach")
  ------------------
  |  Branch (3189:24): [True: 1.94k, False: 64.8k]
  ------------------
 3190|  1.94k|                    {
 3191|  1.94k|                        compiler->addError(*prop, "attach. Use the #include directive instead",
 3192|  1.94k|                                           ScriptCompiler::CE_DEPRECATEDSYMBOL);
 3193|       |
 3194|  1.94k|                        processResourceNames(compiler, ResourceType::GPU_PROGRAM, values);
 3195|  1.94k|                    }
 3196|       |
 3197|  66.8k|                    String value = StringConverter::toString(values);
 3198|       |
 3199|  66.8k|                    if(prop->name == "profiles")
  ------------------
  |  Branch (3199:24): [True: 1.21k, False: 65.6k]
  ------------------
 3200|  1.21k|                        profiles = value;
 3201|  65.6k|                    else if(prop->name == "target")
  ------------------
  |  Branch (3201:29): [True: 1.62k, False: 63.9k]
  ------------------
 3202|  1.62k|                        target = value;
 3203|  63.9k|                    else if(prop->id == ID_SYNTAX && language == "asm")
  ------------------
  |  Branch (3203:29): [True: 1.53k, False: 62.4k]
  |  Branch (3203:54): [True: 495, False: 1.03k]
  ------------------
 3204|    495|                        syntax = value;
 3205|  63.4k|                    else
 3206|  63.4k|                        customParameters.push_back(std::make_pair(prop, value));
 3207|  66.8k|                }
 3208|  84.7k|            }
 3209|  17.3k|            else if(i->type == ANT_OBJECT)
  ------------------
  |  Branch (3209:21): [True: 4.68k, False: 12.6k]
  ------------------
 3210|  4.68k|            {
 3211|  4.68k|                if(((ObjectAbstractNode*)i.get())->id == ID_DEFAULT_PARAMS)
  ------------------
  |  Branch (3211:20): [True: 699, False: 3.98k]
  ------------------
 3212|    699|                    params = i;
 3213|  3.98k|                else
 3214|  3.98k|                    processNode(compiler, i);
 3215|  4.68k|            }
 3216|   102k|        }
 3217|       |
 3218|       |        // Allocate the program
 3219|  3.97k|        GpuProgramType gpt = getProgramType(obj->id);
 3220|  3.97k|        GpuProgram *prog = 0;
 3221|       |
 3222|  3.97k|        if(language == "asm")
  ------------------
  |  Branch (3222:12): [True: 57, False: 3.91k]
  ------------------
 3223|     57|            language = syntax;
 3224|  3.97k|        CreateGpuProgramScriptCompilerEvent evt(obj->file, obj->name, compiler->getResourceGroup(), source,
 3225|  3.97k|                                                language, gpt);
 3226|  3.97k|        bool processed = compiler->_fireEvent(&evt, &prog);
 3227|       |
 3228|  3.97k|        if(!processed)
  ------------------
  |  Branch (3228:12): [True: 3.71k, False: 257]
  ------------------
 3229|  3.71k|        {
 3230|  3.71k|            prog = GpuProgramManager::getSingleton().create(obj->name, compiler->getResourceGroup(), gpt, language).get();
 3231|       |
 3232|  3.71k|            if (source.empty() && language != "unified")
  ------------------
  |  Branch (3232:17): [True: 2.36k, False: 1.35k]
  |  Branch (3232:35): [True: 1.79k, False: 573]
  ------------------
 3233|  1.79k|            {
 3234|  1.79k|                compiler->addError(*obj, "No 'source' provided for GPU program");
 3235|  1.79k|                return;
 3236|  1.79k|            }
 3237|       |
 3238|  1.92k|            if(prog && !source.empty()) // prog=0 if duplicate definition resolved by "use previous"
  ------------------
  |  Branch (3238:16): [True: 1.71k, False: 205]
  |  Branch (3238:24): [True: 1.14k, False: 573]
  ------------------
 3239|  1.14k|                prog->setSourceFile(source);
 3240|  1.92k|        }
 3241|       |
 3242|  2.18k|        if(!prog)
  ------------------
  |  Branch (3242:12): [True: 0, False: 2.18k]
  ------------------
 3243|      0|        {
 3244|      0|            compiler->addError(ScriptCompiler::CE_OBJECTALLOCATIONERROR, obj->file, obj->line, obj->name);
 3245|      0|            return;
 3246|      0|        }
 3247|       |
 3248|  2.18k|        obj->context = prog;
 3249|       |
 3250|  2.18k|        prog->setMorphAnimationIncluded(false);
 3251|  2.18k|        prog->setPoseAnimationIncluded(0);
 3252|  2.18k|        prog->setSkeletalAnimationIncluded(false);
 3253|  2.18k|        prog->setVertexTextureFetchRequired(false);
 3254|  2.18k|        prog->_notifyOrigin(obj->file);
 3255|       |
 3256|       |        // special case for Cg
 3257|  2.18k|        if(!profiles.empty())
  ------------------
  |  Branch (3257:12): [True: 229, False: 1.95k]
  ------------------
 3258|    229|            prog->setParameter("profiles", profiles);
 3259|       |
 3260|       |        // special case for HLSL
 3261|  2.18k|        if(!target.empty())
  ------------------
  |  Branch (3261:12): [True: 499, False: 1.68k]
  ------------------
 3262|    499|            prog->setParameter("target", target);
 3263|       |
 3264|       |        // special case for unified
 3265|  2.18k|        for(const auto& d : delegates)
  ------------------
  |  Branch (3265:27): [True: 8.34k, False: 2.18k]
  ------------------
 3266|  8.34k|            prog->setParameter("delegate", d);
 3267|       |
 3268|       |        // Set the custom parameters
 3269|  2.18k|        for(const auto& p : customParameters)
  ------------------
  |  Branch (3269:27): [True: 8.48k, False: 2.18k]
  ------------------
 3270|  8.48k|        {
 3271|  8.48k|            if(prog->isSupported() && !prog->setParameter(p.first->name, p.second))
  ------------------
  |  Branch (3271:16): [True: 0, False: 8.48k]
  |  Branch (3271:39): [True: 0, False: 0]
  ------------------
 3272|      0|            {
 3273|      0|                compiler->addError(*p.first, p.first->name);
 3274|      0|            }
 3275|  8.48k|        }
 3276|       |
 3277|       |        // Set up default parameters
 3278|  2.18k|        if(prog->isSupported() && params)
  ------------------
  |  Branch (3278:12): [True: 0, False: 2.18k]
  |  Branch (3278:35): [True: 0, False: 0]
  ------------------
 3279|      0|        {
 3280|      0|            GpuProgramParametersSharedPtr ptr = prog->getDefaultParameters();
 3281|       |
 3282|      0|            if(prog->hasCompileError())
  ------------------
  |  Branch (3282:16): [True: 0, False: 0]
  ------------------
 3283|      0|                return;
 3284|       |
 3285|      0|            GpuProgramTranslator::translateProgramParameters(compiler, ptr, static_cast<ObjectAbstractNode*>(params.get()));
 3286|      0|        }
 3287|  2.18k|    }
_ZN4Ogre22SharedParamsTranslatorC2Ev:
 3773|      1|    {
 3774|      1|    }
_ZN4Ogre22SharedParamsTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE:
 3778|  1.36k|    {
 3779|  1.36k|        ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(node.get());
 3780|       |
 3781|       |        // Must have a name
 3782|  1.36k|        if (obj->name.empty())
  ------------------
  |  Branch (3782:13): [True: 200, False: 1.16k]
  ------------------
 3783|    200|        {
 3784|    200|            compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line);
 3785|    200|            return;
 3786|    200|        }
 3787|       |
 3788|  1.16k|        GpuSharedParameters* sharedParams = 0;
 3789|  1.16k|        CreateGpuSharedParametersScriptCompilerEvent evt(obj->file, obj->name, compiler->getResourceGroup());
 3790|  1.16k|        bool processed = compiler->_fireEvent(&evt, (void*)&sharedParams);
 3791|       |
 3792|  1.16k|        if (!processed)
  ------------------
  |  Branch (3792:13): [True: 1.16k, False: 0]
  ------------------
 3793|  1.16k|        {
 3794|  1.16k|            sharedParams = GpuProgramManager::getSingleton().createSharedParameters(obj->name).get();
 3795|  1.16k|        }
 3796|       |
 3797|  1.16k|        if (!sharedParams)
  ------------------
  |  Branch (3797:13): [True: 0, False: 1.16k]
  ------------------
 3798|      0|        {
 3799|      0|            compiler->addError(ScriptCompiler::CE_OBJECTALLOCATIONERROR, obj->file, obj->line, obj->name);
 3800|      0|            return;
 3801|      0|        }
 3802|       |
 3803|  1.16k|        for (auto & i : obj->children)
  ------------------
  |  Branch (3803:23): [True: 32.5k, False: 1.16k]
  ------------------
 3804|  32.5k|        {
 3805|  32.5k|            if (i->type != ANT_PROPERTY)
  ------------------
  |  Branch (3805:17): [True: 5.38k, False: 27.1k]
  ------------------
 3806|  5.38k|                continue;
 3807|       |
 3808|  27.1k|            PropertyAbstractNode *prop = static_cast<PropertyAbstractNode*>(i.get());
 3809|  27.1k|            if (prop->id != ID_SHARED_PARAM_NAMED && prop->id != ID_PARAM_NAMED)
  ------------------
  |  Branch (3809:17): [True: 26.8k, False: 290]
  |  Branch (3809:54): [True: 12.8k, False: 13.9k]
  ------------------
 3810|  12.8k|            {
 3811|  12.8k|                compiler->addError(*prop, prop->name);
 3812|  12.8k|                continue;
 3813|  12.8k|            }
 3814|       |
 3815|  14.2k|            if(prop->id == ID_SHARED_PARAM_NAMED)
  ------------------
  |  Branch (3815:16): [True: 290, False: 13.9k]
  ------------------
 3816|    290|            {
 3817|    290|                compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line,
 3818|    290|                                   "shared_param_named is deprecated. Use param_named instead");
 3819|    290|            }
 3820|       |
 3821|  14.2k|            if (prop->values.size() < 2)
  ------------------
  |  Branch (3821:17): [True: 516, False: 13.7k]
  ------------------
 3822|    516|            {
 3823|    516|                compiler->addError(*prop, prop->name + " - expected 2 or more arguments");
 3824|    516|                continue;
 3825|    516|            }
 3826|       |
 3827|  13.7k|            AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1);
 3828|       |
 3829|  13.7k|            String pName;
 3830|  13.7k|            GpuConstantType constType;
 3831|       |
 3832|  13.7k|            if (!getValue(*i0, pName) || !getConstantType(i1, &constType))
  ------------------
  |  Branch (3832:17): [True: 1, False: 13.7k]
  |  Branch (3832:42): [True: 6.67k, False: 7.08k]
  ------------------
 3833|  6.67k|            {
 3834|  6.67k|                compiler->addError(*prop, "name and parameter type expected");
 3835|  6.67k|                continue;
 3836|  6.67k|            }
 3837|       |
 3838|  7.08k|            AbstractNodeList::const_iterator arrayStart = getNodeAt(prop->values, 2), arrayEnd = prop->values.end();
 3839|  7.08k|            uint32 arraySz = 1;
 3840|       |
 3841|  7.08k|            if (arrayStart != arrayEnd)
  ------------------
  |  Branch (3841:17): [True: 4.25k, False: 2.83k]
  ------------------
 3842|  4.25k|            {
 3843|  4.25k|                String value;
 3844|  4.25k|                getValue(*arrayStart, value);
 3845|       |
 3846|  4.25k|                if (value.front() == '[' && value.back() == ']')
  ------------------
  |  Branch (3846:21): [True: 1.39k, False: 2.86k]
  |  Branch (3846:45): [True: 958, False: 433]
  ------------------
 3847|    958|                {
 3848|    958|                    arraySz = StringConverter::parseInt(value.substr(1, value.size() - 2), 0);
 3849|    958|                    if(!arraySz)
  ------------------
  |  Branch (3849:24): [True: 429, False: 529]
  ------------------
 3850|    429|                    {
 3851|    429|                        compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line,
 3852|    429|                                           "invalid array size");
 3853|    429|                        continue;
 3854|    429|                    }
 3855|    529|                    arrayStart++;
 3856|    529|                }
 3857|  4.25k|            }
 3858|       |
 3859|       |            // Look up the auto constant - if the next token is a known auto constant name,
 3860|       |            // the parameter is driven automatically instead of by literal values
 3861|  6.65k|            const GpuProgramParameters::AutoConstantDefinition* autoDef = NULL;
 3862|  6.65k|            if (arrayStart != arrayEnd && (*arrayStart)->type == ANT_ATOM)
  ------------------
  |  Branch (3862:17): [True: 3.78k, False: 2.87k]
  |  Branch (3862:43): [True: 3.62k, False: 159]
  ------------------
 3863|  3.62k|            {
 3864|  3.62k|                String acName = static_cast<AtomAbstractNode*>(arrayStart->get())->value;
 3865|  3.62k|                StringUtil::toLowerCase(acName);
 3866|  3.62k|                autoDef = GpuProgramParameters::getAutoConstantDefinition(acName);
 3867|  3.62k|            }
 3868|       |
 3869|       |            // define constant entry
 3870|  6.65k|            try
 3871|  6.65k|            {
 3872|  6.65k|                sharedParams->addConstantDefinition(pName, constType, arraySz);
 3873|       |
 3874|  6.65k|                if(autoDef)
  ------------------
  |  Branch (3874:20): [True: 81, False: 6.57k]
  ------------------
 3875|     81|                {
 3876|     81|                    sharedParams->setAutoConstant(pName, autoDef->acType);
 3877|     81|                    arrayStart++;
 3878|     81|                }
 3879|  6.65k|            }
 3880|  6.65k|            catch(Exception& e)
 3881|  6.65k|            {
 3882|  5.15k|                compiler->addError(*prop, e.getDescription());
 3883|  5.15k|                continue;
 3884|  5.15k|            }
 3885|       |
 3886|  1.49k|            if (autoDef && arrayStart != arrayEnd)
  ------------------
  |  Branch (3886:17): [True: 81, False: 1.41k]
  |  Branch (3886:28): [True: 70, False: 11]
  ------------------
 3887|     70|            {
 3888|     70|                compiler->addError(*prop, "unexpected extra parameters after auto constant name");
 3889|     70|            }
 3890|       |
 3891|       |            // amount of individual numbers to read
 3892|  1.49k|            arraySz *= GpuConstantDefinition::getElementSize(constType, false);
 3893|       |
 3894|  1.49k|            switch (GpuConstantDefinition::getBaseType(constType))
 3895|  1.49k|            {
 3896|    446|            case BCT_FLOAT:
  ------------------
  |  Branch (3896:13): [True: 446, False: 1.05k]
  ------------------
 3897|    446|            {
 3898|    446|                std::vector<float> values;
 3899|    446|                if(_getVector(arrayStart, arrayEnd, values, arraySz))
  ------------------
  |  Branch (3899:20): [True: 156, False: 290]
  ------------------
 3900|    156|                    sharedParams->setNamedConstant(pName, &values[0], arraySz);
 3901|    290|                else
 3902|    290|                    compiler->addError(*prop);
 3903|    446|                break;
 3904|      0|            }
 3905|    916|            case BCT_INT:
  ------------------
  |  Branch (3905:13): [True: 916, False: 583]
  ------------------
 3906|    916|            {
 3907|    916|                std::vector<int> values;
 3908|    916|                if(_getVector(arrayStart, arrayEnd, values, arraySz))
  ------------------
  |  Branch (3908:20): [True: 663, False: 253]
  ------------------
 3909|    663|                    sharedParams->setNamedConstant(pName, &values[0], arraySz);
 3910|    253|                else
 3911|    253|                    compiler->addError(*prop);
 3912|    916|                break;
 3913|      0|            }
 3914|     30|            case BCT_DOUBLE:
  ------------------
  |  Branch (3914:13): [True: 30, False: 1.46k]
  ------------------
 3915|     30|            {
 3916|     30|                std::vector<double> values;
 3917|     30|                if(_getVector(arrayStart, arrayEnd, values, arraySz))
  ------------------
  |  Branch (3917:20): [True: 26, False: 4]
  ------------------
 3918|     26|                    sharedParams->setNamedConstant(pName, &values[0], arraySz);
 3919|      4|                else
 3920|      4|                    compiler->addError(*prop);
 3921|     30|                break;
 3922|      0|            }
 3923|    107|            case BCT_UINT:
  ------------------
  |  Branch (3923:13): [True: 107, False: 1.39k]
  ------------------
 3924|    107|            {
 3925|    107|                std::vector<uint> values;
 3926|    107|                if(_getVector(arrayStart, arrayEnd, values, arraySz))
  ------------------
  |  Branch (3926:20): [True: 34, False: 73]
  ------------------
 3927|     34|                {
 3928|     34|                    sharedParams->setNamedConstant(pName, &values[0], arraySz);
 3929|     34|                }
 3930|     73|                else
 3931|     73|                    compiler->addError(*prop);
 3932|    107|                break;
 3933|      0|            }
 3934|      0|            case BCT_BOOL:
  ------------------
  |  Branch (3934:13): [True: 0, False: 1.49k]
  ------------------
 3935|      0|            {
 3936|      0|                compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line,
 3937|      0|                                   "bool. Use uint instead");
 3938|      0|                std::vector<bool> tmp;
 3939|      0|                if(_getVector(arrayStart, arrayEnd, tmp, arraySz))
  ------------------
  |  Branch (3939:20): [True: 0, False: 0]
  ------------------
 3940|      0|                {
 3941|      0|                    std::vector<uint> values(tmp.begin(), tmp.end());
 3942|      0|                    sharedParams->setNamedConstant(pName, &values[0], arraySz);
 3943|      0|                }
 3944|      0|                else
 3945|      0|                    compiler->addError(*prop);
 3946|      0|                break;
 3947|      0|            }
 3948|      0|            default:
  ------------------
  |  Branch (3948:13): [True: 0, False: 1.49k]
  ------------------
 3949|      0|                compiler->addError(*prop, "invalid parameter type");
 3950|      0|                break;
 3951|  1.49k|            }
 3952|  1.49k|        }
 3953|  1.16k|    }
_ZN4Ogre24ParticleSystemTranslatorC2Ev:
 3959|      1|        :mSystem(0)
 3960|      1|    {
 3961|      1|    }
_ZN4Ogre24ParticleSystemTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE:
 3964|     98|    {
 3965|     98|        ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(node.get());
 3966|       |        // Find the name
 3967|     98|        if(obj->name.empty())
  ------------------
  |  Branch (3967:12): [True: 84, False: 14]
  ------------------
 3968|     84|        {
 3969|     84|            compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line);
 3970|     84|            return;
 3971|     84|        }
 3972|       |
 3973|       |        // Allocate the particle system
 3974|     14|        CreateParticleSystemScriptCompilerEvent evt(obj->file, obj->name, compiler->getResourceGroup());
 3975|     14|        bool processed = compiler->_fireEvent(&evt, (void*)&mSystem);
 3976|       |
 3977|     14|        if(!processed)
  ------------------
  |  Branch (3977:12): [True: 14, False: 0]
  ------------------
 3978|     14|        {
 3979|     14|            mSystem = ParticleSystemManager::getSingleton().createTemplate(obj->name, compiler->getResourceGroup());
 3980|     14|        }
 3981|       |
 3982|     14|        if(!mSystem)
  ------------------
  |  Branch (3982:12): [True: 0, False: 14]
  ------------------
 3983|      0|        {
 3984|      0|            compiler->addError(ScriptCompiler::CE_OBJECTALLOCATIONERROR, obj->file, obj->line, obj->name);
 3985|      0|            return;
 3986|      0|        }
 3987|       |
 3988|     14|        mSystem->_notifyOrigin(obj->file);
 3989|       |
 3990|     14|        mSystem->removeAllEmitters();
 3991|     14|        mSystem->removeAllAffectors();
 3992|       |
 3993|     14|        obj->context = mSystem;
 3994|       |
 3995|     14|        for(auto & i : obj->children)
  ------------------
  |  Branch (3995:22): [True: 0, False: 14]
  ------------------
 3996|      0|        {
 3997|      0|            if(i->type == ANT_PROPERTY)
  ------------------
  |  Branch (3997:16): [True: 0, False: 0]
  ------------------
 3998|      0|            {
 3999|      0|                auto prop = i->getProperty();
 4000|      0|                if(prop.values.empty())
  ------------------
  |  Branch (4000:20): [True: 0, False: 0]
  ------------------
 4001|      0|                {
 4002|      0|                    compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, i->file, i->line);
 4003|      0|                    return;
 4004|      0|                }
 4005|       |
 4006|      0|                String value;
 4007|      0|                if(static_cast<PropertyAbstractNode*>(i.get())->id == ID_MATERIAL)
  ------------------
  |  Branch (4007:20): [True: 0, False: 0]
  ------------------
 4008|      0|                {
 4009|      0|                    value = processResourceName(compiler, ResourceType::MATERIAL, prop.values.front());
 4010|      0|                }
 4011|      0|                else
 4012|      0|                {
 4013|      0|                    value = StringConverter::toString(prop.values);
 4014|      0|                }
 4015|       |
 4016|      0|                if(!mSystem->setParameter(prop.name, value))
  ------------------
  |  Branch (4016:20): [True: 0, False: 0]
  ------------------
 4017|      0|                {
 4018|      0|                    if(auto renderer = mSystem->getRenderer())
  ------------------
  |  Branch (4018:29): [True: 0, False: 0]
  ------------------
 4019|      0|                    {
 4020|      0|                        if(!renderer->setParameter(prop.name, value))
  ------------------
  |  Branch (4020:28): [True: 0, False: 0]
  ------------------
 4021|      0|                            compiler->addError(*i);
 4022|      0|                    }
 4023|      0|                }
 4024|      0|            }
 4025|      0|            else
 4026|      0|            {
 4027|      0|                processNode(compiler, i);
 4028|      0|            }
 4029|      0|        }
 4030|     14|    }
_ZN4Ogre25ParticleEmitterTranslatorC2Ev:
 4036|      1|        :mEmitter(0)
 4037|      1|    {
 4038|      1|    }
_ZN4Ogre26ParticleAffectorTranslatorC2Ev:
 4084|      1|        :mAffector(0)
 4085|      1|    {
 4086|      1|    }
_ZN4Ogre20CompositorTranslatorC2Ev:
 4131|      1|        :mCompositor(0)
 4132|      1|    {
 4133|      1|    }
_ZN4Ogre20CompositorTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE:
 4136|  2.71k|    {
 4137|  2.71k|        ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(node.get());
 4138|  2.71k|        if(obj->name.empty())
  ------------------
  |  Branch (4138:12): [True: 386, False: 2.32k]
  ------------------
 4139|    386|        {
 4140|    386|            compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line);
 4141|    386|            return;
 4142|    386|        }
 4143|       |
 4144|       |        // Create the compositor
 4145|  2.32k|        CreateCompositorScriptCompilerEvent evt(obj->file, obj->name, compiler->getResourceGroup());
 4146|  2.32k|        bool processed = compiler->_fireEvent(&evt, (void*)&mCompositor);
 4147|       |
 4148|  2.32k|        if(!processed)
  ------------------
  |  Branch (4148:12): [True: 2.32k, False: 0]
  ------------------
 4149|  2.32k|        {
 4150|  2.32k|            mCompositor = CompositorManager::getSingleton().create(obj->name, compiler->getResourceGroup()).get();
 4151|  2.32k|        }
 4152|       |
 4153|  2.32k|        if(!mCompositor)
  ------------------
  |  Branch (4153:12): [True: 0, False: 2.32k]
  ------------------
 4154|      0|        {
 4155|      0|            compiler->addError(ScriptCompiler::CE_OBJECTALLOCATIONERROR, obj->file, obj->line, obj->name);
 4156|      0|            return;
 4157|      0|        }
 4158|       |
 4159|       |        // Prepare the compositor
 4160|  2.32k|        mCompositor->removeAllTechniques();
 4161|  2.32k|        mCompositor->_notifyOrigin(obj->file);
 4162|  2.32k|        obj->context = mCompositor;
 4163|       |
 4164|  2.32k|        for(auto & i : obj->children)
  ------------------
  |  Branch (4164:22): [True: 19.0k, False: 2.32k]
  ------------------
 4165|  19.0k|        {
 4166|  19.0k|            if(i->type == ANT_OBJECT)
  ------------------
  |  Branch (4166:16): [True: 8.64k, False: 10.3k]
  ------------------
 4167|  8.64k|            {
 4168|  8.64k|                processNode(compiler, i);
 4169|  8.64k|            }
 4170|  10.3k|            else
 4171|  10.3k|            {
 4172|  10.3k|                compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, i->file, i->line,
 4173|  10.3k|                                   "token not recognized");
 4174|  10.3k|            }
 4175|  19.0k|        }
 4176|  2.32k|    }
_ZN4Ogre30CompositionTechniqueTranslatorC2Ev:
 4182|      1|        :mTechnique(0)
 4183|      1|    {
 4184|      1|    }
_ZN4Ogre30CompositionTechniqueTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE:
 4187|  7.17k|    {
 4188|  7.17k|        ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(node.get());
 4189|       |
 4190|  7.17k|        Compositor *compositor = any_cast<Compositor*>(obj->parent->context);
 4191|  7.17k|        mTechnique = compositor->createTechnique();
 4192|  7.17k|        obj->context = mTechnique;
 4193|       |
 4194|  7.17k|        String sval;
 4195|  7.17k|        uint32 uival;
 4196|       |
 4197|  7.17k|        for(auto & i : obj->children)
  ------------------
  |  Branch (4197:22): [True: 63.5k, False: 5.68k]
  ------------------
 4198|  63.5k|        {
 4199|  63.5k|            if(i->type == ANT_OBJECT)
  ------------------
  |  Branch (4199:16): [True: 26.3k, False: 37.1k]
  ------------------
 4200|  26.3k|            {
 4201|  26.3k|                processNode(compiler, i);
 4202|  26.3k|            }
 4203|  37.1k|            else if(i->type == ANT_PROPERTY)
  ------------------
  |  Branch (4203:21): [True: 28.2k, False: 8.96k]
  ------------------
 4204|  28.2k|            {
 4205|  28.2k|                PropertyAbstractNode *prop = static_cast<PropertyAbstractNode*>(i.get());
 4206|  28.2k|                switch(prop->id)
 4207|  28.2k|                {
 4208|  8.04k|                case ID_TEXTURE:
  ------------------
  |  Branch (4208:17): [True: 8.04k, False: 20.1k]
  ------------------
 4209|  8.04k|                    {
 4210|  8.04k|                        if (prop->values.size() < 4)
  ------------------
  |  Branch (4210:29): [True: 1.00k, False: 7.04k]
  ------------------
 4211|  1.00k|                        {
 4212|  1.00k|                            compiler->addError(*prop, "texture must have at least 4 arguments");
 4213|  1.00k|                            continue;
 4214|  1.00k|                        }
 4215|       |
 4216|       |                        // Save the first atom, should be name
 4217|  7.04k|                        AbstractNodeList::const_iterator it = getNodeAt(prop->values, 0);
 4218|  7.04k|                        const String& name = (*it)->getString();
 4219|       |
 4220|  7.04k|                        if(name.empty())
  ------------------
  |  Branch (4220:28): [True: 278, False: 6.76k]
  ------------------
 4221|    278|                        {
 4222|    278|                            compiler->addError(*prop, "texture name cannot be empty");
 4223|    278|                            continue;
 4224|    278|                        }
 4225|       |
 4226|  6.76k|                        uint32 width = 0, height = 0;
 4227|  6.76k|                        uint32 depth = 1;
 4228|  6.76k|                        float widthFactor = 1.0f, heightFactor = 1.0f;
 4229|  6.76k|                        bool widthSet = false, heightSet = false, formatSet = false;
 4230|  6.76k|                        bool pooled = false;
 4231|  6.76k|                        bool hwGammaWrite = false;
 4232|  6.76k|                        uint32 fsaa = 1;
 4233|  6.76k|                        auto type = TEX_TYPE_2D;
 4234|  6.76k|                        uint16 depthBufferId = RBP_DEFAULT;
 4235|  6.76k|                        CompositionTechnique::TextureScope scope = CompositionTechnique::TS_LOCAL;
 4236|  6.76k|                        Ogre::PixelFormatList formats;
 4237|       |
 4238|  6.76k|                        size_t atomIndex = 1;
 4239|  39.6k|                        while (atomIndex < prop->values.size())
  ------------------
  |  Branch (4239:32): [True: 34.1k, False: 5.55k]
  ------------------
 4240|  34.1k|                        {
 4241|  34.1k|                            it = getNodeAt(prop->values, static_cast<int>(atomIndex++));
 4242|  34.1k|                            if((*it)->type != ANT_ATOM)
  ------------------
  |  Branch (4242:32): [True: 49, False: 34.0k]
  ------------------
 4243|     49|                            {
 4244|     49|                                compiler->addError(*prop);
 4245|     49|                                return;
 4246|     49|                            }
 4247|  34.0k|                            AtomAbstractNode *atom = (AtomAbstractNode*)(*it).get();
 4248|       |
 4249|  34.0k|                            switch(atom->id)
 4250|  34.0k|                            {
 4251|  1.74k|                            case ID_TARGET_WIDTH:
  ------------------
  |  Branch (4251:29): [True: 1.74k, False: 32.3k]
  ------------------
 4252|  1.74k|                                width = 0;
 4253|  1.74k|                                widthSet = true;
 4254|  1.74k|                                break;
 4255|  1.45k|                            case ID_TARGET_HEIGHT:
  ------------------
  |  Branch (4255:29): [True: 1.45k, False: 32.6k]
  ------------------
 4256|  1.45k|                                height = 0;
 4257|  1.45k|                                heightSet = true;
 4258|  1.45k|                                break;
 4259|    862|                            case ID_TARGET_WIDTH_SCALED:
  ------------------
  |  Branch (4259:29): [True: 862, False: 33.2k]
  ------------------
 4260|  1.52k|                            case ID_TARGET_HEIGHT_SCALED:
  ------------------
  |  Branch (4260:29): [True: 661, False: 33.4k]
  ------------------
 4261|  1.52k|                                {
 4262|  1.52k|                                    bool *pSetFlag;
 4263|  1.52k|                                    uint32 *pSize;
 4264|  1.52k|                                    float *pFactor;
 4265|       |
 4266|  1.52k|                                    if (atom->id == ID_TARGET_WIDTH_SCALED)
  ------------------
  |  Branch (4266:41): [True: 862, False: 661]
  ------------------
 4267|    862|                                    {
 4268|    862|                                        pSetFlag = &widthSet;
 4269|    862|                                        pSize = &width;
 4270|    862|                                        pFactor = &widthFactor;
 4271|    862|                                    }
 4272|    661|                                    else
 4273|    661|                                    {
 4274|    661|                                        pSetFlag = &heightSet;
 4275|    661|                                        pSize = &height;
 4276|    661|                                        pFactor = &heightFactor;
 4277|    661|                                    }
 4278|       |                                    // advance to next to get scaling
 4279|  1.52k|                                    it = getNodeAt(prop->values, static_cast<int>(atomIndex++));
 4280|  1.52k|                                    if(prop->values.end() == it || !getValue(*it, *pFactor))
  ------------------
  |  Branch (4280:40): [True: 189, False: 1.33k]
  |  Branch (4280:40): [True: 280, False: 1.24k]
  |  Branch (4280:68): [True: 91, False: 1.24k]
  ------------------
 4281|    280|                                    {
 4282|    280|                                        compiler->addError(*prop);
 4283|    280|                                        return;
 4284|    280|                                    }
 4285|       |
 4286|  1.24k|                                    *pSize = 0;
 4287|  1.24k|                                    *pSetFlag = true;
 4288|  1.24k|                                }
 4289|      0|                                break;
 4290|     73|                            case ID_POOLED:
  ------------------
  |  Branch (4290:29): [True: 73, False: 34.0k]
  ------------------
 4291|     73|                                pooled = true;
 4292|     73|                                break;
 4293|  1.06k|                            case ID_CUBIC:
  ------------------
  |  Branch (4293:29): [True: 1.06k, False: 33.0k]
  ------------------
 4294|  1.06k|                                type = TEX_TYPE_CUBE_MAP;
 4295|  1.06k|                                break;
 4296|      0|                            case ID_2DARRAY:
  ------------------
  |  Branch (4296:29): [True: 0, False: 34.0k]
  ------------------
 4297|      0|                                type = TEX_TYPE_2D_ARRAY;
 4298|      0|                                break;
 4299|      0|                            case ID_2DMS:
  ------------------
  |  Branch (4299:29): [True: 0, False: 34.0k]
  ------------------
 4300|      0|                                type = TEX_TYPE_2D_MULTISAMPLE;
 4301|      0|                                break;
 4302|      0|                            case ID_SCOPE_LOCAL:
  ------------------
  |  Branch (4302:29): [True: 0, False: 34.0k]
  ------------------
 4303|      0|                                scope = CompositionTechnique::TS_LOCAL;
 4304|      0|                                break;
 4305|    392|                            case ID_SCOPE_CHAIN:
  ------------------
  |  Branch (4305:29): [True: 392, False: 33.6k]
  ------------------
 4306|    392|                                scope = CompositionTechnique::TS_CHAIN;
 4307|    392|                                break;
 4308|      0|                            case ID_SCOPE_GLOBAL:
  ------------------
  |  Branch (4308:29): [True: 0, False: 34.0k]
  ------------------
 4309|      0|                                scope = CompositionTechnique::TS_GLOBAL;
 4310|      0|                                break;
 4311|     10|                            case ID_GAMMA:
  ------------------
  |  Branch (4311:29): [True: 10, False: 34.0k]
  ------------------
 4312|     10|                                hwGammaWrite = true;
 4313|     10|                                break;
 4314|  3.58k|                            case ID_NO_FSAA:
  ------------------
  |  Branch (4314:29): [True: 3.58k, False: 30.5k]
  ------------------
 4315|  3.58k|                                fsaa = 0;
 4316|  3.58k|                                break;
 4317|    163|                            case ID_FSAA:
  ------------------
  |  Branch (4317:29): [True: 163, False: 33.9k]
  ------------------
 4318|       |                                // advance to next to get the value
 4319|    163|                                it = getNodeAt(prop->values, atomIndex++);
 4320|    163|                                if(prop->values.end() == it || !getValue(*it, fsaa))
  ------------------
  |  Branch (4320:36): [True: 68, False: 95]
  |  Branch (4320:36): [True: 93, False: 70]
  |  Branch (4320:64): [True: 25, False: 70]
  ------------------
 4321|     93|                                {
 4322|     93|                                    compiler->addError(*prop);
 4323|     93|                                    return;
 4324|     93|                                }
 4325|     70|                                break;
 4326|  6.54k|                            case ID_DEPTH_POOL:
  ------------------
  |  Branch (4326:29): [True: 6.54k, False: 27.5k]
  ------------------
 4327|  6.54k|                                {
 4328|       |                                    // advance to next to get the ID
 4329|  6.54k|                                    it = getNodeAt(prop->values, static_cast<int>(atomIndex++));
 4330|  6.54k|                                    if(prop->values.end() == it || !getValue(*it, uival))
  ------------------
  |  Branch (4330:40): [True: 13, False: 6.52k]
  |  Branch (4330:40): [True: 85, False: 6.45k]
  |  Branch (4330:68): [True: 72, False: 6.45k]
  ------------------
 4331|     85|                                    {
 4332|     85|                                        compiler->addError(*prop);
 4333|     85|                                        return;
 4334|     85|                                    }
 4335|  6.45k|                                    depthBufferId = Math::uint16Cast(uival);
 4336|  6.45k|                                }
 4337|      0|                                break;
 4338|  17.5k|                            default:
  ------------------
  |  Branch (4338:29): [True: 17.5k, False: 16.5k]
  ------------------
 4339|  17.5k|                                if (StringConverter::parse(atom->value, uival))
  ------------------
  |  Branch (4339:37): [True: 8.97k, False: 8.56k]
  ------------------
 4340|  8.97k|                                {
 4341|  8.97k|                                    if (atomIndex == 2)
  ------------------
  |  Branch (4341:41): [True: 4.09k, False: 4.88k]
  ------------------
 4342|  4.09k|                                    {
 4343|  4.09k|                                        width = uival;
 4344|  4.09k|                                        widthSet = true;
 4345|  4.09k|                                    }
 4346|  4.88k|                                    else if (atomIndex == 3)
  ------------------
  |  Branch (4346:46): [True: 4.01k, False: 866]
  ------------------
 4347|  4.01k|                                    {
 4348|  4.01k|                                        height = uival;
 4349|  4.01k|                                        heightSet = true;
 4350|  4.01k|                                    }
 4351|    866|                                    else if (atomIndex == 4)
  ------------------
  |  Branch (4351:46): [True: 819, False: 47]
  ------------------
 4352|    819|                                    {
 4353|    819|                                        depth = uival;
 4354|    819|                                    }
 4355|     47|                                    else
 4356|     47|                                    {
 4357|     47|                                        compiler->addError(*prop);
 4358|     47|                                        return;
 4359|     47|                                    }
 4360|  8.97k|                                }
 4361|  8.56k|                                else
 4362|  8.56k|                                {
 4363|       |                                    // pixel format?
 4364|  8.56k|                                    PixelFormat format = PixelUtil::getFormatFromName(atom->value, true);
 4365|  8.56k|                                    if (format == PF_UNKNOWN)
  ------------------
  |  Branch (4365:41): [True: 649, False: 7.91k]
  ------------------
 4366|    649|                                    {
 4367|    649|                                        compiler->addError(*prop, atom->value);
 4368|    649|                                        return;
 4369|    649|                                    }
 4370|  7.91k|                                    formats.push_back(format);
 4371|  7.91k|                                    formatSet = true;
 4372|  7.91k|                                }
 4373|       |
 4374|  34.0k|                            }
 4375|  34.0k|                        }
 4376|  5.55k|                        if (!widthSet || !heightSet || !formatSet)
  ------------------
  |  Branch (4376:29): [True: 69, False: 5.49k]
  |  Branch (4376:42): [True: 40, False: 5.45k]
  |  Branch (4376:56): [True: 37, False: 5.41k]
  ------------------
 4377|    146|                        {
 4378|    146|                            compiler->addError(*prop, "texture definition must specify width, height, and format");
 4379|    146|                            return;
 4380|    146|                        }
 4381|       |
 4382|  5.41k|                        if(depth != 1 && type != TEX_TYPE_2D_ARRAY)
  ------------------
  |  Branch (4382:28): [True: 128, False: 5.28k]
  |  Branch (4382:42): [True: 128, False: 0]
  ------------------
 4383|    128|                        {
 4384|    128|                            compiler->addError(*prop, "depth only supported for 2d_array textures");
 4385|    128|                            return;
 4386|    128|                        }
 4387|       |
 4388|       |                        // No errors, create
 4389|  5.28k|                        try {
 4390|  5.28k|                            CompositionTechnique::TextureDefinition *def = mTechnique->createTextureDefinition(name);
 4391|  5.28k|                            def->width = width;
 4392|  5.28k|                            def->height = height;
 4393|  5.28k|                            def->depth = depth;
 4394|  5.28k|                            def->type = type;
 4395|  5.28k|                            def->widthFactor = widthFactor;
 4396|  5.28k|                            def->heightFactor = heightFactor;
 4397|  5.28k|                            def->formatList = formats;
 4398|  5.28k|                            def->fsaa = fsaa;
 4399|  5.28k|                            def->hwGammaWrite = hwGammaWrite;
 4400|  5.28k|                            def->depthBufferId = depthBufferId;
 4401|  5.28k|                            def->pooled = pooled;
 4402|  5.28k|                            def->scope = scope;
 4403|  5.28k|                        }
 4404|  5.28k|                        catch (Exception &e)
 4405|  5.28k|                        {
 4406|  3.79k|                            compiler->addError(*prop, e.getDescription());
 4407|  3.79k|                        }
 4408|  5.28k|                    }
 4409|  5.28k|                    break;
 4410|  2.00k|                case ID_TEXTURE_REF:
  ------------------
  |  Branch (4410:17): [True: 2.00k, False: 26.2k]
  ------------------
 4411|  2.00k|                    if(prop->values.empty())
  ------------------
  |  Branch (4411:24): [True: 333, False: 1.66k]
  ------------------
 4412|    333|                    {
 4413|    333|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 4414|    333|                    }
 4415|  1.66k|                    else if(prop->values.size() != 3)
  ------------------
  |  Branch (4415:29): [True: 345, False: 1.32k]
  ------------------
 4416|    345|                    {
 4417|    345|                        compiler->addError(*prop, "texture_ref only supports 3 argument");
 4418|    345|                    }
 4419|  1.32k|                    else
 4420|  1.32k|                    {
 4421|  1.32k|                        String texName, refCompName, refTexName;
 4422|       |
 4423|  1.32k|                        AbstractNodeList::const_iterator it = getNodeAt(prop->values, 0);
 4424|  1.32k|                        if(!getString(*it, &texName))
  ------------------
  |  Branch (4424:28): [True: 6, False: 1.31k]
  ------------------
 4425|      6|                            compiler->addError(*prop, "texture_ref must have 3 string arguments");
 4426|       |
 4427|  1.32k|                        it = getNodeAt(prop->values, 1);
 4428|  1.32k|                        if(!getString(*it, &refCompName))
  ------------------
  |  Branch (4428:28): [True: 91, False: 1.23k]
  ------------------
 4429|     91|                            compiler->addError(*prop, "texture_ref must have 3 string arguments");
 4430|       |
 4431|  1.32k|                        it = getNodeAt(prop->values, 2);
 4432|  1.32k|                        if(!getString(*it, &refTexName))
  ------------------
  |  Branch (4432:28): [True: 610, False: 714]
  ------------------
 4433|    610|                            compiler->addError(*prop, "texture_ref must have 3 string arguments");
 4434|       |
 4435|  1.32k|                        CompositionTechnique::TextureDefinition* refTexDef =
 4436|  1.32k|                            mTechnique->createTextureDefinition(texName);
 4437|       |
 4438|  1.32k|                        refTexDef->refCompName = refCompName;
 4439|  1.32k|                        refTexDef->refTexName = refTexName;
 4440|  1.32k|                    }
 4441|  2.00k|                    break;
 4442|  1.18k|                case ID_SCHEME:
  ------------------
  |  Branch (4442:17): [True: 1.18k, False: 27.0k]
  ------------------
 4443|  1.18k|                    if(getValue(prop, compiler, sval))
  ------------------
  |  Branch (4443:24): [True: 742, False: 440]
  ------------------
 4444|    742|                        mTechnique->setSchemeName(sval);
 4445|  1.18k|                    break;
 4446|  1.00k|                case ID_COMPOSITOR_LOGIC:
  ------------------
  |  Branch (4446:17): [True: 1.00k, False: 27.2k]
  ------------------
 4447|  1.00k|                    if(getValue(prop, compiler, sval))
  ------------------
  |  Branch (4447:24): [True: 648, False: 361]
  ------------------
 4448|    648|                        mTechnique->setCompositorLogicName(sval);
 4449|  1.00k|                    break;
 4450|  15.9k|                default:
  ------------------
  |  Branch (4450:17): [True: 15.9k, False: 12.2k]
  ------------------
 4451|  15.9k|                    compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line,
 4452|  15.9k|                                       "token \"" + prop->name + "\" is not recognized");
 4453|  28.2k|                }
 4454|  28.2k|            }
 4455|  63.5k|        }
 4456|  7.17k|    }
_ZN4Ogre31CompositionTargetPassTranslatorC2Ev:
 4462|      1|        :mTarget(0)
 4463|      1|    {
 4464|      1|    }
_ZN4Ogre31CompositionTargetPassTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE:
 4467|  21.1k|    {
 4468|  21.1k|        ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(node.get());
 4469|       |
 4470|  21.1k|        CompositionTechnique *technique = any_cast<CompositionTechnique*>(obj->parent->context);
 4471|  21.1k|        if(obj->id == ID_TARGET)
  ------------------
  |  Branch (4471:12): [True: 20.4k, False: 731]
  ------------------
 4472|  20.4k|        {
 4473|  20.4k|            mTarget = technique->createTargetPass();
 4474|  20.4k|            if(obj->name.empty())
  ------------------
  |  Branch (4474:16): [True: 169, False: 20.2k]
  ------------------
 4475|    169|            {
 4476|    169|                compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line);
 4477|    169|                return;
 4478|    169|            }
 4479|  20.2k|            mTarget->setOutputName(obj->name);
 4480|       |
 4481|  20.2k|            if(!obj->values.empty())
  ------------------
  |  Branch (4481:16): [True: 18.2k, False: 1.99k]
  ------------------
 4482|  18.2k|            {
 4483|  18.2k|                int val;
 4484|  18.2k|                if(getInt(obj->values.front(), &val))
  ------------------
  |  Branch (4484:20): [True: 17.0k, False: 1.22k]
  ------------------
 4485|  17.0k|                    mTarget->setOutputSlice(val);
 4486|  18.2k|            }
 4487|  20.2k|        }
 4488|    731|        else if(obj->id == ID_TARGET_OUTPUT)
  ------------------
  |  Branch (4488:17): [True: 723, False: 8]
  ------------------
 4489|    723|        {
 4490|    723|            mTarget = technique->getOutputTargetPass();
 4491|    723|            if (!mTarget->getPasses().empty() || mTarget->getInputMode() != CompositionTargetPass::IM_NONE)
  ------------------
  |  Branch (4491:17): [True: 200, False: 523]
  |  Branch (4491:50): [True: 213, False: 310]
  ------------------
 4492|    413|            {
 4493|    413|                compiler->addError(*obj, "target_output can only be used once per technique");
 4494|    413|            }
 4495|    723|        }
 4496|  20.9k|        obj->context = mTarget;
 4497|       |
 4498|  20.9k|        bool bval;
 4499|  20.9k|        Real fval;
 4500|  20.9k|        uint32 uival;
 4501|  20.9k|        String sval;
 4502|       |
 4503|  20.9k|        for(auto & i : obj->children)
  ------------------
  |  Branch (4503:22): [True: 61.4k, False: 20.9k]
  ------------------
 4504|  61.4k|        {
 4505|  61.4k|            if(i->type == ANT_OBJECT)
  ------------------
  |  Branch (4505:16): [True: 25.5k, False: 35.9k]
  ------------------
 4506|  25.5k|            {
 4507|  25.5k|                processNode(compiler, i);
 4508|  25.5k|            }
 4509|  35.9k|            else if(i->type == ANT_PROPERTY)
  ------------------
  |  Branch (4509:21): [True: 25.3k, False: 10.5k]
  ------------------
 4510|  25.3k|            {
 4511|  25.3k|                PropertyAbstractNode *prop = static_cast<PropertyAbstractNode*>(i.get());
 4512|  25.3k|                switch(prop->id)
 4513|  25.3k|                {
 4514|  3.48k|                case ID_INPUT:
  ------------------
  |  Branch (4514:17): [True: 3.48k, False: 21.8k]
  ------------------
 4515|  3.48k|                    CompositionTargetPass::InputMode im;
 4516|  3.48k|                    if(getValue(prop, compiler, im))
  ------------------
  |  Branch (4516:24): [True: 1.77k, False: 1.71k]
  ------------------
 4517|  1.77k|                        mTarget->setInputMode(im);
 4518|  3.48k|                    break;
 4519|    405|                case ID_ONLY_INITIAL:
  ------------------
  |  Branch (4519:17): [True: 405, False: 24.9k]
  ------------------
 4520|    405|                    if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (4520:24): [True: 209, False: 196]
  ------------------
 4521|    209|                        mTarget->setOnlyInitial(bval);
 4522|    405|                    break;
 4523|  2.21k|                case ID_VISIBILITY_MASK:
  ------------------
  |  Branch (4523:17): [True: 2.21k, False: 23.1k]
  ------------------
 4524|  2.21k|                    if(getValue(prop, compiler, uival))
  ------------------
  |  Branch (4524:24): [True: 1.59k, False: 619]
  ------------------
 4525|  1.59k|                        mTarget->setVisibilityMask(uival);
 4526|  2.21k|                    break;
 4527|    611|                case ID_LOD_BIAS:
  ------------------
  |  Branch (4527:17): [True: 611, False: 24.7k]
  ------------------
 4528|    611|                    if(getValue(prop, compiler, fval))
  ------------------
  |  Branch (4528:24): [True: 213, False: 398]
  ------------------
 4529|    213|                        mTarget->setLodBias(fval);
 4530|    611|                    break;
 4531|    999|                case ID_MATERIAL_SCHEME:
  ------------------
  |  Branch (4531:17): [True: 999, False: 24.3k]
  ------------------
 4532|    999|                    if(getValue(prop, compiler, sval))
  ------------------
  |  Branch (4532:24): [True: 725, False: 274]
  ------------------
 4533|    725|                        mTarget->setMaterialScheme(sval);
 4534|    999|                    break;
 4535|    922|                case ID_SHADOWS_ENABLED:
  ------------------
  |  Branch (4535:17): [True: 922, False: 24.4k]
  ------------------
 4536|    922|                    if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (4536:24): [True: 406, False: 516]
  ------------------
 4537|    406|                        mTarget->setShadowsEnabled(bval);
 4538|    922|                    break;
 4539|  16.6k|                default:
  ------------------
  |  Branch (4539:17): [True: 16.6k, False: 8.63k]
  ------------------
 4540|  16.6k|                    compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line,
 4541|  16.6k|                                       "token \"" + prop->name + "\" is not recognized");
 4542|  25.3k|                }
 4543|  25.3k|            }
 4544|  61.4k|        }
 4545|  20.9k|    }
_ZN4Ogre25CompositionPassTranslatorC2Ev:
 4551|      1|        :mPass(0)
 4552|      1|    {
 4553|      1|    }
_ZN4Ogre25CompositionPassTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE:
 4556|  19.0k|    {
 4557|  19.0k|        ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(node.get());
 4558|       |
 4559|       |        // The name is the type of the pass
 4560|  19.0k|        if(obj->values.empty() || obj->values.front()->type != ANT_ATOM)
  ------------------
  |  Branch (4560:12): [True: 219, False: 18.7k]
  |  Branch (4560:35): [True: 0, False: 18.7k]
  ------------------
 4561|    219|        {
 4562|    219|            compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, obj->file, obj->line, "pass type missing");
 4563|    219|            return;
 4564|    219|        }
 4565|       |
 4566|  18.7k|        AtomAbstractNode* atom = static_cast<AtomAbstractNode*>(obj->values.front().get());
 4567|       |
 4568|  18.7k|        CompositionPass::PassType ptype;
 4569|  18.7k|        switch(atom->id)
 4570|  18.7k|        {
 4571|  6.35k|            case ID_CLEAR:
  ------------------
  |  Branch (4571:13): [True: 6.35k, False: 12.4k]
  ------------------
 4572|  6.35k|                ptype = CompositionPass::PT_CLEAR;
 4573|  6.35k|                break;
 4574|    206|            case ID_STENCIL:
  ------------------
  |  Branch (4574:13): [True: 206, False: 18.5k]
  ------------------
 4575|    206|                ptype = CompositionPass::PT_STENCIL;
 4576|    206|                break;
 4577|  1.98k|            case ID_RENDER_QUAD:
  ------------------
  |  Branch (4577:13): [True: 1.98k, False: 16.8k]
  ------------------
 4578|  1.98k|                ptype = CompositionPass::PT_RENDERQUAD;
 4579|  1.98k|                break;
 4580|  6.26k|            case ID_RENDER_SCENE:
  ------------------
  |  Branch (4580:13): [True: 6.26k, False: 12.5k]
  ------------------
 4581|  6.26k|                ptype = CompositionPass::PT_RENDERSCENE;
 4582|  6.26k|                break;
 4583|    252|            case ID_COMPUTE:
  ------------------
  |  Branch (4583:13): [True: 252, False: 18.5k]
  ------------------
 4584|    252|                ptype = CompositionPass::PT_COMPUTE;
 4585|    252|                break;
 4586|  1.30k|            case ID_RENDER_CUSTOM:
  ------------------
  |  Branch (4586:13): [True: 1.30k, False: 17.4k]
  ------------------
 4587|  1.30k|                ptype = CompositionPass::PT_RENDERCUSTOM;
 4588|  1.30k|                break;
 4589|  2.43k|            default:
  ------------------
  |  Branch (4589:13): [True: 2.43k, False: 16.3k]
  ------------------
 4590|  2.43k|                compiler->addError(*obj, atom->value);
 4591|  2.43k|                return;
 4592|  18.7k|        }
 4593|       |
 4594|  16.3k|        CompositionTargetPass *target = any_cast<CompositionTargetPass*>(obj->parent->context);
 4595|  16.3k|        mPass = target->createPass(ptype);
 4596|  16.3k|        obj->context = mPass;
 4597|       |
 4598|  16.3k|        if(mPass->getType() == CompositionPass::PT_RENDERCUSTOM)
  ------------------
  |  Branch (4598:12): [True: 1.30k, False: 15.0k]
  ------------------
 4599|  1.30k|        {
 4600|  1.30k|            String customType;
 4601|       |            //This is the ugly one liner for safe access to the second parameter.
 4602|  1.30k|            if (obj->values.size() < 2 || !getString(*(++(obj->values.begin())), &customType))
  ------------------
  |  Branch (4602:17): [True: 66, False: 1.23k]
  |  Branch (4602:17): [True: 66, False: 1.23k]
  |  Branch (4602:43): [True: 0, False: 1.23k]
  ------------------
 4603|     66|            {
 4604|     66|                compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, obj->file, obj->line);
 4605|     66|                return;
 4606|     66|            }
 4607|  1.23k|            mPass->setCustomType(customType);
 4608|  1.23k|        }
 4609|       |
 4610|  16.2k|        Real fval;
 4611|  16.2k|        bool bval;
 4612|  16.2k|        uint32 uival;
 4613|  16.2k|        String sval;
 4614|  16.2k|        StencilOperation sop;
 4615|       |
 4616|  16.2k|        for(auto & i : obj->children)
  ------------------
  |  Branch (4616:22): [True: 78.8k, False: 13.8k]
  ------------------
 4617|  78.8k|        {
 4618|  78.8k|            if(i->type == ANT_OBJECT)
  ------------------
  |  Branch (4618:16): [True: 7.64k, False: 71.2k]
  ------------------
 4619|  7.64k|            {
 4620|  7.64k|                processNode(compiler, i);
 4621|  7.64k|            }
 4622|  71.2k|            else if(i->type == ANT_PROPERTY)
  ------------------
  |  Branch (4622:21): [True: 60.9k, False: 10.3k]
  ------------------
 4623|  60.9k|            {
 4624|  60.9k|                PropertyAbstractNode *prop = static_cast<PropertyAbstractNode*>(i.get());
 4625|  60.9k|                switch(prop->id)
 4626|  60.9k|                {
 4627|    401|                case ID_CHECK:
  ------------------
  |  Branch (4627:17): [True: 401, False: 60.5k]
  ------------------
 4628|    401|                    if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (4628:24): [True: 239, False: 162]
  ------------------
 4629|    239|                        mPass->setStencilCheck(bval);
 4630|    401|                    break;
 4631|    507|                case ID_COMP_FUNC:
  ------------------
  |  Branch (4631:17): [True: 507, False: 60.4k]
  ------------------
 4632|    507|                    CompareFunction func;
 4633|    507|                    if(getValue(prop, compiler, func))
  ------------------
  |  Branch (4633:24): [True: 223, False: 284]
  ------------------
 4634|    223|                        mPass->setStencilFunc(func);
 4635|    507|                    break;
 4636|    459|                case ID_REF_VALUE:
  ------------------
  |  Branch (4636:17): [True: 459, False: 60.4k]
  ------------------
 4637|    459|                    if(getValue(prop, compiler, uival))
  ------------------
  |  Branch (4637:24): [True: 257, False: 202]
  ------------------
 4638|    257|                        mPass->setStencilRefValue(uival);
 4639|    459|                    break;
 4640|  2.76k|                case ID_MASK:
  ------------------
  |  Branch (4640:17): [True: 2.76k, False: 58.1k]
  ------------------
 4641|  2.76k|                    if(getValue(prop, compiler, uival))
  ------------------
  |  Branch (4641:24): [True: 210, False: 2.55k]
  ------------------
 4642|    210|                        mPass->setStencilMask(uival);
 4643|  2.76k|                    break;
 4644|  1.05k|                case ID_FAIL_OP:
  ------------------
  |  Branch (4644:17): [True: 1.05k, False: 59.8k]
  ------------------
 4645|  1.05k|                    if(getValue(prop, compiler, sop))
  ------------------
  |  Branch (4645:24): [True: 702, False: 350]
  ------------------
 4646|    702|                        mPass->setStencilFailOp(sop);
 4647|  1.05k|                    break;
 4648|  1.35k|                case ID_DEPTH_FAIL_OP:
  ------------------
  |  Branch (4648:17): [True: 1.35k, False: 59.5k]
  ------------------
 4649|  1.35k|                    if(getValue(prop, compiler, sop))
  ------------------
  |  Branch (4649:24): [True: 425, False: 929]
  ------------------
 4650|    425|                        mPass->setStencilDepthFailOp(sop);
 4651|  1.35k|                    break;
 4652|  1.37k|                case ID_PASS_OP:
  ------------------
  |  Branch (4652:17): [True: 1.37k, False: 59.5k]
  ------------------
 4653|  1.37k|                    if(getValue(prop, compiler, sop))
  ------------------
  |  Branch (4653:24): [True: 780, False: 592]
  ------------------
 4654|    780|                        mPass->setStencilPassOp(sop);
 4655|  1.37k|                    break;
 4656|  2.66k|                case ID_TWO_SIDED:
  ------------------
  |  Branch (4656:17): [True: 2.66k, False: 58.2k]
  ------------------
 4657|  2.66k|                    if(getValue(prop, compiler, bval))
  ------------------
  |  Branch (4657:24): [True: 342, False: 2.31k]
  ------------------
 4658|    342|                        mPass->setStencilTwoSidedOperation(bval);
 4659|  2.66k|                    break;
 4660|  1.95k|                case ID_BUFFERS:
  ------------------
  |  Branch (4660:17): [True: 1.95k, False: 58.9k]
  ------------------
 4661|  1.95k|                    {
 4662|  1.95k|                        uint32 buffers = 0;
 4663|  1.95k|                        for(const auto& v : prop->values)
  ------------------
  |  Branch (4663:43): [True: 3.45k, False: 1.95k]
  ------------------
 4664|  3.45k|                        {
 4665|  3.45k|                            switch(getAtomId(v))
 4666|  3.45k|                            {
 4667|    775|                            case ID_COLOUR:
  ------------------
  |  Branch (4667:29): [True: 775, False: 2.68k]
  ------------------
 4668|    775|                                buffers |= FBT_COLOUR;
 4669|    775|                                break;
 4670|    346|                            case ID_DEPTH:
  ------------------
  |  Branch (4670:29): [True: 346, False: 3.11k]
  ------------------
 4671|    346|                                buffers |= FBT_DEPTH;
 4672|    346|                                break;
 4673|    458|                            case ID_STENCIL:
  ------------------
  |  Branch (4673:29): [True: 458, False: 3.00k]
  ------------------
 4674|    458|                                buffers |= FBT_STENCIL;
 4675|    458|                                break;
 4676|  1.88k|                            default:
  ------------------
  |  Branch (4676:29): [True: 1.88k, False: 1.57k]
  ------------------
 4677|  1.88k|                                compiler->addError(*prop);
 4678|  3.45k|                            }
 4679|  3.45k|                        }
 4680|  1.95k|                        mPass->setClearBuffers(buffers);
 4681|  1.95k|                    }
 4682|      0|                    break;
 4683|  1.95k|                case ID_COLOUR_VALUE:
  ------------------
  |  Branch (4683:17): [True: 1.95k, False: 58.9k]
  ------------------
 4684|  1.95k|                    {
 4685|  1.95k|                        if(prop->values.empty())
  ------------------
  |  Branch (4685:28): [True: 96, False: 1.85k]
  ------------------
 4686|     96|                        {
 4687|     96|                            compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line);
 4688|     96|                            return;
 4689|     96|                        }
 4690|  1.85k|                        ColourValue val;
 4691|  1.85k|                        if (getAtomId(prop->values.front()) == ID_AUTO)
  ------------------
  |  Branch (4691:29): [True: 0, False: 1.85k]
  ------------------
 4692|      0|                            mPass->setAutomaticColour(true);
 4693|  1.85k|                        else if(getColour(prop->values.begin(), prop->values.end(), &val))
  ------------------
  |  Branch (4693:33): [True: 582, False: 1.27k]
  ------------------
 4694|    582|                            mPass->setClearColour(val);
 4695|  1.27k|                        else
 4696|  1.27k|                            compiler->addError(*prop);
 4697|  1.85k|                    }
 4698|      0|                    break;
 4699|    536|                case ID_DEPTH_VALUE:
  ------------------
  |  Branch (4699:17): [True: 536, False: 60.3k]
  ------------------
 4700|    536|                    if(getValue(prop, compiler, fval))
  ------------------
  |  Branch (4700:24): [True: 249, False: 287]
  ------------------
 4701|    249|                        mPass->setClearDepth(fval);
 4702|    536|                    break;
 4703|    659|                case ID_STENCIL_VALUE:
  ------------------
  |  Branch (4703:17): [True: 659, False: 60.2k]
  ------------------
 4704|    659|                    if(getValue(prop, compiler, uival))
  ------------------
  |  Branch (4704:24): [True: 332, False: 327]
  ------------------
 4705|    332|                        mPass->setClearStencil(uival);
 4706|    659|                    break;
 4707|  11.3k|                case ID_MATERIAL:
  ------------------
  |  Branch (4707:17): [True: 11.3k, False: 49.6k]
  ------------------
 4708|  11.3k|                    if(getValue(prop, compiler, sval))
  ------------------
  |  Branch (4708:24): [True: 9.61k, False: 1.70k]
  ------------------
 4709|  9.61k|                    {
 4710|  9.61k|                        String name = processResourceName(compiler, ResourceType::MATERIAL, sval);
 4711|  9.61k|                        auto mat = MaterialManager::getSingleton().getByName(name, compiler->getResourceGroup());
 4712|  9.61k|                        if (mat)
  ------------------
  |  Branch (4712:29): [True: 7.28k, False: 2.33k]
  ------------------
 4713|  7.28k|                            mPass->setMaterial(mat);
 4714|  2.33k|                        else
 4715|  2.33k|                            compiler->addError(ScriptCompiler::CE_REFERENCETOANONEXISTINGOBJECT, prop->file,
 4716|  2.33k|                                               prop->line, name);
 4717|  9.61k|                    }
 4718|  11.3k|                    break;
 4719|  5.32k|                case ID_INPUT:
  ------------------
  |  Branch (4719:17): [True: 5.32k, False: 55.6k]
  ------------------
 4720|  5.32k|                    if(prop->values.size() < 2)
  ------------------
  |  Branch (4720:24): [True: 337, False: 4.98k]
  ------------------
 4721|    337|                    {
 4722|    337|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 4723|    337|                        return;
 4724|    337|                    }
 4725|  4.98k|                    else if (prop->values.size() > 3)
  ------------------
  |  Branch (4725:30): [True: 255, False: 4.72k]
  ------------------
 4726|    255|                    {
 4727|    255|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line);
 4728|    255|                        return;
 4729|    255|                    }
 4730|  4.72k|                    else
 4731|  4.72k|                    {
 4732|  4.72k|                        AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1), i2 = getNodeAt(prop->values, 2);
 4733|  4.72k|                        uint32 id;
 4734|  4.72k|                        String name;
 4735|  4.72k|                        if(getUInt(*i0, &id) && getString(*i1, &name))
  ------------------
  |  Branch (4735:28): [True: 3.92k, False: 804]
  |  Branch (4735:49): [True: 3.52k, False: 402]
  ------------------
 4736|  3.52k|                        {
 4737|  3.52k|                            uint32 index = 0;
 4738|  3.52k|                            if(i2 != prop->values.end())
  ------------------
  |  Branch (4738:32): [True: 2.57k, False: 953]
  ------------------
 4739|  2.57k|                            {
 4740|  2.57k|                                if(!getUInt(*i2, &index))
  ------------------
  |  Branch (4740:36): [True: 389, False: 2.18k]
  ------------------
 4741|    389|                                {
 4742|    389|                                    compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line);
 4743|    389|                                    return;
 4744|    389|                                }
 4745|  2.57k|                            }
 4746|       |
 4747|  3.13k|                            if(id >= OGRE_MAX_TEXTURE_LAYERS)
  ------------------
  |  Branch (4747:32): [True: 477, False: 2.65k]
  ------------------
 4748|    477|                            {
 4749|    477|                                compiler->addError(*prop, "input id must be less than " +
 4750|    477|                                                       std::to_string(OGRE_MAX_TEXTURE_LAYERS));
 4751|    477|                                return;
 4752|    477|                            }
 4753|       |
 4754|  2.65k|                            mPass->setInput(id, name, index);
 4755|  2.65k|                        }
 4756|  1.20k|                        else
 4757|  1.20k|                        {
 4758|  1.20k|                            compiler->addError(*prop);
 4759|  1.20k|                        }
 4760|  4.72k|                    }
 4761|  3.86k|                    break;
 4762|  3.86k|                case ID_IDENTIFIER:
  ------------------
  |  Branch (4762:17): [True: 442, False: 60.4k]
  ------------------
 4763|    442|                    if(getValue(prop, compiler, uival))
  ------------------
  |  Branch (4763:24): [True: 221, False: 221]
  ------------------
 4764|    221|                        mPass->setIdentifier(uival);
 4765|    442|                    break;
 4766|  1.64k|                case ID_FIRST_RENDER_QUEUE:
  ------------------
  |  Branch (4766:17): [True: 1.64k, False: 59.2k]
  ------------------
 4767|  1.64k|                    if(getValue(prop, compiler, uival))
  ------------------
  |  Branch (4767:24): [True: 1.35k, False: 290]
  ------------------
 4768|  1.35k|                        mPass->setFirstRenderQueue(static_cast<uint8>(uival));
 4769|  1.64k|                    break;
 4770|  1.40k|                case ID_LAST_RENDER_QUEUE:
  ------------------
  |  Branch (4770:17): [True: 1.40k, False: 59.5k]
  ------------------
 4771|  1.40k|                    if(getValue(prop, compiler, uival))
  ------------------
  |  Branch (4771:24): [True: 917, False: 483]
  ------------------
 4772|    917|                        mPass->setLastRenderQueue(static_cast<uint8>(uival));
 4773|  1.40k|                    break;
 4774|    874|                case ID_MATERIAL_SCHEME:
  ------------------
  |  Branch (4774:17): [True: 874, False: 60.0k]
  ------------------
 4775|    874|                    if(getValue(prop, compiler, sval))
  ------------------
  |  Branch (4775:24): [True: 692, False: 182]
  ------------------
 4776|    692|                        mPass->setMaterialScheme(sval);
 4777|    874|                    break;
 4778|    943|                case ID_THREAD_GROUPS:
  ------------------
  |  Branch (4778:17): [True: 943, False: 59.9k]
  ------------------
 4779|    943|                {
 4780|    943|                    std::vector<int> g;
 4781|    943|                    if(_getVector(prop->values.begin(), prop->values.end(), g, 3))
  ------------------
  |  Branch (4781:24): [True: 681, False: 262]
  ------------------
 4782|    681|                        mPass->setThreadGroups({g[0], g[1], g[2]});
 4783|    943|                    break;
 4784|  5.32k|                }
 4785|  1.15k|                case ID_QUAD_NORMALS:
  ------------------
  |  Branch (4785:17): [True: 1.15k, False: 59.7k]
  ------------------
 4786|  1.15k|                    if(prop->values.empty())
  ------------------
  |  Branch (4786:24): [True: 188, False: 967]
  ------------------
 4787|    188|                    {
 4788|    188|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 4789|    188|                        return;
 4790|    188|                    }
 4791|    967|                    else if (prop->values.size() > 1)
  ------------------
  |  Branch (4791:30): [True: 210, False: 757]
  ------------------
 4792|    210|                    {
 4793|    210|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line);
 4794|    210|                        return;
 4795|    210|                    }
 4796|    757|                    else
 4797|    757|                    {
 4798|    757|                        uint32 quadNormalsId = getAtomId(prop->values.front());
 4799|    757|                        if(quadNormalsId == ID_CAMERA_FAR_CORNERS_VIEW_SPACE)
  ------------------
  |  Branch (4799:28): [True: 191, False: 566]
  ------------------
 4800|    191|                            mPass->setQuadFarCorners(true, true);
 4801|    566|                        else if(quadNormalsId == ID_CAMERA_FAR_CORNERS_WORLD_SPACE)
  ------------------
  |  Branch (4801:33): [True: 0, False: 566]
  ------------------
 4802|      0|                            mPass->setQuadFarCorners(true, false);
 4803|    566|                        else
 4804|    566|                            compiler->addError(*prop);
 4805|    757|                    }
 4806|    757|                    break;
 4807|  3.27k|                case ID_CAMERA:
  ------------------
  |  Branch (4807:17): [True: 3.27k, False: 57.6k]
  ------------------
 4808|  3.27k|                    if(prop->values.empty())
  ------------------
  |  Branch (4808:24): [True: 33, False: 3.24k]
  ------------------
 4809|     33|                    {
 4810|     33|                        compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line);
 4811|     33|                        return;
 4812|     33|                    }
 4813|  3.24k|                    else if (prop->values.size() > 2)
  ------------------
  |  Branch (4813:30): [True: 285, False: 2.95k]
  ------------------
 4814|    285|                    {
 4815|    285|                        compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line);
 4816|    285|                        return;
 4817|    285|                    }
 4818|  2.95k|                    else
 4819|  2.95k|                    {
 4820|  2.95k|                        if (!getValue(prop->values.front(), sval))
  ------------------
  |  Branch (4820:29): [True: 182, False: 2.77k]
  ------------------
 4821|    182|                            return;
 4822|  2.77k|                        mPass->setCameraName(sval);
 4823|  2.77k|                        if (getAtomId(prop->values.back()) == ID_ALIGN_TO_FACE)
  ------------------
  |  Branch (4823:29): [True: 294, False: 2.48k]
  ------------------
 4824|    294|                        {
 4825|    294|                            mPass->setAlignCameraToFace(true);
 4826|    294|                        }
 4827|  2.77k|                    }
 4828|  2.77k|                    break;
 4829|  18.8k|                default:
  ------------------
  |  Branch (4829:17): [True: 18.8k, False: 42.0k]
  ------------------
 4830|  18.8k|                    compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line,
 4831|  18.8k|                                       "token \"" + prop->name + "\" is not recognized");
 4832|  60.9k|                }
 4833|  60.9k|            }
 4834|  78.8k|        }
 4835|  16.2k|    }
_ZN4Ogre30BuiltinScriptTranslatorManagerC2Ev:
 4841|      1|    {
 4842|      1|    }
_ZN4Ogre30BuiltinScriptTranslatorManager13getTranslatorERKNS_9SharedPtrINS_12AbstractNodeEEE:
 4845|   402k|    {
 4846|   402k|        ScriptTranslator *translator = 0;
 4847|       |
 4848|   402k|        if(node->type == ANT_OBJECT)
  ------------------
  |  Branch (4848:12): [True: 346k, False: 56.1k]
  ------------------
 4849|   346k|        {
 4850|   346k|            ObjectAbstractNode *obj = static_cast<ObjectAbstractNode*>(node.get());
 4851|   346k|            ObjectAbstractNode *parent = obj->parent && obj->parent->type == ANT_OBJECT ? static_cast<ObjectAbstractNode*>(obj->parent) : 0;
  ------------------
  |  Branch (4851:42): [True: 319k, False: 26.1k]
  |  Branch (4851:57): [True: 319k, False: 0]
  ------------------
 4852|   346k|            if(obj->id == ID_MATERIAL)
  ------------------
  |  Branch (4852:16): [True: 15.3k, False: 330k]
  ------------------
 4853|  15.3k|                translator = &mMaterialTranslator;
 4854|   330k|            else if(obj->id == ID_TECHNIQUE && parent && parent->id == ID_MATERIAL)
  ------------------
  |  Branch (4854:21): [True: 45.7k, False: 285k]
  |  Branch (4854:48): [True: 45.4k, False: 250]
  |  Branch (4854:58): [True: 36.7k, False: 8.66k]
  ------------------
 4855|  36.7k|                translator = &mTechniqueTranslator;
 4856|   294k|            else if(obj->id == ID_PASS && parent && parent->id == ID_TECHNIQUE)
  ------------------
  |  Branch (4856:21): [True: 90.4k, False: 203k]
  |  Branch (4856:43): [True: 90.2k, False: 221]
  |  Branch (4856:53): [True: 69.5k, False: 20.7k]
  ------------------
 4857|  69.5k|                translator = &mPassTranslator;
 4858|   224k|            else if(obj->id == ID_TEXTURE_UNIT && parent && parent->id == ID_PASS)
  ------------------
  |  Branch (4858:21): [True: 45.1k, False: 179k]
  |  Branch (4858:51): [True: 44.9k, False: 222]
  |  Branch (4858:61): [True: 41.4k, False: 3.52k]
  ------------------
 4859|  41.4k|                translator = &mTextureUnitTranslator;
 4860|   183k|            else if(obj->id == ID_TEXTURE_SOURCE && parent && parent->id == ID_TEXTURE_UNIT)
  ------------------
  |  Branch (4860:21): [True: 1.12k, False: 181k]
  |  Branch (4860:53): [True: 1.01k, False: 102]
  |  Branch (4860:63): [True: 746, False: 272]
  ------------------
 4861|    746|                translator = &mTextureSourceTranslator;
 4862|   182k|            else if(obj->id == ID_FRAGMENT_PROGRAM ||
  ------------------
  |  Branch (4862:21): [True: 2.49k, False: 179k]
  ------------------
 4863|   179k|                    obj->id == ID_VERTEX_PROGRAM ||
  ------------------
  |  Branch (4863:21): [True: 4.03k, False: 175k]
  ------------------
 4864|   175k|                    obj->id == ID_GEOMETRY_PROGRAM ||
  ------------------
  |  Branch (4864:21): [True: 951, False: 174k]
  ------------------
 4865|   174k|                    obj->id == ID_TESSELLATION_HULL_PROGRAM ||
  ------------------
  |  Branch (4865:21): [True: 628, False: 174k]
  ------------------
 4866|   174k|                    obj->id == ID_TESSELLATION_DOMAIN_PROGRAM ||
  ------------------
  |  Branch (4866:21): [True: 7.46k, False: 166k]
  ------------------
 4867|   166k|                    obj->id == ID_COMPUTE_PROGRAM ||
  ------------------
  |  Branch (4867:21): [True: 594, False: 166k]
  ------------------
 4868|   166k|                    obj->id == ID_MESH_PROGRAM ||
  ------------------
  |  Branch (4868:21): [True: 294, False: 165k]
  ------------------
 4869|   165k|                    obj->id == ID_TASK_PROGRAM)
  ------------------
  |  Branch (4869:21): [True: 0, False: 165k]
  ------------------
 4870|  16.4k|                translator = &mGpuProgramTranslator;
 4871|   165k|            else if(obj->id == ID_SHARED_PARAMS)
  ------------------
  |  Branch (4871:21): [True: 1.36k, False: 164k]
  ------------------
 4872|  1.36k|                translator = &mSharedParamsTranslator;
 4873|   164k|            else if(obj->id == ID_PARTICLE_SYSTEM)
  ------------------
  |  Branch (4873:21): [True: 98, False: 164k]
  ------------------
 4874|     98|                translator = &mParticleSystemTranslator;
 4875|   164k|            else if(obj->id == ID_EMITTER && parent && parent->id == ID_PARTICLE_SYSTEM)
  ------------------
  |  Branch (4875:21): [True: 515, False: 163k]
  |  Branch (4875:46): [True: 307, False: 208]
  |  Branch (4875:56): [True: 0, False: 307]
  ------------------
 4876|      0|                translator = &mParticleEmitterTranslator;
 4877|   164k|            else if(obj->id == ID_AFFECTOR && parent && parent->id == ID_PARTICLE_SYSTEM)
  ------------------
  |  Branch (4877:21): [True: 376, False: 163k]
  |  Branch (4877:47): [True: 286, False: 90]
  |  Branch (4877:57): [True: 0, False: 286]
  ------------------
 4878|      0|                translator = &mParticleAffectorTranslator;
 4879|   164k|            else if(obj->id == ID_COMPOSITOR)
  ------------------
  |  Branch (4879:21): [True: 2.71k, False: 161k]
  ------------------
 4880|  2.71k|                translator = &mCompositorTranslator;
 4881|   161k|            else if(obj->id == ID_TECHNIQUE && parent && parent->id == ID_COMPOSITOR)
  ------------------
  |  Branch (4881:21): [True: 8.91k, False: 152k]
  |  Branch (4881:48): [True: 8.66k, False: 250]
  |  Branch (4881:58): [True: 7.17k, False: 1.48k]
  ------------------
 4882|  7.17k|                translator = &mCompositionTechniqueTranslator;
 4883|   154k|            else if((obj->id == ID_TARGET || obj->id == ID_TARGET_OUTPUT) && parent && parent->id == ID_TECHNIQUE)
  ------------------
  |  Branch (4883:22): [True: 27.6k, False: 126k]
  |  Branch (4883:46): [True: 843, False: 126k]
  |  Branch (4883:78): [True: 28.1k, False: 333]
  |  Branch (4883:88): [True: 21.1k, False: 6.96k]
  ------------------
 4884|  21.1k|                translator = &mCompositionTargetPassTranslator;
 4885|   133k|            else if(obj->id == ID_PASS && parent && (parent->id == ID_TARGET || parent->id == ID_TARGET_OUTPUT))
  ------------------
  |  Branch (4885:21): [True: 20.9k, False: 112k]
  |  Branch (4885:43): [True: 20.7k, False: 221]
  |  Branch (4885:54): [True: 18.7k, False: 1.99k]
  |  Branch (4885:81): [True: 295, False: 1.69k]
  ------------------
 4886|  19.0k|                translator = &mCompositionPassTranslator;
 4887|   114k|            else if(obj->id == ID_SAMPLER)
  ------------------
  |  Branch (4887:21): [True: 732, False: 113k]
  ------------------
 4888|    732|                translator = &mSamplerTranslator;
 4889|   346k|        }
 4890|       |
 4891|   402k|        return translator;
 4892|   402k|    }
OgreScriptTranslator.cpp:_ZN4OgreL9getAtomIdERKNS_9SharedPtrINS_12AbstractNodeEEE:
   87|   306k|    {
   88|   306k|        return node->type == ANT_ATOM ? static_cast<AtomAbstractNode*>(node.get())->id : 0;
  ------------------
  |  Branch (88:16): [True: 286k, False: 19.9k]
  ------------------
   89|   306k|    }
OgreScriptTranslator.cpp:_ZN4OgreL19applyTextureAliasesEPNS_14ScriptCompilerEPKNS_8MaterialERKNSt3__13mapINS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESC_NS5_4lessISC_EENSA_INS5_4pairIKSC_SC_EEEEEE:
   64|  13.2k|    {
   65|  13.2k|        for (auto t : mat->getTechniques())
  ------------------
  |  Branch (65:21): [True: 36.4k, False: 13.2k]
  ------------------
   66|  36.4k|        {
   67|  36.4k|            for (auto p : t->getPasses())
  ------------------
  |  Branch (67:25): [True: 68.3k, False: 36.4k]
  ------------------
   68|  68.3k|            {
   69|  68.3k|                for (auto tus : p->getTextureUnitStates())
  ------------------
  |  Branch (69:31): [True: 40.1k, False: 68.3k]
  ------------------
   70|  40.1k|                {
   71|  40.1k|                    auto aliasIt = aliasList.find(tus->getName());
   72|  40.1k|                    if (aliasIt == aliasList.end())
  ------------------
  |  Branch (72:25): [True: 39.0k, False: 1.09k]
  ------------------
   73|  39.0k|                        continue;
   74|       |
   75|  1.09k|                    auto name = processResourceName(compiler, ResourceType::TEXTURE, aliasIt->second);
   76|  1.09k|                    if (tus->getNumFrames() > 1)
  ------------------
  |  Branch (76:25): [True: 131, False: 962]
  ------------------
   77|    131|                        tus->setAnimatedTextureName(name, tus->getNumFrames(),
   78|    131|                                                    tus->getAnimationDuration());
   79|    962|                    else
   80|    962|                        tus->setTextureName(name, tus->getTextureType());
   81|  1.09k|                }
   82|  68.3k|            }
   83|  36.4k|        }
   84|  13.2k|    }
OgreScriptTranslator.cpp:_ZN4OgreL19processResourceNameEPNS_14ScriptCompilerENS_38ProcessResourceNameScriptCompilerEvent12ResourceTypeERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE:
   50|   266k|    {
   51|   266k|        ProcessResourceNameScriptCompilerEvent evt(type, name);
   52|   266k|        compiler->_fireEvent(&evt, 0);
   53|   266k|        return evt.mName;
   54|   266k|    }
OgreScriptTranslator.cpp:_ZZN4Ogre14PassTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEEENK3$_0clENSt3__121__list_const_iteratorIS5_PvEE:
 1860|  2.49k|                    {
 1861|  2.49k|                        if(it == prop->values.end())
  ------------------
  |  Branch (1861:28): [True: 780, False: 1.71k]
  ------------------
 1862|    780|                        {
 1863|    780|                            mPass->setIteratePerLight(true, false);
 1864|    780|                            return;
 1865|    780|                        }
 1866|  1.71k|                        switch(getAtomId(*it))
 1867|  1.71k|                        {
 1868|    614|                        case ID_POINT:
  ------------------
  |  Branch (1868:25): [True: 614, False: 1.10k]
  ------------------
 1869|    614|                            mPass->setIteratePerLight(true, true, Light::LT_POINT);
 1870|    614|                            break;
 1871|    128|                        case ID_DIRECTIONAL:
  ------------------
  |  Branch (1871:25): [True: 128, False: 1.58k]
  ------------------
 1872|    128|                            mPass->setIteratePerLight(true, true, Light::LT_DIRECTIONAL);
 1873|    128|                            break;
 1874|    184|                        case ID_SPOT:
  ------------------
  |  Branch (1874:25): [True: 184, False: 1.53k]
  ------------------
 1875|    184|                            mPass->setIteratePerLight(true, true, Light::LT_SPOTLIGHT);
 1876|    184|                            break;
 1877|    791|                        default:
  ------------------
  |  Branch (1877:25): [True: 791, False: 926]
  ------------------
 1878|       |                            // no ID_RECT to keep the header ABI stable
 1879|    791|                            if ((*it)->getValue() == "rect")
  ------------------
  |  Branch (1879:33): [True: 0, False: 791]
  ------------------
 1880|      0|                                mPass->setIteratePerLight(true, true, Light::LT_RECTLIGHT);
 1881|    791|                            else
 1882|    791|                                compiler->addError(*prop, (*it)->getValue() + " is not a valid light type (point, directional, spot, or rect)");
 1883|  1.71k|                        }
 1884|  1.71k|                    };
OgreScriptTranslator.cpp:_ZN4OgreL14getProgramTypeEi:
  472|  43.2k|    {
  473|  43.2k|        switch(id)
  474|  43.2k|        {
  475|      0|        default:
  ------------------
  |  Branch (475:9): [True: 0, False: 43.2k]
  ------------------
  476|      0|            assert(false);
  477|      0|            OGRE_FALLTHROUGH;
  478|  2.55k|        case ID_VERTEX_PROGRAM:
  ------------------
  |  Branch (478:9): [True: 2.55k, False: 40.6k]
  ------------------
  479|  26.3k|        case ID_VERTEX_PROGRAM_REF:
  ------------------
  |  Branch (479:9): [True: 23.7k, False: 19.4k]
  ------------------
  480|  26.3k|            return GPT_VERTEX_PROGRAM;
  481|  1.38k|        case ID_FRAGMENT_PROGRAM:
  ------------------
  |  Branch (481:9): [True: 1.38k, False: 41.8k]
  ------------------
  482|  2.69k|        case ID_FRAGMENT_PROGRAM_REF:
  ------------------
  |  Branch (482:9): [True: 1.31k, False: 41.8k]
  ------------------
  483|  2.69k|            return GPT_FRAGMENT_PROGRAM;
  484|    526|        case ID_GEOMETRY_PROGRAM:
  ------------------
  |  Branch (484:9): [True: 526, False: 42.6k]
  ------------------
  485|    785|        case ID_GEOMETRY_PROGRAM_REF:
  ------------------
  |  Branch (485:9): [True: 259, False: 42.9k]
  ------------------
  486|    785|            return GPT_GEOMETRY_PROGRAM;
  487|  7.17k|        case ID_TESSELLATION_DOMAIN_PROGRAM:
  ------------------
  |  Branch (487:9): [True: 7.17k, False: 36.0k]
  ------------------
  488|  8.96k|        case ID_TESSELLATION_DOMAIN_PROGRAM_REF:
  ------------------
  |  Branch (488:9): [True: 1.79k, False: 41.4k]
  ------------------
  489|  8.96k|            return GPT_DOMAIN_PROGRAM;
  490|    414|        case ID_TESSELLATION_HULL_PROGRAM:
  ------------------
  |  Branch (490:9): [True: 414, False: 42.7k]
  ------------------
  491|  2.80k|        case ID_TESSELLATION_HULL_PROGRAM_REF:
  ------------------
  |  Branch (491:9): [True: 2.39k, False: 40.8k]
  ------------------
  492|  2.80k|            return GPT_HULL_PROGRAM;
  493|    442|        case ID_COMPUTE_PROGRAM:
  ------------------
  |  Branch (493:9): [True: 442, False: 42.7k]
  ------------------
  494|    710|        case ID_COMPUTE_PROGRAM_REF:
  ------------------
  |  Branch (494:9): [True: 268, False: 42.9k]
  ------------------
  495|    710|            return GPT_COMPUTE_PROGRAM;
  496|     93|        case ID_MESH_PROGRAM:
  ------------------
  |  Branch (496:9): [True: 93, False: 43.1k]
  ------------------
  497|    913|        case ID_MESH_PROGRAM_REF:
  ------------------
  |  Branch (497:9): [True: 820, False: 42.3k]
  ------------------
  498|    913|            return GPT_MESH_PROGRAM;
  499|      0|        case ID_TASK_PROGRAM:
  ------------------
  |  Branch (499:9): [True: 0, False: 43.2k]
  ------------------
  500|      0|        case ID_TASK_PROGRAM_REF:
  ------------------
  |  Branch (500:9): [True: 0, False: 43.2k]
  ------------------
  501|      0|            return GPT_TASK_PROGRAM;
  502|  43.2k|        }
  503|  43.2k|    }
OgreScriptTranslator.cpp:_ZN4OgreL10getProgramEPNS_14ScriptCompilerEPNS_18ObjectAbstractNodeE:
 2046|  57.0k|    {
 2047|  57.0k|        if(node->name.empty())
  ------------------
  |  Branch (2047:12): [True: 225, False: 56.8k]
  ------------------
 2048|    225|        {
 2049|    225|            compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, node->file, node->line);
 2050|    225|            return nullptr;
 2051|    225|        }
 2052|       |
 2053|  56.8k|        String name = processResourceName(compiler, ResourceType::GPU_PROGRAM, node->name);
 2054|       |
 2055|  56.8k|        auto& mgr = GpuProgramManager::getSingleton();
 2056|  56.8k|        if (auto ret = mgr.getByName(name, compiler->getResourceGroup()))
  ------------------
  |  Branch (2056:18): [True: 46.0k, False: 10.8k]
  ------------------
 2057|  46.0k|            return ret;
 2058|       |
 2059|       |        // recheck with auto resource group
 2060|  10.8k|        if (auto ret = mgr.getByName(name, RGN_AUTODETECT))
  ------------------
  |  Branch (2060:18): [True: 0, False: 10.8k]
  ------------------
 2061|      0|            return ret;
 2062|       |
 2063|  10.8k|        compiler->addError(ScriptCompiler::CE_REFERENCETOANONEXISTINGOBJECT, node->file, node->line,
 2064|  10.8k|                           name);
 2065|  10.8k|        return nullptr;
 2066|  10.8k|    }
OgreScriptTranslator.cpp:_ZN4OgreL20processResourceNamesEPNS_14ScriptCompilerENS_38ProcessResourceNameScriptCompilerEvent12ResourceTypeERNSt3__16vectorINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS9_ISB_EEEE:
   56|  8.75k|    {
   57|  8.75k|        if (!compiler->getListener())
  ------------------
  |  Branch (57:13): [True: 0, False: 8.75k]
  ------------------
   58|      0|            return; // nothing would change
   59|  8.75k|        for (String& n : names)
  ------------------
  |  Branch (59:24): [True: 136k, False: 8.75k]
  ------------------
   60|   136k|            n = processResourceName(compiler, type, n);
   61|  8.75k|    }
OgreScriptTranslator.cpp:_ZN4OgreL10_getVectorIiEEbNSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEES7_RNS1_6vectorIT_NS1_9allocatorIS9_EEEEm:
  452|  1.85k|    {
  453|  1.85k|        vals.reserve(count);
  454|  1.85k|        size_t n = 0;
  455|  4.87k|        while (n < count)
  ------------------
  |  Branch (455:16): [True: 3.52k, False: 1.34k]
  ------------------
  456|  3.52k|        {
  457|  3.52k|            if (i != end)
  ------------------
  |  Branch (457:17): [True: 2.41k, False: 1.11k]
  ------------------
  458|  2.41k|            {
  459|  2.41k|                T v;
  460|  2.41k|                if (!getValue(*i++, v))
  ------------------
  |  Branch (460:21): [True: 515, False: 1.90k]
  ------------------
  461|    515|                    return false;
  462|  1.90k|                vals.push_back(v);
  463|  1.90k|            }
  464|  3.01k|            ++n;
  465|  3.01k|        }
  466|       |
  467|  1.34k|        vals.resize(count);
  468|  1.34k|        return true;
  469|  1.85k|    }
OgreScriptTranslator.cpp:_ZN4OgreL10_getVectorIfEEbNSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEES7_RNS1_6vectorIT_NS1_9allocatorIS9_EEEEm:
  452|  29.2k|    {
  453|  29.2k|        vals.reserve(count);
  454|  29.2k|        size_t n = 0;
  455|  19.5M|        while (n < count)
  ------------------
  |  Branch (455:16): [True: 19.4M, False: 26.5k]
  ------------------
  456|  19.4M|        {
  457|  19.4M|            if (i != end)
  ------------------
  |  Branch (457:17): [True: 58.0k, False: 19.4M]
  ------------------
  458|  58.0k|            {
  459|  58.0k|                T v;
  460|  58.0k|                if (!getValue(*i++, v))
  ------------------
  |  Branch (460:21): [True: 2.68k, False: 55.3k]
  ------------------
  461|  2.68k|                    return false;
  462|  55.3k|                vals.push_back(v);
  463|  55.3k|            }
  464|  19.4M|            ++n;
  465|  19.4M|        }
  466|       |
  467|  26.5k|        vals.resize(count);
  468|  26.5k|        return true;
  469|  29.2k|    }
OgreScriptTranslator.cpp:_ZN4OgreL8getValueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_:
  433|  70.7k|    {
  434|  70.7k|        if (prop->values.size() != 1)
  ------------------
  |  Branch (434:13): [True: 12.5k, False: 58.1k]
  ------------------
  435|  12.5k|        {
  436|  12.5k|            compiler->addError(*prop, prop->name + " must have exactly 1 argument");
  437|  12.5k|        }
  438|  58.1k|        else
  439|  58.1k|        {
  440|  58.1k|            if (getValue(prop->values.front(), val))
  ------------------
  |  Branch (440:17): [True: 57.0k, False: 1.13k]
  ------------------
  441|  57.0k|                return true;
  442|  1.13k|            else
  443|  1.13k|                compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name);
  444|  58.1k|        }
  445|       |
  446|  13.7k|        return false;
  447|  70.7k|    }
OgreScriptTranslator.cpp:_ZN4OgreL8getValueIbEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_:
  433|  76.7k|    {
  434|  76.7k|        if (prop->values.size() != 1)
  ------------------
  |  Branch (434:13): [True: 7.37k, False: 69.3k]
  ------------------
  435|  7.37k|        {
  436|  7.37k|            compiler->addError(*prop, prop->name + " must have exactly 1 argument");
  437|  7.37k|        }
  438|  69.3k|        else
  439|  69.3k|        {
  440|  69.3k|            if (getValue(prop->values.front(), val))
  ------------------
  |  Branch (440:17): [True: 61.4k, False: 7.85k]
  ------------------
  441|  61.4k|                return true;
  442|  7.85k|            else
  443|  7.85k|                compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name);
  444|  69.3k|        }
  445|       |
  446|  15.2k|        return false;
  447|  76.7k|    }
OgreScriptTranslator.cpp:_ZN4OgreL8getValueIjEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_:
  433|  18.3k|    {
  434|  18.3k|        if (prop->values.size() != 1)
  ------------------
  |  Branch (434:13): [True: 4.00k, False: 14.3k]
  ------------------
  435|  4.00k|        {
  436|  4.00k|            compiler->addError(*prop, prop->name + " must have exactly 1 argument");
  437|  4.00k|        }
  438|  14.3k|        else
  439|  14.3k|        {
  440|  14.3k|            if (getValue(prop->values.front(), val))
  ------------------
  |  Branch (440:17): [True: 9.06k, False: 5.24k]
  ------------------
  441|  9.06k|                return true;
  442|  5.24k|            else
  443|  5.24k|                compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name);
  444|  14.3k|        }
  445|       |
  446|  9.24k|        return false;
  447|  18.3k|    }
OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_19SceneBlendOperationEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_:
  433|  2.78k|    {
  434|  2.78k|        if (prop->values.size() != 1)
  ------------------
  |  Branch (434:13): [True: 469, False: 2.31k]
  ------------------
  435|    469|        {
  436|    469|            compiler->addError(*prop, prop->name + " must have exactly 1 argument");
  437|    469|        }
  438|  2.31k|        else
  439|  2.31k|        {
  440|  2.31k|            if (getValue(prop->values.front(), val))
  ------------------
  |  Branch (440:17): [True: 1.20k, False: 1.10k]
  ------------------
  441|  1.20k|                return true;
  442|  1.10k|            else
  443|  1.10k|                compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name);
  444|  2.31k|        }
  445|       |
  446|  1.57k|        return false;
  447|  2.78k|    }
OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_15CompareFunctionEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_:
  433|  4.03k|    {
  434|  4.03k|        if (prop->values.size() != 1)
  ------------------
  |  Branch (434:13): [True: 812, False: 3.22k]
  ------------------
  435|    812|        {
  436|    812|            compiler->addError(*prop, prop->name + " must have exactly 1 argument");
  437|    812|        }
  438|  3.22k|        else
  439|  3.22k|        {
  440|  3.22k|            if (getValue(prop->values.front(), val))
  ------------------
  |  Branch (440:17): [True: 1.45k, False: 1.76k]
  ------------------
  441|  1.45k|                return true;
  442|  1.76k|            else
  443|  1.76k|                compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name);
  444|  3.22k|        }
  445|       |
  446|  2.58k|        return false;
  447|  4.03k|    }
OgreScriptTranslator.cpp:_ZN4OgreL8getValueIfEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_:
  433|  13.9k|    {
  434|  13.9k|        if (prop->values.size() != 1)
  ------------------
  |  Branch (434:13): [True: 3.09k, False: 10.8k]
  ------------------
  435|  3.09k|        {
  436|  3.09k|            compiler->addError(*prop, prop->name + " must have exactly 1 argument");
  437|  3.09k|        }
  438|  10.8k|        else
  439|  10.8k|        {
  440|  10.8k|            if (getValue(prop->values.front(), val))
  ------------------
  |  Branch (440:17): [True: 7.61k, False: 3.26k]
  ------------------
  441|  7.61k|                return true;
  442|  3.26k|            else
  443|  3.26k|                compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name);
  444|  10.8k|        }
  445|       |
  446|  6.36k|        return false;
  447|  13.9k|    }
OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_17IlluminationStageEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_:
  433|  3.59k|    {
  434|  3.59k|        if (prop->values.size() != 1)
  ------------------
  |  Branch (434:13): [True: 1.32k, False: 2.26k]
  ------------------
  435|  1.32k|        {
  436|  1.32k|            compiler->addError(*prop, prop->name + " must have exactly 1 argument");
  437|  1.32k|        }
  438|  2.26k|        else
  439|  2.26k|        {
  440|  2.26k|            if (getValue(prop->values.front(), val))
  ------------------
  |  Branch (440:17): [True: 1.01k, False: 1.24k]
  ------------------
  441|  1.01k|                return true;
  442|  1.24k|            else
  443|  1.24k|                compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name);
  444|  2.26k|        }
  445|       |
  446|  2.57k|        return false;
  447|  3.59k|    }
OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_11CullingModeEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_:
  433|  39.0k|    {
  434|  39.0k|        if (prop->values.size() != 1)
  ------------------
  |  Branch (434:13): [True: 496, False: 38.5k]
  ------------------
  435|    496|        {
  436|    496|            compiler->addError(*prop, prop->name + " must have exactly 1 argument");
  437|    496|        }
  438|  38.5k|        else
  439|  38.5k|        {
  440|  38.5k|            if (getValue(prop->values.front(), val))
  ------------------
  |  Branch (440:17): [True: 34.4k, False: 4.06k]
  ------------------
  441|  34.4k|                return true;
  442|  4.06k|            else
  443|  4.06k|                compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name);
  444|  38.5k|        }
  445|       |
  446|  4.56k|        return false;
  447|  39.0k|    }
OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_17ManualCullingModeEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_:
  433|  1.73k|    {
  434|  1.73k|        if (prop->values.size() != 1)
  ------------------
  |  Branch (434:13): [True: 397, False: 1.33k]
  ------------------
  435|    397|        {
  436|    397|            compiler->addError(*prop, prop->name + " must have exactly 1 argument");
  437|    397|        }
  438|  1.33k|        else
  439|  1.33k|        {
  440|  1.33k|            if (getValue(prop->values.front(), val))
  ------------------
  |  Branch (440:17): [True: 683, False: 653]
  ------------------
  441|    683|                return true;
  442|    653|            else
  443|    653|                compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name);
  444|  1.33k|        }
  445|       |
  446|  1.05k|        return false;
  447|  1.73k|    }
OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_12ShadeOptionsEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_:
  433|  1.53k|    {
  434|  1.53k|        if (prop->values.size() != 1)
  ------------------
  |  Branch (434:13): [True: 411, False: 1.12k]
  ------------------
  435|    411|        {
  436|    411|            compiler->addError(*prop, prop->name + " must have exactly 1 argument");
  437|    411|        }
  438|  1.12k|        else
  439|  1.12k|        {
  440|  1.12k|            if (getValue(prop->values.front(), val))
  ------------------
  |  Branch (440:17): [True: 309, False: 813]
  ------------------
  441|    309|                return true;
  442|    813|            else
  443|    813|                compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name);
  444|  1.12k|        }
  445|       |
  446|  1.22k|        return false;
  447|  1.53k|    }
OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_11PolygonModeEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_:
  433|  2.74k|    {
  434|  2.74k|        if (prop->values.size() != 1)
  ------------------
  |  Branch (434:13): [True: 1.04k, False: 1.69k]
  ------------------
  435|  1.04k|        {
  436|  1.04k|            compiler->addError(*prop, prop->name + " must have exactly 1 argument");
  437|  1.04k|        }
  438|  1.69k|        else
  439|  1.69k|        {
  440|  1.69k|            if (getValue(prop->values.front(), val))
  ------------------
  |  Branch (440:17): [True: 308, False: 1.39k]
  ------------------
  441|    308|                return true;
  442|  1.39k|            else
  443|  1.39k|                compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name);
  444|  1.69k|        }
  445|       |
  446|  2.43k|        return false;
  447|  2.74k|    }
OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_19LayerBlendOperationEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_:
  433|  6.18k|    {
  434|  6.18k|        if (prop->values.size() != 1)
  ------------------
  |  Branch (434:13): [True: 675, False: 5.51k]
  ------------------
  435|    675|        {
  436|    675|            compiler->addError(*prop, prop->name + " must have exactly 1 argument");
  437|    675|        }
  438|  5.51k|        else
  439|  5.51k|        {
  440|  5.51k|            if (getValue(prop->values.front(), val))
  ------------------
  |  Branch (440:17): [True: 401, False: 5.10k]
  ------------------
  441|    401|                return true;
  442|  5.10k|            else
  443|  5.10k|                compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name);
  444|  5.51k|        }
  445|       |
  446|  5.78k|        return false;
  447|  6.18k|    }
OgreScriptTranslator.cpp:_ZN4OgreL10_getVectorINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbNS1_21__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEESD_RNS1_6vectorIT_NS5_ISF_EEEEm:
  452|  66.8k|    {
  453|  66.8k|        vals.reserve(count);
  454|  66.8k|        size_t n = 0;
  455|  2.25M|        while (n < count)
  ------------------
  |  Branch (455:16): [True: 2.19M, False: 61.2k]
  ------------------
  456|  2.19M|        {
  457|  2.19M|            if (i != end)
  ------------------
  |  Branch (457:17): [True: 2.19M, False: 0]
  ------------------
  458|  2.19M|            {
  459|  2.19M|                T v;
  460|  2.19M|                if (!getValue(*i++, v))
  ------------------
  |  Branch (460:21): [True: 5.62k, False: 2.18M]
  ------------------
  461|  5.62k|                    return false;
  462|  2.18M|                vals.push_back(v);
  463|  2.18M|            }
  464|  2.18M|            ++n;
  465|  2.18M|        }
  466|       |
  467|  61.2k|        vals.resize(count);
  468|  61.2k|        return true;
  469|  66.8k|    }
OgreScriptTranslator.cpp:_ZN4OgreL10_getVectorIdEEbNSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEES7_RNS1_6vectorIT_NS1_9allocatorIS9_EEEEm:
  452|     30|    {
  453|     30|        vals.reserve(count);
  454|     30|        size_t n = 0;
  455|     85|        while (n < count)
  ------------------
  |  Branch (455:16): [True: 59, False: 26]
  ------------------
  456|     59|        {
  457|     59|            if (i != end)
  ------------------
  |  Branch (457:17): [True: 8, False: 51]
  ------------------
  458|      8|            {
  459|      8|                T v;
  460|      8|                if (!getValue(*i++, v))
  ------------------
  |  Branch (460:21): [True: 4, False: 4]
  ------------------
  461|      4|                    return false;
  462|      4|                vals.push_back(v);
  463|      4|            }
  464|     55|            ++n;
  465|     55|        }
  466|       |
  467|     26|        vals.resize(count);
  468|     26|        return true;
  469|     30|    }
OgreScriptTranslator.cpp:_ZN4OgreL10_getVectorIjEEbNSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEES7_RNS1_6vectorIT_NS1_9allocatorIS9_EEEEm:
  452|    107|    {
  453|    107|        vals.reserve(count);
  454|    107|        size_t n = 0;
  455|  16.5k|        while (n < count)
  ------------------
  |  Branch (455:16): [True: 16.5k, False: 34]
  ------------------
  456|  16.5k|        {
  457|  16.5k|            if (i != end)
  ------------------
  |  Branch (457:17): [True: 96, False: 16.4k]
  ------------------
  458|     96|            {
  459|     96|                T v;
  460|     96|                if (!getValue(*i++, v))
  ------------------
  |  Branch (460:21): [True: 73, False: 23]
  ------------------
  461|     73|                    return false;
  462|     23|                vals.push_back(v);
  463|     23|            }
  464|  16.4k|            ++n;
  465|  16.4k|        }
  466|       |
  467|     34|        vals.resize(count);
  468|     34|        return true;
  469|    107|    }
OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_21CompositionTargetPass9InputModeEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_:
  433|  3.48k|    {
  434|  3.48k|        if (prop->values.size() != 1)
  ------------------
  |  Branch (434:13): [True: 628, False: 2.85k]
  ------------------
  435|    628|        {
  436|    628|            compiler->addError(*prop, prop->name + " must have exactly 1 argument");
  437|    628|        }
  438|  2.85k|        else
  439|  2.85k|        {
  440|  2.85k|            if (getValue(prop->values.front(), val))
  ------------------
  |  Branch (440:17): [True: 1.77k, False: 1.08k]
  ------------------
  441|  1.77k|                return true;
  442|  1.08k|            else
  443|  1.08k|                compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name);
  444|  2.85k|        }
  445|       |
  446|  1.71k|        return false;
  447|  3.48k|    }
OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_16StencilOperationEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_:
  433|  3.77k|    {
  434|  3.77k|        if (prop->values.size() != 1)
  ------------------
  |  Branch (434:13): [True: 742, False: 3.03k]
  ------------------
  435|    742|        {
  436|    742|            compiler->addError(*prop, prop->name + " must have exactly 1 argument");
  437|    742|        }
  438|  3.03k|        else
  439|  3.03k|        {
  440|  3.03k|            if (getValue(prop->values.front(), val))
  ------------------
  |  Branch (440:17): [True: 1.90k, False: 1.12k]
  ------------------
  441|  1.90k|                return true;
  442|  1.12k|            else
  443|  1.12k|                compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name);
  444|  3.03k|        }
  445|       |
  446|  1.87k|        return false;
  447|  3.77k|    }

_ZN4Ogre20ShadowTextureManagerC2Ev:
   64|      1|        : mCount(0)
   65|      1|    {
   66|       |
   67|      1|    }

_ZN4Ogre15SkeletonManagerC2Ev:
   45|      1|    {
   46|      1|        mLoadOrder = 300.0f;
   47|      1|        mResourceType = "Skeleton";
   48|       |
   49|      1|        ResourceGroupManager::getSingleton()._registerResourceManager(mResourceType, this);
   50|      1|    }

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

_ZN4Ogre10StringUtil4trimERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbb:
   42|      2|    {
   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|      2|        static const String delims = " \t\r\n";
   67|      2|        if(right)
  ------------------
  |  Branch (67:12): [True: 2, False: 0]
  ------------------
   68|      2|            str.erase(str.find_last_not_of(delims)+1); // trim right
   69|      2|        if(left)
  ------------------
  |  Branch (69:12): [True: 2, False: 0]
  ------------------
   70|      2|            str.erase(0, str.find_first_not_of(delims)); // trim left
   71|      2|    }
_ZN4Ogre10StringUtil11toLowerCaseERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  203|  7.94k|    {
  204|  7.94k|        std::transform(
  205|  7.94k|            str.begin(),
  206|  7.94k|            str.end(),
  207|  7.94k|            str.begin(),
  208|  7.94k|            tolower);
  209|  7.94k|    }
_ZN4Ogre10StringUtil11toUpperCaseERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  213|  28.1k|    {
  214|  28.1k|        std::transform(
  215|  28.1k|            str.begin(),
  216|  28.1k|            str.end(),
  217|  28.1k|            str.begin(),
  218|  28.1k|            toupper);
  219|  28.1k|    }
_ZN4Ogre10StringUtil17splitBaseFilenameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS7_SA_:
  382|  6.64k|    {
  383|  6.64k|        size_t i = fullName.find_last_of('.');
  384|  6.64k|        if (i == Ogre::String::npos)
  ------------------
  |  Branch (384:13): [True: 2.10k, False: 4.53k]
  ------------------
  385|  2.10k|        {
  386|  2.10k|            outExtention.clear();
  387|  2.10k|            outBasename = fullName;
  388|  2.10k|        }
  389|  4.53k|        else
  390|  4.53k|        {
  391|  4.53k|            outExtention = fullName.substr(i+1);
  392|  4.53k|            outBasename = fullName.substr(0, i);
  393|  4.53k|        }
  394|  6.64k|    }
_ZN4Ogre10StringUtil5matchERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_b:
  405|   198k|    {
  406|   198k|        String tmpStr = str;
  407|   198k|        String tmpPattern = pattern;
  408|   198k|        if (!caseSensitive)
  ------------------
  |  Branch (408:13): [True: 0, False: 198k]
  ------------------
  409|      0|        {
  410|      0|            StringUtil::toLowerCase(tmpStr);
  411|      0|            StringUtil::toLowerCase(tmpPattern);
  412|      0|        }
  413|       |
  414|   198k|        String::const_iterator strIt = tmpStr.begin();
  415|   198k|        String::const_iterator patIt = tmpPattern.begin();
  416|   198k|        String::const_iterator lastWildCardIt = tmpPattern.end();
  417|   198k|        String::const_iterator lastWildCardStrIt = tmpStr.end();
  418|  1.15M|        while (strIt != tmpStr.end())
  ------------------
  |  Branch (418:16): [True: 1.03M, False: 127k]
  ------------------
  419|  1.03M|        {
  420|  1.03M|            if (patIt != tmpPattern.end() && *patIt == '*')
  ------------------
  |  Branch (420:17): [True: 482k, False: 548k]
  |  Branch (420:17): [True: 77.3k, False: 953k]
  |  Branch (420:46): [True: 77.3k, False: 404k]
  ------------------
  421|  77.3k|            {
  422|       |                // remember the wildcard, let it match nothing for now
  423|  77.3k|                lastWildCardIt = patIt;
  424|  77.3k|                lastWildCardStrIt = strIt;
  425|  77.3k|                ++patIt;
  426|  77.3k|            }
  427|   953k|            else if (patIt != tmpPattern.end() && *patIt == *strIt)
  ------------------
  |  Branch (427:22): [True: 404k, False: 548k]
  |  Branch (427:22): [True: 287k, False: 665k]
  |  Branch (427:51): [True: 287k, False: 116k]
  ------------------
  428|   287k|            {
  429|   287k|                ++patIt;
  430|   287k|                ++strIt;
  431|   287k|            }
  432|   665k|            else if (lastWildCardIt != tmpPattern.end())
  ------------------
  |  Branch (432:22): [True: 594k, False: 70.9k]
  ------------------
  433|   594k|            {
  434|       |                // let the last wildcard match one more character and retry from there
  435|   594k|                patIt = lastWildCardIt + 1;
  436|   594k|                strIt = ++lastWildCardStrIt;
  437|   594k|            }
  438|  70.9k|            else
  439|  70.9k|            {
  440|       |                // no wildcards left
  441|  70.9k|                return false;
  442|  70.9k|            }
  443|  1.03M|        }
  444|       |        // the string is consumed, only wildcards may remain in the pattern
  445|   172k|        while (patIt != tmpPattern.end() && *patIt == '*')
  ------------------
  |  Branch (445:16): [True: 87.7k, False: 85.2k]
  |  Branch (445:16): [True: 45.7k, False: 127k]
  |  Branch (445:45): [True: 45.7k, False: 41.9k]
  ------------------
  446|  45.7k|            ++patIt;
  447|       |
  448|   127k|        return patIt == tmpPattern.end();
  449|       |
  450|   198k|    }
_ZN4Ogre10StringUtil6formatEPKcz:
  467|  19.6M|    {
  468|       |        // try to use a stack buffer and fall back to heap for large strings
  469|  19.6M|        char sbuf[1024];
  470|  19.6M|        size_t bsize = sizeof(sbuf);
  471|  19.6M|        std::vector<char> hbuf;
  472|  19.6M|        char* pbuf = sbuf;
  473|       |
  474|  19.7M|        while (true)
  ------------------
  |  Branch (474:16): [True: 19.7M, Folded]
  ------------------
  475|  19.7M|        {
  476|  19.7M|            va_list va;
  477|  19.7M|            va_start(va, fmt);
  478|  19.7M|            int len = vsnprintf(pbuf, bsize, fmt, va);
  479|  19.7M|            va_end(va);
  480|       |
  481|  19.7M|            OgreAssert(len >= 0, "Check format string for errors");
  ------------------
  |  Branch (481:13): [True: 0, False: 19.7M]
  ------------------
  482|  19.7M|            if (size_t(len) >= bsize)
  ------------------
  |  Branch (482:17): [True: 98.7k, False: 19.6M]
  ------------------
  483|  98.7k|            {
  484|  98.7k|                hbuf.resize(len + 1);
  485|  98.7k|                pbuf = hbuf.data();
  486|  98.7k|                bsize = hbuf.size();
  487|  98.7k|                continue;
  488|  98.7k|            }
  489|  19.6M|            pbuf[bsize - 1] = 0;
  490|  19.6M|            return String(pbuf, len);
  491|  19.7M|        }
  492|  19.6M|    }

_ZN4Ogre15StringConverter8toStringERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE:
  239|  66.8k|    {
  240|  66.8k|        StringStream stream;
  241|  66.8k|        StringVector::const_iterator i, iend, ibegin;
  242|  66.8k|        ibegin = val.begin();
  243|  66.8k|        iend = val.end();
  244|  2.25M|        for (i = ibegin; i != iend; ++i)
  ------------------
  |  Branch (244:26): [True: 2.18M, False: 66.8k]
  ------------------
  245|  2.18M|        {
  246|  2.18M|            if (i != ibegin)
  ------------------
  |  Branch (246:17): [True: 2.12M, False: 63.1k]
  ------------------
  247|  2.12M|                stream << " ";
  248|       |
  249|  2.18M|            stream << *i; 
  250|  2.18M|        }
  251|  66.8k|        return stream.str();
  252|  66.8k|    }
_ZN4Ogre15StringConverter5parseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERf:
  263|   319k|    {
  264|   319k|        char* end;
  265|   319k|        auto tmp = (float)strtod_l(val.c_str(), &end, _numLocale);
  266|   319k|        return assignValid(val.c_str() != end, tmp, ret);
  267|   319k|    }
_ZN4Ogre15StringConverter5parseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERd:
  269|      8|    {
  270|      8|        char* end;
  271|      8|        auto tmp = strtod_l(val.c_str(), &end, _numLocale);
  272|      8|        return assignValid(val.c_str() != end, tmp, ret);
  273|      8|    }
_ZN4Ogre15StringConverter5parseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERi:
  276|  52.8k|    {
  277|  52.8k|        char* end;
  278|  52.8k|        auto tmp = (int32)strtol_l(val.c_str(), &end, 0, _numLocale);
  279|  52.8k|        return assignValid(val.c_str() != end, tmp, ret);
  280|  52.8k|    }
_ZN4Ogre15StringConverter5parseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERj:
  303|  75.7k|    {
  304|  75.7k|        char* end;
  305|  75.7k|        auto tmp = (uint32)strtoul_l(val.c_str(), &end, 0, _numLocale);
  306|  75.7k|        return assignValid(val.c_str() != end, tmp, ret);
  307|  75.7k|    }
OgreStringConverter.cpp:_ZN4OgreL11assignValidIfEEbbRKT_RS1_:
  256|   319k|    {
  257|   319k|        if (valid)
  ------------------
  |  Branch (257:13): [True: 245k, False: 74.6k]
  ------------------
  258|   245k|            ret = val;
  259|   319k|        return valid;
  260|   319k|    }
OgreStringConverter.cpp:_ZN4OgreL11assignValidIdEEbbRKT_RS1_:
  256|      8|    {
  257|      8|        if (valid)
  ------------------
  |  Branch (257:13): [True: 4, False: 4]
  ------------------
  258|      4|            ret = val;
  259|      8|        return valid;
  260|      8|    }
OgreStringConverter.cpp:_ZN4OgreL11assignValidIiEEbbRKT_RS1_:
  256|  52.8k|    {
  257|  52.8k|        if (valid)
  ------------------
  |  Branch (257:13): [True: 30.2k, False: 22.6k]
  ------------------
  258|  30.2k|            ret = val;
  259|  52.8k|        return valid;
  260|  52.8k|    }
OgreStringConverter.cpp:_ZN4OgreL11assignValidIjEEbbRKT_RS1_:
  256|  75.7k|    {
  257|  75.7k|        if (valid)
  ------------------
  |  Branch (257:13): [True: 47.9k, False: 27.8k]
  ------------------
  258|  47.9k|            ret = val;
  259|  75.7k|        return valid;
  260|  75.7k|    }

_ZN4Ogre15ParamDictionaryC2Ev:
   36|      4|    ParamDictionary::ParamDictionary() {}
_ZN4Ogre15ParamDictionaryD2Ev:
   37|      8|    ParamDictionary::~ParamDictionary() {}
_ZN4Ogre15ParamDictionary15getParamCommandERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   40|  8.21k|    {
   41|  8.21k|        ParamCommandMap::iterator i = mParamCommands.find(name);
   42|  8.21k|        if (i != mParamCommands.end())
  ------------------
  |  Branch (42:13): [True: 8.15k, False: 59]
  ------------------
   43|  8.15k|        {
   44|  8.15k|            return i->second;
   45|  8.15k|        }
   46|     59|        else
   47|     59|        {
   48|     59|            return 0;
   49|     59|        }
   50|  8.21k|    }
_ZN4Ogre15ParamDictionary12addParameterERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_12ParamCommandE:
   66|     20|    {
   67|     20|        mParamDefs.push_back(name);
   68|     20|        mParamCommands[name] = paramCmd;
   69|     20|    }
_ZN4Ogre15StringInterface21createParamDictionaryERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   72|  15.8M|    {
   73|  15.8M|        OGRE_LOCK_MUTEX( msDictionaryMutex );
   74|       |
   75|  15.8M|        ParamDictionaryMap::iterator it = msDictionary.find(className);
   76|       |
   77|  15.8M|        if ( it == msDictionary.end() )
  ------------------
  |  Branch (77:14): [True: 4, False: 15.8M]
  ------------------
   78|      4|        {
   79|      4|            mParamDict = &msDictionary.insert( std::make_pair( className, ParamDictionary() ) ).first->second;
   80|      4|            mParamDictName = className;
   81|      4|            return true;
   82|      4|        }
   83|  15.8M|        else
   84|  15.8M|        {
   85|  15.8M|            mParamDict = &it->second;
   86|  15.8M|            mParamDictName = className;
   87|  15.8M|            return false;
   88|  15.8M|        }
   89|  15.8M|    }
_ZN4Ogre15StringInterface12setParameterERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
  124|  9.07k|    {
  125|       |        // Get dictionary
  126|  9.07k|        ParamDictionary* dict = getParamDictionary();
  127|       |
  128|  9.07k|        if (dict)
  ------------------
  |  Branch (128:13): [True: 8.21k, False: 858]
  ------------------
  129|  8.21k|        {
  130|       |            // Look up command object
  131|  8.21k|            ParamCommand* cmd = dict->getParamCommand(name);
  132|  8.21k|            if (cmd)
  ------------------
  |  Branch (132:17): [True: 8.15k, False: 59]
  ------------------
  133|  8.15k|            {
  134|  8.15k|                cmd->doSet(this, value);
  135|  8.15k|                return true;
  136|  8.15k|            }
  137|  8.21k|        }
  138|       |        // Fallback
  139|    917|        return false;
  140|  9.07k|    }

_ZN4Ogre9TechniqueC2EPNS_8MaterialE:
   35|  3.49M|        : mParent(parent), mIlluminationPassesCompilationPhase(IPS_NOT_COMPILED), mIsSupported(false), mLodIndex(0), mSchemeIndex(0)
   36|  3.49M|    {
   37|       |        // See above, defaults to unsupported until examined
   38|  3.49M|    }
_ZN4Ogre9TechniqueD2Ev:
   48|  3.49M|    {
   49|  3.49M|        removeAllPasses();
   50|  3.49M|        clearIlluminationPasses();
   51|  3.49M|    }
_ZNK4Ogre9Technique11isSupportedEv:
   54|  3.45M|    {
   55|  3.45M|        return mIsSupported;
   56|  3.45M|    }
_ZN4Ogre9Technique10createPassEv:
  310|  69.5k|    {
  311|       |        Pass* newPass = OGRE_NEW Pass(this, static_cast<unsigned short>(mPasses.size()));
  312|  69.5k|        mPasses.push_back(newPass);
  313|  69.5k|        return newPass;
  314|  69.5k|    }
_ZN4Ogre9Technique15removeAllPassesEv:
  341|  6.94M|    {
  342|  6.94M|        for (auto *p : mPasses)
  ------------------
  |  Branch (342:22): [True: 3.54M, False: 6.94M]
  ------------------
  343|  3.54M|        {
  344|  3.54M|            p->queueForDeletion();
  345|  3.54M|        }
  346|  6.94M|        mPasses.clear();
  347|  6.94M|    }
_ZN4Ogre9TechniqueaSERKS0_:
  398|  3.45M|    {
  399|  3.45M|        if (this == &rhs)
  ------------------
  |  Branch (399:13): [True: 0, False: 3.45M]
  ------------------
  400|      0|            return *this;
  401|       |
  402|  3.45M|        mName = rhs.mName;
  403|  3.45M|        this->mIsSupported = rhs.mIsSupported;
  404|  3.45M|        this->mLodIndex = rhs.mLodIndex;
  405|  3.45M|        this->mSchemeIndex = rhs.mSchemeIndex;
  406|  3.45M|        this->mShadowCasterMaterial = rhs.mShadowCasterMaterial;
  407|  3.45M|        this->mShadowCasterMaterialName = rhs.mShadowCasterMaterialName;
  408|  3.45M|        this->mShadowReceiverMaterial = rhs.mShadowReceiverMaterial;
  409|  3.45M|        this->mShadowReceiverMaterialName = rhs.mShadowReceiverMaterialName;
  410|  3.45M|        this->mGPUVendorRules = rhs.mGPUVendorRules;
  411|  3.45M|        this->mGPUDeviceNameRules = rhs.mGPUDeviceNameRules;
  412|       |
  413|       |        // copy passes
  414|  3.45M|        removeAllPasses();
  415|  3.45M|        for (auto *rp : rhs.mPasses)
  ------------------
  |  Branch (415:23): [True: 3.47M, False: 3.45M]
  ------------------
  416|  3.47M|        {
  417|  3.47M|            Pass* p = OGRE_NEW Pass(this, rp->getIndex(), *(rp));
  418|  3.47M|            mPasses.push_back(p);
  419|  3.47M|        }
  420|       |        // Compile for categorised illumination on demand
  421|  3.45M|        clearIlluminationPasses();
  422|  3.45M|        mIlluminationPassesCompilationPhase = IPS_NOT_COMPILED;
  423|  3.45M|        return *this;
  424|  3.45M|    }
_ZNK4Ogre9Technique8isLoadedEv:
  576|  3.32M|    {
  577|       |        // Only supported technique will be loaded
  578|  3.32M|        return mParent->isLoaded() && mIsSupported;
  ------------------
  |  Branch (578:16): [True: 0, False: 3.32M]
  |  Branch (578:39): [True: 0, False: 0]
  ------------------
  579|  3.32M|    }
_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]
  |  |  ------------------
  ------------------
_ZN4Ogre9Technique7setNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  673|  26.0k|    {
  674|  26.0k|        mName = name;
  675|  26.0k|    }
_ZN4Ogre9Technique21_notifyNeedsRecompileEv:
  680|   103k|    {
  681|       |        // Disable require to recompile when splitting illumination passes
  682|   103k|        if (mIlluminationPassesCompilationPhase != IPS_COMPILE_DISABLED)
  ------------------
  |  Branch (682:13): [True: 103k, False: 0]
  ------------------
  683|   103k|        {
  684|   103k|            mParent->_notifyNeedsRecompile();
  685|   103k|        }
  686|   103k|    }
_ZN4Ogre9Technique11setLodIndexEt:
  689|    192|    {
  690|    192|        mLodIndex = index;
  691|    192|        _notifyNeedsRecompile();
  692|    192|    }
_ZN4Ogre9Technique13setSchemeNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  695|  7.38k|    {
  696|  7.38k|        mSchemeIndex = MaterialManager::getSingleton()._getSchemeIndex(schemeName);
  697|  7.38k|        _notifyNeedsRecompile();
  698|  7.38k|    }
_ZN4Ogre9Technique23clearIlluminationPassesEv:
  958|  6.94M|    {
  959|  6.94M|        if(MaterialManager::getSingletonPtr())
  ------------------
  |  Branch (959:12): [True: 6.94M, False: 0]
  ------------------
  960|  6.94M|            MaterialManager::getSingleton()._notifyBeforeIlluminationPassesCleared(this);
  961|       |
  962|  6.94M|        for (auto *i : mIlluminationPasses)
  ------------------
  |  Branch (962:22): [True: 0, False: 6.94M]
  ------------------
  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|  6.94M|        mIlluminationPasses.clear();
  971|  6.94M|    }
_ZNK4Ogre9Technique16getResourceGroupEv:
  995|  19.7M|    {
  996|  19.7M|        return mParent->getGroup();
  997|  19.7M|    }
_ZNK4Ogre9Technique23getShadowCasterMaterialEv:
 1000|  19.4k|    {
 1001|  19.4k|        return mShadowCasterMaterial;
 1002|  19.4k|    }
_ZN4Ogre9Technique23setShadowCasterMaterialENS_9SharedPtrINS_8MaterialEEE:
 1005|  20.0k|    {
 1006|  20.0k|        if (!val)
  ------------------
  |  Branch (1006:13): [True: 1.88k, False: 18.1k]
  ------------------
 1007|  1.88k|        {
 1008|  1.88k|            mShadowCasterMaterial.reset();
 1009|  1.88k|            mShadowCasterMaterialName.clear();
 1010|  1.88k|        }
 1011|  18.1k|        else
 1012|  18.1k|        {
 1013|  18.1k|            if(val.get() == mParent)
  ------------------
  |  Branch (1013:16): [True: 552, False: 17.6k]
  ------------------
 1014|  18.1k|                OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Using parent material is not allowed");
 1015|       |
 1016|       |            // shadow caster material should never receive shadows
 1017|  17.6k|            val->setReceiveShadows(false); // should we warn if this is not set?
 1018|  17.6k|            mShadowCasterMaterial = val;
 1019|  17.6k|            mShadowCasterMaterialName = val->getName();
 1020|  17.6k|        }
 1021|  20.0k|    }
_ZN4Ogre9Technique23setShadowCasterMaterialERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1024|  3.04k|    {
 1025|  3.04k|        setShadowCasterMaterial(MaterialManager::getSingleton().getByName(name));
 1026|       |        // remember the name, even if it is not created yet
 1027|  3.04k|        mShadowCasterMaterialName = name;
 1028|  3.04k|    }
_ZNK4Ogre9Technique25getShadowReceiverMaterialEv:
 1031|  3.17k|    {
 1032|  3.17k|        return mShadowReceiverMaterial;
 1033|  3.17k|    }
_ZN4Ogre9Technique25setShadowReceiverMaterialENS_9SharedPtrINS_8MaterialEEE:
 1036|  2.37k|    {
 1037|  2.37k|        if (!val)
  ------------------
  |  Branch (1037:13): [True: 1.33k, False: 1.04k]
  ------------------
 1038|  1.33k|        {
 1039|  1.33k|            mShadowReceiverMaterial.reset();
 1040|  1.33k|            mShadowReceiverMaterialName.clear();
 1041|  1.33k|        }
 1042|  1.04k|        else
 1043|  1.04k|        {
 1044|  1.04k|            if(val.get() == mParent)
  ------------------
  |  Branch (1044:16): [True: 325, False: 720]
  ------------------
 1045|  1.04k|                OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Using parent material is not allowed");
 1046|       |
 1047|    720|            mShadowReceiverMaterial = val;
 1048|    720|            mShadowReceiverMaterialName = val->getName();
 1049|    720|        }
 1050|  2.37k|    }
_ZN4Ogre9Technique25setShadowReceiverMaterialERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1053|  2.17k|    {
 1054|  2.17k|        setShadowReceiverMaterial(MaterialManager::getSingleton().getByName(name));
 1055|  2.17k|        mShadowReceiverMaterialName = name;
 1056|  2.17k|    }
_ZN4Ogre9Technique16addGPUVendorRuleERKNS0_13GPUVendorRuleE:
 1064|  2.33k|    {
 1065|       |        // remove duplicates
 1066|  2.33k|        removeGPUVendorRule(rule.vendor);
 1067|  2.33k|        mGPUVendorRules.push_back(rule);
 1068|  2.33k|    }
_ZN4Ogre9Technique19removeGPUVendorRuleENS_9GPUVendorE:
 1071|  2.33k|    {
 1072|  5.56k|        for (GPUVendorRuleList::iterator i = mGPUVendorRules.begin(); i != mGPUVendorRules.end(); )
  ------------------
  |  Branch (1072:71): [True: 3.22k, False: 2.33k]
  ------------------
 1073|  3.22k|        {
 1074|  3.22k|            if (i->vendor == vendor)
  ------------------
  |  Branch (1074:17): [True: 1.70k, False: 1.51k]
  ------------------
 1075|  1.70k|                i = mGPUVendorRules.erase(i);
 1076|  1.51k|            else
 1077|  1.51k|                ++i;
 1078|  3.22k|        }
 1079|  2.33k|    }
_ZN4Ogre9Technique20addGPUDeviceNameRuleERKNS0_17GPUDeviceNameRuleE:
 1093|  6.58k|    {
 1094|       |        // remove duplicates
 1095|  6.58k|        removeGPUDeviceNameRule(rule.devicePattern);
 1096|  6.58k|        mGPUDeviceNameRules.push_back(rule);
 1097|  6.58k|    }
_ZN4Ogre9Technique23removeGPUDeviceNameRuleERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1100|  6.58k|    {
 1101|  19.0k|        for (GPUDeviceNameRuleList::iterator i = mGPUDeviceNameRules.begin(); i != mGPUDeviceNameRules.end(); )
  ------------------
  |  Branch (1101:79): [True: 12.4k, False: 6.58k]
  ------------------
 1102|  12.4k|        {
 1103|  12.4k|            if (i->devicePattern == devicePattern)
  ------------------
  |  Branch (1103:17): [True: 4.16k, False: 8.29k]
  ------------------
 1104|  4.16k|                i = mGPUDeviceNameRules.erase(i);
 1105|  8.29k|            else
 1106|  8.29k|                ++i;
 1107|  12.4k|        }
 1108|  6.58k|    }

_ZN4Ogre7TextureC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE:
   40|  15.8M|        : Resource(creator, name, handle, group, isManual, loader),
   41|       |            // init defaults; can be overridden before load()
   42|  15.8M|            mHeight(512),
   43|  15.8M|            mWidth(512),
   44|  15.8M|            mDepth(1),
   45|  15.8M|            mNumRequestedMipmaps(0),
   46|  15.8M|            mNumMipmaps(0),
   47|  15.8M|            mGamma(1.0f),
   48|  15.8M|            mFSAA(0),
   49|  15.8M|            mFormat(PF_UNKNOWN),
   50|  15.8M|            mUsage(TU_DEFAULT),
   51|  15.8M|            mSrcFormat(PF_UNKNOWN),
   52|  15.8M|            mSrcWidth(0),
   53|  15.8M|            mSrcHeight(0), 
   54|  15.8M|            mSrcDepth(0),
   55|  15.8M|            mTreatLuminanceAsAlpha(false),
   56|  15.8M|            mInternalResourcesCreated(false),
   57|  15.8M|            mMipmapsHardwareGenerated(false),
   58|  15.8M|            mHwGamma(false),
   59|  15.8M|            mTextureType(TEX_TYPE_2D),
   60|  15.8M|            mDesiredIntegerBitDepth(0),
   61|  15.8M|            mDesiredFloatBitDepth(0),
   62|  15.8M|            mDesiredFormat(PF_UNKNOWN)
   63|  15.8M|    {
   64|  15.8M|        if (createParamDictionary("Texture"))
  ------------------
  |  Branch (64:13): [True: 1, False: 15.8M]
  ------------------
   65|      1|        {
   66|       |            // Define the parameters that have to be present to load
   67|       |            // from a generic source; actually there are none, since when
   68|       |            // predeclaring, you use a texture file which includes all the
   69|       |            // information required.
   70|      1|        }
   71|       |
   72|       |        // Set some defaults for default load path
   73|  15.8M|        if (TextureManager::getSingletonPtr())
  ------------------
  |  Branch (73:13): [True: 15.8M, False: 0]
  ------------------
   74|  15.8M|        {
   75|  15.8M|            TextureManager& tmgr = TextureManager::getSingleton();
   76|  15.8M|            setNumMipmaps(tmgr.getDefaultNumMipmaps());
   77|  15.8M|            setDesiredBitDepths(tmgr.getPreferredIntegerBitDepth(), tmgr.getPreferredFloatBitDepth());
   78|  15.8M|        }
   79|       |
   80|       |        
   81|  15.8M|    }
_ZN4Ogre7Texture9setFormatENS_11PixelFormatE:
  118|  37.6k|    {
  119|  37.6k|        mFormat = pf;
  120|  37.6k|        mDesiredFormat = pf;
  121|  37.6k|    }
_ZN4Ogre7Texture19setDesiredBitDepthsEtt:
  149|  15.8M|    {
  150|  15.8M|        mDesiredIntegerBitDepth = integerBits;
  151|  15.8M|        mDesiredFloatBitDepth = floatBits;
  152|  15.8M|    }
_ZN4Ogre7Texture24setTreatLuminanceAsAlphaEb:
  155|  37.6k|    {
  156|  37.6k|        mTreatLuminanceAsAlpha = asAlpha;
  157|  37.6k|    }

_ZN4Ogre14TextureManager15getSingletonPtrEv:
   35|  15.9M|    {
   36|  15.9M|        return msSingleton;
   37|  15.9M|    }
_ZN4Ogre14TextureManager12getSingletonEv:
   39|  35.7M|    {  
   40|       |        assert( msSingleton );  return ( *msSingleton );  
   41|  35.7M|    }
_ZN4Ogre14TextureManagerC2Ev:
   44|      1|         : mPreferredIntegerBitDepth(0)
   45|      1|         , mPreferredFloatBitDepth(0)
   46|      1|         , mDefaultNumMipmaps(MIP_UNLIMITED)
   47|      1|    {
   48|      1|        mResourceType = "Texture";
   49|      1|        mLoadOrder = 75.0f;
   50|       |
   51|       |        // Subclasses should register (when this is fully constructed)
   52|      1|    }
_ZN4Ogre14TextureManager13createSamplerERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   60|  8.18k|    {
   61|  8.18k|        SamplerPtr ret = _createSamplerImpl();
   62|  8.18k|        if(!name.empty())
  ------------------
  |  Branch (62:12): [True: 475, False: 7.70k]
  ------------------
   63|    475|        {
   64|    475|            if (mNamedSamplers.find(name) != mNamedSamplers.end())
  ------------------
  |  Branch (64:17): [True: 69, False: 406]
  ------------------
   65|    475|                OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Sampler '" + name + "' already exists");
   66|    406|            mNamedSamplers[name] = ret;
   67|    406|        }
   68|  8.11k|        return ret;
   69|  8.18k|    }
_ZNK4Ogre14TextureManager10getSamplerERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   73|  9.15k|    {
   74|  9.15k|        static SamplerPtr nullPtr;
   75|  9.15k|        auto it = mNamedSamplers.find(name);
   76|  9.15k|        if(it == mNamedSamplers.end())
  ------------------
  |  Branch (76:12): [True: 8.28k, False: 869]
  ------------------
   77|  8.28k|            return nullPtr;
   78|    869|        return it->second;
   79|  9.15k|    }
_ZNK4Ogre14TextureManager9getByNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_:
   82|  37.6k|    {
   83|  37.6k|        return static_pointer_cast<Texture>(getResourceByName(name, groupName));
   84|  37.6k|    }
_ZNK4Ogre14TextureManager27getPreferredIntegerBitDepthEv:
  245|  15.8M|    {
  246|  15.8M|        return mPreferredIntegerBitDepth;
  247|  15.8M|    }
_ZNK4Ogre14TextureManager25getPreferredFloatBitDepthEv:
  275|  15.8M|    {
  276|  15.8M|        return mPreferredFloatBitDepth;
  277|  15.8M|    }
_ZN4Ogre14TextureManager17getDefaultSamplerEv:
  361|  85.4k|    {
  362|  85.4k|        if(!mDefaultSampler)
  ------------------
  |  Branch (362:12): [True: 1, False: 85.4k]
  ------------------
  363|      1|            mDefaultSampler = createSampler();
  364|       |
  365|  85.4k|        return mDefaultSampler;
  366|  85.4k|    }

_ZN4Ogre7SamplerC2Ev:
   40|  8.18k|        : mBorderColour(ColourValue::Black)
   41|  8.18k|        , mMaxAniso(1)
   42|  8.18k|        , mMipmapBias(0)
   43|  8.18k|        , mMinFilter(FO_LINEAR)
   44|  8.18k|        , mMagFilter(FO_LINEAR)
   45|  8.18k|        , mMipFilter(FO_POINT)
   46|  8.18k|        , mCompareFunc(CMPF_GREATER_EQUAL)
   47|  8.18k|        , mCompareEnabled(false)
   48|  8.18k|        , mDirty(true)
   49|  8.18k|    {
   50|  8.18k|        setAddressingMode(TAM_WRAP);
   51|  8.18k|    }
_ZN4Ogre7SamplerD2Ev:
   52|  7.77k|    Sampler::~Sampler() {}
_ZN4Ogre7Sampler17setAddressingModeERKNS0_17UVWAddressingModeE:
   55|  14.4k|    {
   56|  14.4k|        mAddressMode = uvw;
   57|  14.4k|        mDirty = true;
   58|  14.4k|    }
_ZN4Ogre7Sampler12setFilteringENS_20TextureFilterOptionsE:
   62|  7.33k|    {
   63|  7.33k|        switch (filterType)
  ------------------
  |  Branch (63:17): [True: 7.33k, False: 0]
  ------------------
   64|  7.33k|        {
   65|  5.14k|        case TFO_NONE:
  ------------------
  |  Branch (65:9): [True: 5.14k, False: 2.18k]
  ------------------
   66|  5.14k|            setFiltering(FO_POINT, FO_POINT, FO_NONE);
   67|  5.14k|            break;
   68|    336|        case TFO_BILINEAR:
  ------------------
  |  Branch (68:9): [True: 336, False: 6.99k]
  ------------------
   69|    336|            setFiltering(FO_LINEAR, FO_LINEAR, FO_POINT);
   70|    336|            break;
   71|  1.67k|        case TFO_TRILINEAR:
  ------------------
  |  Branch (71:9): [True: 1.67k, False: 5.65k]
  ------------------
   72|  1.67k|            setFiltering(FO_LINEAR, FO_LINEAR, FO_LINEAR);
   73|  1.67k|            break;
   74|    169|        case TFO_ANISOTROPIC:
  ------------------
  |  Branch (74:9): [True: 169, False: 7.16k]
  ------------------
   75|    169|            setFiltering(FO_ANISOTROPIC, FO_ANISOTROPIC, FO_LINEAR);
   76|    169|            break;
   77|  7.33k|        }
   78|  7.33k|    }
_ZN4Ogre7Sampler12setFilteringENS_13FilterOptionsES1_S1_:
   98|  9.96k|    {
   99|  9.96k|        mMinFilter = minFilter;
  100|  9.96k|        mMagFilter = magFilter;
  101|  9.96k|        mMipFilter = mipFilter;
  102|  9.96k|        mDirty = true;
  103|  9.96k|    }
_ZN4Ogre16TextureUnitStateC2EPNS_4PassE:
  121|  41.4k|        : mCurrentFrame(0)
  122|  41.4k|        , mAnimDuration(0)
  123|  41.4k|        , mUnorderedAccessMipLevel(-1)
  124|  41.4k|        , mGamma(1)
  125|  41.4k|        , mUMod(0)
  126|  41.4k|        , mVMod(0)
  127|  41.4k|        , mUScale(1)
  128|  41.4k|        , mVScale(1)
  129|  41.4k|        , mRotate(0)
  130|  41.4k|        , mTexModMatrix(Matrix4::IDENTITY)
  131|  41.4k|        , mContentType(CONTENT_NAMED)
  132|  41.4k|        , mTextureLoadFailed(false)
  133|  41.4k|        , mRecalcTexMatrix(false)
  134|  41.4k|        , mTextureCoordSetIndex(0)
  135|  41.4k|        , mFramePtrs(1)
  136|  41.4k|        , mSampler(TextureManager::getSingletonPtr() ? TextureManager::getSingleton().getDefaultSampler() : DUMMY_SAMPLER)
  ------------------
  |  Branch (136:20): [True: 41.4k, False: 0]
  ------------------
  137|  41.4k|        , mParent(parent)
  138|  41.4k|        , mAnimController(0)
  139|  41.4k|    {
  140|  41.4k|        mColourBlendMode.blendType = LBT_COLOUR;
  141|  41.4k|        mAlphaBlendMode.operation = LBX_MODULATE;
  142|  41.4k|        mAlphaBlendMode.blendType = LBT_ALPHA;
  143|  41.4k|        mAlphaBlendMode.source1 = LBS_TEXTURE;
  144|  41.4k|        mAlphaBlendMode.source2 = LBS_CURRENT;
  145|  41.4k|        setColourOperation(LBO_MODULATE);
  146|       |
  147|  41.4k|        if( Pass::getHashFunction() == Pass::getBuiltinHashFunction( Pass::MIN_TEXTURE_CHANGE ) )
  ------------------
  |  Branch (147:13): [True: 0, False: 41.4k]
  ------------------
  148|      0|        {
  149|      0|            mParent->_dirtyHash();
  150|      0|        }
  151|       |
  152|  41.4k|    }
_ZN4Ogre16TextureUnitStateC2EPNS_4PassERKS0_:
  156|  3.18M|    {
  157|  3.18M|        mParent = parent;
  158|  3.18M|        mAnimController = 0;
  159|  3.18M|        *this = oth;
  160|  3.18M|    }
_ZN4Ogre16TextureUnitStateD2Ev:
  171|  3.22M|    {
  172|       |        // Unload ensure all controllers destroyed
  173|  3.22M|        _unload();
  174|  3.22M|    }
_ZN4Ogre16TextureUnitStateaSERKS0_:
  178|  3.18M|    {
  179|  3.18M|        if (this == &oth)
  ------------------
  |  Branch (179:13): [True: 0, False: 3.18M]
  ------------------
  180|      0|            return *this;
  181|       |
  182|  3.18M|        assert(mAnimController == 0);
  183|  3.18M|        removeAllEffects();
  184|       |
  185|       |        // copy basic members (int's, real's)
  186|  3.18M|        memcpy( (uchar*)this, &oth, (const uchar *)(&oth.mFramePtrs) - (const uchar *)(&oth) );
  187|       |        // copy complex members
  188|  3.18M|        mFramePtrs = oth.mFramePtrs;
  189|  3.18M|        mSampler = oth.mSampler;
  190|  3.18M|        mName    = oth.mName;
  191|  3.18M|        mEffects = oth.mEffects;
  192|       |
  193|  3.18M|        mCompositorRefName = oth.mCompositorRefName;
  194|  3.18M|        mCompositorRefTexName = oth.mCompositorRefTexName;
  195|       |        // Can't sharing controllers with other TUS, reset to null to avoid potential bug.
  196|  3.18M|        for (auto & e : mEffects)
  ------------------
  |  Branch (196:23): [True: 5.69M, False: 3.18M]
  ------------------
  197|  5.69M|        {
  198|  5.69M|            e.second.controller = 0;
  199|  5.69M|        }
  200|       |
  201|       |        // Load immediately if Material loaded
  202|  3.18M|        if (isLoaded())
  ------------------
  |  Branch (202:13): [True: 0, False: 3.18M]
  ------------------
  203|      0|        {
  204|      0|            _load();
  205|      0|        }
  206|       |
  207|       |        // Tell parent to recalculate hash
  208|  3.18M|        if( Pass::getHashFunction() == Pass::getBuiltinHashFunction( Pass::MIN_TEXTURE_CHANGE ) )
  ------------------
  |  Branch (208:13): [True: 0, False: 3.18M]
  ------------------
  209|      0|        {
  210|      0|            mParent->_dirtyHash();
  211|      0|        }
  212|       |
  213|  3.18M|        return *this;
  214|  3.18M|    }
_ZN4Ogre16TextureUnitState14setTextureNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11TextureTypeE:
  232|  39.7k|    {
  233|  39.7k|        TexturePtr tex = retrieveTexture(name);
  234|       |
  235|  39.7k|        if(!tex)
  ------------------
  |  Branch (235:12): [True: 0, False: 39.7k]
  ------------------
  236|      0|            return;
  237|       |
  238|  39.7k|        tex->setTextureType(texType);
  239|  39.7k|        setTexture(tex);
  240|  39.7k|    }
_ZN4Ogre16TextureUnitState10setTextureERKNS_9SharedPtrINS_7TextureEEE:
  243|  43.4k|    {
  244|  43.4k|        if (!texPtr)
  ------------------
  |  Branch (244:13): [True: 0, False: 43.4k]
  ------------------
  245|      0|        {
  246|      0|            OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND,
  247|      0|                "Texture Pointer is empty.",
  248|      0|                "TextureUnitState::setTexture");
  249|      0|        }
  250|       |
  251|  43.4k|        setContentType(CONTENT_NAMED);
  252|  43.4k|        mTextureLoadFailed = false;
  253|       |        
  254|  43.4k|        if (texPtr->getTextureType() == TEX_TYPE_EXTERNAL_OES)
  ------------------
  |  Branch (254:13): [True: 0, False: 43.4k]
  ------------------
  255|      0|        {
  256|      0|            setTextureAddressingMode( TAM_CLAMP );
  257|      0|            setTextureFiltering(FT_MIP, FO_NONE);
  258|      0|        }
  259|       |
  260|  43.4k|        mFramePtrs.resize(1);
  261|  43.4k|        mFramePtrs[0] = texPtr;
  262|       |
  263|  43.4k|        mCurrentFrame = 0;
  264|       |
  265|       |        // Load immediately ?
  266|  43.4k|        if (isLoaded())
  ------------------
  |  Branch (266:13): [True: 0, False: 43.4k]
  ------------------
  267|      0|        {
  268|      0|            _load(); // reload
  269|      0|        }
  270|       |        // Tell parent to recalculate hash
  271|  43.4k|        if( Pass::getHashFunction() == Pass::getBuiltinHashFunction( Pass::MIN_TEXTURE_CHANGE ) )
  ------------------
  |  Branch (271:13): [True: 0, False: 43.4k]
  ------------------
  272|      0|        {
  273|      0|            mParent->_dirtyHash();
  274|      0|        }
  275|  43.4k|    }
_ZN4Ogre16TextureUnitState14setContentTypeENS0_11ContentTypeE:
  278|  60.6k|    {
  279|  60.6k|        mContentType = ct;
  280|  60.6k|    }
_ZNK4Ogre16TextureUnitState14getTextureTypeEv:
  288|    962|    {
  289|    962|        return !mFramePtrs[0] ? TEX_TYPE_2D : mFramePtrs[0]->getTextureType();
  ------------------
  |  Branch (289:16): [True: 577, False: 385]
  ------------------
  290|    962|    }
_ZN4Ogre16TextureUnitState22setAnimatedTextureNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmf:
  356|  6.64k|    {
  357|  6.64k|        String baseName, ext;
  358|  6.64k|        StringUtil::splitBaseFilename(name, baseName, ext);
  359|       |
  360|  6.64k|        std::vector<String> names(numFrames);
  361|  19.5M|        for (uint32 i = 0; i < names.size(); ++i)
  ------------------
  |  Branch (361:28): [True: 19.5M, False: 6.64k]
  ------------------
  362|  19.5M|        {
  363|  19.5M|            names[i] = StringUtil::format("%s_%u.%s", baseName.c_str(), i, ext.c_str());
  364|  19.5M|        }
  365|       |
  366|  6.64k|        setAnimatedTextureName(names, duration);
  367|  6.64k|    }
_ZN4Ogre16TextureUnitState22setAnimatedTextureNameEPKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmf:
  370|  9.75k|    {
  371|  9.75k|        OgreAssert(numFrames > 0, "numFrames must be greater than 0");
  ------------------
  |  Branch (371:9): [True: 1, False: 9.75k]
  ------------------
  372|  9.75k|        setContentType(CONTENT_NAMED);
  373|  9.75k|        mTextureLoadFailed = false;
  374|       |
  375|       |        // resize pointers, but don't populate until needed
  376|  9.75k|        mFramePtrs.resize(numFrames);
  377|  9.75k|        mAnimDuration = duration;
  378|  9.75k|        mCurrentFrame = 0;
  379|       |
  380|  19.6M|        for (unsigned int i = 0; i < mFramePtrs.size(); ++i)
  ------------------
  |  Branch (380:34): [True: 19.6M, False: 9.75k]
  ------------------
  381|  19.6M|        {
  382|  19.6M|            mFramePtrs[i] = retrieveTexture(names[i]);
  383|  19.6M|        }
  384|       |
  385|       |        // Load immediately if Material loaded
  386|  9.75k|        if (isLoaded())
  ------------------
  |  Branch (386:13): [True: 0, False: 9.75k]
  ------------------
  387|      0|        {
  388|      0|            _load();
  389|      0|        }
  390|       |        // Tell parent to recalculate hash
  391|  9.75k|        if( Pass::getHashFunction() == Pass::getBuiltinHashFunction( Pass::MIN_TEXTURE_CHANGE ) )
  ------------------
  |  Branch (391:13): [True: 0, False: 9.75k]
  ------------------
  392|      0|        {
  393|      0|            mParent->_dirtyHash();
  394|      0|        }
  395|  9.75k|    }
_ZN4Ogre16TextureUnitState18setLayerArrayNamesENS_11TextureTypeERKNSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEE:
  397|  3.69k|    {
  398|  3.69k|        OgreAssert(!names.empty(), "array layers empty");
  ------------------
  |  Branch (398:9): [True: 0, False: 3.69k]
  ------------------
  399|       |
  400|  3.69k|        const char* typeName;
  401|  3.69k|        switch(type)
  402|  3.69k|        {
  403|  3.69k|        case TEX_TYPE_CUBE_MAP:
  ------------------
  |  Branch (403:9): [True: 3.69k, False: 0]
  ------------------
  404|  3.69k|            typeName = "Cube";
  405|  3.69k|            break;
  406|      0|        case TEX_TYPE_2D_ARRAY:
  ------------------
  |  Branch (406:9): [True: 0, False: 3.69k]
  ------------------
  407|      0|            typeName = "Array";
  408|      0|            break;
  409|      0|        case TEX_TYPE_3D:
  ------------------
  |  Branch (409:9): [True: 0, False: 3.69k]
  ------------------
  410|      0|            typeName = "Volume";
  411|      0|            break;
  412|      0|        default:
  ------------------
  |  Branch (412:9): [True: 0, False: 3.69k]
  ------------------
  413|      0|            OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "arrays not possible for this texture type");
  414|      0|            return;
  415|  3.69k|        }
  416|       |
  417|       |        // use hash to auto-name the texture
  418|  3.69k|        uint32 hash = 0;
  419|  3.69k|        for(const String& name : names)
  ------------------
  |  Branch (419:32): [True: 22.1k, False: 3.69k]
  ------------------
  420|  22.1k|            hash = FastHash(name.data(), name.size(), hash);
  421|       |
  422|  3.69k|        auto tex = retrieveTexture(StringUtil::format("%sTex_%x", typeName, hash));
  423|  3.69k|        tex->setTextureType(type);
  424|  3.69k|        tex->setLayerNames(names);
  425|  3.69k|        setTexture(tex);
  426|  3.69k|    }
_ZNK4Ogre16TextureUnitState12getNumFramesEv:
  457|  1.22k|    {
  458|  1.22k|        return (unsigned int)mFramePtrs.size();
  459|  1.22k|    }
_ZN4Ogre16TextureUnitState16setDesiredFormatENS_11PixelFormatE:
  469|  37.6k|    {
  470|  37.6k|        OgreAssert(mFramePtrs[0], "frame must not be blank");
  ------------------
  |  Branch (470:9): [True: 0, False: 37.6k]
  ------------------
  471|  37.6k|        for(auto& frame : mFramePtrs)
  ------------------
  |  Branch (471:25): [True: 37.6k, False: 37.6k]
  ------------------
  472|  37.6k|            frame->setFormat(desiredFormat);
  473|  37.6k|    }
_ZN4Ogre16TextureUnitState13setNumMipmapsEi:
  481|  37.6k|    {
  482|  37.6k|        OgreAssert(mFramePtrs[0], "frame must not be blank");
  ------------------
  |  Branch (482:9): [True: 0, False: 37.6k]
  ------------------
  483|  37.6k|        for (auto& frame : mFramePtrs)
  ------------------
  |  Branch (483:26): [True: 37.6k, False: 37.6k]
  ------------------
  484|  37.6k|            frame->setNumMipmaps(numMipmaps == MIP_DEFAULT
  ------------------
  |  Branch (484:34): [True: 186, False: 37.4k]
  ------------------
  485|  37.6k|                                     ? TextureManager::getSingleton().getDefaultNumMipmaps()
  486|  37.6k|                                     : numMipmaps);
  487|  37.6k|    }
_ZN4Ogre16TextureUnitState10setIsAlphaEb:
  495|  37.6k|    {
  496|  37.6k|        OgreAssert(mFramePtrs[0], "frame must not be blank");
  ------------------
  |  Branch (496:9): [True: 0, False: 37.6k]
  ------------------
  497|  37.6k|        OGRE_IGNORE_DEPRECATED_BEGIN
  498|  37.6k|        for(auto& frame : mFramePtrs)
  ------------------
  |  Branch (498:25): [True: 37.6k, False: 37.6k]
  ------------------
  499|  37.6k|            frame->setTreatLuminanceAsAlpha(isAlpha);
  500|  37.6k|        OGRE_IGNORE_DEPRECATED_END
  501|  37.6k|    }
_ZN4Ogre16TextureUnitState23setHardwareGammaEnabledEb:
  514|  37.6k|    {
  515|  37.6k|        OgreAssert(mFramePtrs[0], "frame must not be blank");
  ------------------
  |  Branch (515:9): [True: 0, False: 37.6k]
  ------------------
  516|  37.6k|        for(auto& frame : mFramePtrs)
  ------------------
  |  Branch (516:25): [True: 37.6k, False: 37.6k]
  ------------------
  517|  37.6k|            frame->setHardwareGammaEnabled(g);
  518|  37.6k|    }
_ZN4Ogre16TextureUnitState18setTextureCoordSetEh:
  531|  1.48k|    {
  532|  1.48k|        mTextureCoordSetIndex = set;
  533|  1.48k|    }
_ZN4Ogre16TextureUnitState20setColourOperationExENS_21LayerBlendOperationExENS_16LayerBlendSourceES2_RKNS_11ColourValueES5_f:
  541|  45.9k|    {
  542|  45.9k|        mColourBlendMode.operation = op;
  543|  45.9k|        mColourBlendMode.source1 = source1;
  544|  45.9k|        mColourBlendMode.source2 = source2;
  545|  45.9k|        mColourBlendMode.colourArg1 = arg1;
  546|  45.9k|        mColourBlendMode.colourArg2 = arg2;
  547|  45.9k|        mColourBlendMode.factor = manualBlend;
  548|  45.9k|    }
_ZN4Ogre16TextureUnitState18setColourOperationENS_19LayerBlendOperationE:
  551|  41.8k|    {
  552|       |        // Set up the multitexture and multipass blending operations
  553|  41.8k|        switch (op)
  ------------------
  |  Branch (553:17): [True: 41.8k, False: 0]
  ------------------
  554|  41.8k|        {
  555|    203|        case LBO_REPLACE:
  ------------------
  |  Branch (555:9): [True: 203, False: 41.6k]
  ------------------
  556|    203|            setColourOperationEx(LBX_SOURCE1, LBS_TEXTURE, LBS_CURRENT);
  557|    203|            setColourOpMultipassFallback(SBF_ONE, SBF_ZERO);
  558|    203|            break;
  559|     66|        case LBO_ADD:
  ------------------
  |  Branch (559:9): [True: 66, False: 41.7k]
  ------------------
  560|     66|            setColourOperationEx(LBX_ADD, LBS_TEXTURE, LBS_CURRENT);
  561|     66|            setColourOpMultipassFallback(SBF_ONE, SBF_ONE);
  562|     66|            break;
  563|  41.4k|        case LBO_MODULATE:
  ------------------
  |  Branch (563:9): [True: 41.4k, False: 357]
  ------------------
  564|  41.4k|            setColourOperationEx(LBX_MODULATE, LBS_TEXTURE, LBS_CURRENT);
  565|  41.4k|            setColourOpMultipassFallback(SBF_DEST_COLOUR, SBF_ZERO);
  566|  41.4k|            break;
  567|     88|        case LBO_ALPHA_BLEND:
  ------------------
  |  Branch (567:9): [True: 88, False: 41.7k]
  ------------------
  568|     88|            setColourOperationEx(LBX_BLEND_TEXTURE_ALPHA, LBS_TEXTURE, LBS_CURRENT);
  569|     88|            setColourOpMultipassFallback(SBF_SOURCE_ALPHA, SBF_ONE_MINUS_SOURCE_ALPHA);
  570|     88|            break;
  571|  41.8k|        }
  572|       |
  573|       |
  574|  41.8k|    }
_ZN4Ogre16TextureUnitState28setColourOpMultipassFallbackENS_16SceneBlendFactorES1_:
  577|  43.9k|    {
  578|  43.9k|        mColourBlendFallbackSrc = sourceFactor;
  579|  43.9k|        mColourBlendFallbackDest = destFactor;
  580|  43.9k|    }
_ZN4Ogre16TextureUnitState17setAlphaOperationENS_21LayerBlendOperationExENS_16LayerBlendSourceES2_fff:
  588|  3.16k|    {
  589|  3.16k|        mAlphaBlendMode.operation = op;
  590|  3.16k|        mAlphaBlendMode.source1 = source1;
  591|  3.16k|        mAlphaBlendMode.source2 = source2;
  592|  3.16k|        mAlphaBlendMode.alphaArg1 = arg1;
  593|  3.16k|        mAlphaBlendMode.alphaArg2 = arg2;
  594|  3.16k|        mAlphaBlendMode.factor = manualBlend;
  595|  3.16k|    }
_ZN4Ogre16TextureUnitState9addEffectENS0_13TextureEffectE:
  598|  81.8k|    {
  599|       |        // Ensure controller pointer is null
  600|  81.8k|        effect.controller = 0;
  601|       |
  602|  81.8k|        if (effect.type != ET_TRANSFORM)
  ------------------
  |  Branch (602:13): [True: 70.2k, False: 11.5k]
  ------------------
  603|  70.2k|        {
  604|       |            // Replace - must be unique
  605|       |            // Search for existing effect of this type
  606|  70.2k|            EffectMap::iterator i = mEffects.find(effect.type);
  607|  70.2k|            if (i != mEffects.end())
  ------------------
  |  Branch (607:17): [True: 6.46k, False: 63.7k]
  ------------------
  608|  6.46k|            {
  609|       |                // Destroy old effect controller if exist
  610|  6.46k|                if (i->second.controller)
  ------------------
  |  Branch (610:21): [True: 0, False: 6.46k]
  ------------------
  611|      0|                {
  612|      0|                    ControllerManager::getSingleton().destroyController(i->second.controller);
  613|      0|                }
  614|       |
  615|  6.46k|                mEffects.erase(i);
  616|  6.46k|            }
  617|  70.2k|        }
  618|       |
  619|  81.8k|        if (isLoaded())
  ------------------
  |  Branch (619:13): [True: 0, False: 81.8k]
  ------------------
  620|      0|        {
  621|       |            // Create controller
  622|      0|            createEffectController(effect);
  623|      0|        }
  624|       |
  625|       |        // Record new effect
  626|  81.8k|        mEffects.emplace(effect.type, effect);
  627|       |
  628|  81.8k|    }
_ZN4Ogre16TextureUnitState16removeAllEffectsEv:
  631|  3.18M|    {
  632|       |        // Iterate over effects to remove controllers
  633|  3.18M|        EffectMap::iterator i, iend;
  634|  3.18M|        iend = mEffects.end();
  635|  3.18M|        for (i = mEffects.begin(); i != iend; ++i)
  ------------------
  |  Branch (635:36): [True: 0, False: 3.18M]
  ------------------
  636|      0|        {
  637|      0|            if (i->second.controller)
  ------------------
  |  Branch (637:17): [True: 0, False: 0]
  ------------------
  638|      0|            {
  639|      0|                ControllerManager::getSingleton().destroyController(i->second.controller);
  640|      0|            }
  641|      0|        }
  642|       |
  643|  3.18M|        mEffects.clear();
  644|  3.18M|    }
_ZN4Ogre16TextureUnitState17setEnvironmentMapEbi:
  674|  18.2k|    {
  675|  18.2k|        if (enable)
  ------------------
  |  Branch (675:13): [True: 17.6k, False: 574]
  ------------------
  676|  17.6k|        {
  677|  17.6k|            TextureEffect eff = {ET_ENVIRONMENT_MAP};
  678|  17.6k|            eff.subtype = envMapType;
  679|  17.6k|            addEffect(eff);
  680|  17.6k|        }
  681|    574|        else
  682|    574|        {
  683|    574|            removeEffect(ET_ENVIRONMENT_MAP);
  684|    574|        }
  685|  18.2k|    }
_ZN4Ogre16TextureUnitState12removeEffectENS0_17TextureEffectTypeE:
  688|  79.6k|    {
  689|       |        // Get range of items matching this effect
  690|  79.6k|        std::pair< EffectMap::iterator, EffectMap::iterator > remPair = 
  691|  79.6k|            mEffects.equal_range( type );
  692|       |        // Remove controllers
  693|  98.5k|        for (EffectMap::iterator i = remPair.first; i != remPair.second; ++i)
  ------------------
  |  Branch (693:53): [True: 18.8k, False: 79.6k]
  ------------------
  694|  18.8k|        {
  695|  18.8k|            if (i->second.controller)
  ------------------
  |  Branch (695:17): [True: 0, False: 18.8k]
  ------------------
  696|      0|            {
  697|      0|                ControllerManager::getSingleton().destroyController(i->second.controller);
  698|      0|            }
  699|  18.8k|        }
  700|       |        // Erase         
  701|  79.6k|        mEffects.erase( remPair.first, remPair.second );
  702|  79.6k|    }
_ZN4Ogre16TextureUnitState19setTextureTransformERKNS_7Matrix4E:
  711|    934|    {
  712|    934|        mTexModMatrix = xform;
  713|    934|        mRecalcTexMatrix = false;
  714|    934|    }
_ZN4Ogre16TextureUnitState16setTextureScrollEff:
  717|    317|    {
  718|    317|        mUMod = u;
  719|    317|        mVMod = v;
  720|    317|        mRecalcTexMatrix = true;
  721|    317|    }
_ZN4Ogre16TextureUnitState15setTextureScaleEff:
  724|    478|    {
  725|    478|        mUScale = uScale;
  726|    478|        mVScale = vScale;
  727|    478|        mRecalcTexMatrix = true;
  728|    478|    }
_ZN4Ogre16TextureUnitState16setTextureRotateERKNS_6RadianE:
  731|    334|    {
  732|    334|        mRotate = angle;
  733|    334|        mRecalcTexMatrix = true;
  734|    334|    }
_ZN4Ogre16TextureUnitState18setScrollAnimationEff:
  814|  24.5k|    {
  815|       |        // Remove existing effects
  816|  24.5k|        removeEffect(ET_UVSCROLL);
  817|  24.5k|        removeEffect(ET_USCROLL);
  818|  24.5k|        removeEffect(ET_VSCROLL);
  819|       |
  820|       |        // don't create an effect if the speeds are both 0
  821|  24.5k|        if (uSpeed == 0.0f && vSpeed == 0.0f)
  ------------------
  |  Branch (821:13): [True: 712, False: 23.8k]
  |  Branch (821:31): [True: 202, False: 510]
  ------------------
  822|    202|        {
  823|    202|            return;
  824|    202|        }
  825|       |
  826|       |        // Create new effect
  827|  24.3k|        if (uSpeed == vSpeed)
  ------------------
  |  Branch (827:13): [True: 222, False: 24.1k]
  ------------------
  828|    222|        {
  829|    222|            addEffect({ET_UVSCROLL, uSpeed});
  830|    222|        }
  831|  24.1k|        else
  832|  24.1k|        {
  833|  24.1k|            if (uSpeed)
  ------------------
  |  Branch (833:17): [True: 23.6k, False: 510]
  ------------------
  834|  23.6k|            {
  835|  23.6k|                addEffect({ET_USCROLL, uSpeed});
  836|  23.6k|            }
  837|  24.1k|            if (vSpeed)
  ------------------
  |  Branch (837:17): [True: 23.5k, False: 532]
  ------------------
  838|  23.5k|            {
  839|  23.5k|                addEffect({ET_VSCROLL, vSpeed});
  840|  23.5k|            }
  841|  24.1k|        }
  842|  24.3k|    }
_ZN4Ogre16TextureUnitState18setRotateAnimationEf:
  845|  5.41k|    {
  846|       |        // Remove existing effect
  847|  5.41k|        removeEffect(ET_ROTATE);
  848|       |        // don't create an effect if the speed is 0
  849|  5.41k|        if(speed == 0.0f) 
  ------------------
  |  Branch (849:12): [True: 280, False: 5.13k]
  ------------------
  850|    280|        {
  851|    280|          return;
  852|    280|        }
  853|       |        // Create new effect
  854|  5.13k|        addEffect({ET_ROTATE, speed});
  855|  5.13k|    }
_ZN4Ogre16TextureUnitState21setTransformAnimationENS0_20TextureTransformTypeENS_12WaveformTypeEffff:
  859|  12.4k|    {
  860|       |        // Remove existing effect
  861|       |        // note, only remove for subtype, not entire ET_TRANSFORM
  862|       |        // otherwise we won't be able to combine subtypes
  863|       |        // Get range of items matching this effect
  864|  31.7k|        for (EffectMap::iterator i = mEffects.begin(); i != mEffects.end(); ++i)
  ------------------
  |  Branch (864:56): [True: 29.0k, False: 2.73k]
  ------------------
  865|  29.0k|        {
  866|  29.0k|            if (i->second.type == ET_TRANSFORM && i->second.subtype == ttype)
  ------------------
  |  Branch (866:17): [True: 14.3k, False: 14.7k]
  |  Branch (866:51): [True: 9.70k, False: 4.60k]
  ------------------
  867|  9.70k|            {
  868|  9.70k|                if (i->second.controller)
  ------------------
  |  Branch (868:21): [True: 0, False: 9.70k]
  ------------------
  869|      0|                {
  870|      0|                    ControllerManager::getSingleton().destroyController(i->second.controller);
  871|      0|                }
  872|  9.70k|                mEffects.erase(i);
  873|       |
  874|       |                // should only be one, so jump out
  875|  9.70k|                break;
  876|  9.70k|            }
  877|  29.0k|        }
  878|       |
  879|       |        // don't create an effect if the given values are all 0
  880|  12.4k|        if(base == 0.0f && phase == 0.0f && frequency == 0.0f && amplitude == 0.0f)
  ------------------
  |  Branch (880:12): [True: 5.53k, False: 6.89k]
  |  Branch (880:28): [True: 4.39k, False: 1.13k]
  |  Branch (880:45): [True: 1.11k, False: 3.27k]
  |  Branch (880:66): [True: 874, False: 241]
  ------------------
  881|    874|        {
  882|    874|            return;
  883|    874|        }
  884|       |        // Create new effect
  885|  11.5k|        TextureEffect eff = {ET_TRANSFORM};
  886|  11.5k|        eff.subtype = ttype;
  887|  11.5k|        eff.waveType = waveType;
  888|  11.5k|        eff.base = base;
  889|  11.5k|        eff.frequency = frequency;
  890|  11.5k|        eff.phase = phase;
  891|  11.5k|        eff.amplitude = amplitude;
  892|  11.5k|        addEffect(eff);
  893|  11.5k|    }
_ZN4Ogre16TextureUnitState15retrieveTextureERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  961|  19.6M|    TexturePtr TextureUnitState::retrieveTexture(const String& name) {
  962|  19.6M|        TextureManager::ResourceCreateOrRetrieveResult res;
  963|  19.6M|        res = TextureManager::getSingleton().createOrRetrieve(name, mParent->getResourceGroup());
  964|  19.6M|        return static_pointer_cast<Texture>(res.first);
  965|  19.6M|    }
_ZNK4Ogre16TextureUnitState20getAnimationDurationEv:
 1109|    131|    {
 1110|    131|        return mAnimDuration;
 1111|    131|    }
_ZN4Ogre16TextureUnitState7_unloadEv:
 1125|  3.22M|    {
 1126|       |        // Destroy animation controller
 1127|  3.22M|        if (mAnimController)
  ------------------
  |  Branch (1127:13): [True: 0, False: 3.22M]
  ------------------
 1128|      0|        {
 1129|      0|            ControllerManager::getSingleton().destroyController(mAnimController);
 1130|      0|            mAnimController = 0;
 1131|      0|        }
 1132|       |
 1133|       |        // Destroy effect controllers
 1134|  3.22M|        for (auto & e : mEffects)
  ------------------
  |  Branch (1134:23): [True: 5.73M, False: 3.22M]
  ------------------
 1135|  5.73M|        {
 1136|  5.73M|            if (e.second.controller)
  ------------------
  |  Branch (1136:17): [True: 0, False: 5.73M]
  ------------------
 1137|      0|            {
 1138|      0|                ControllerManager::getSingleton().destroyController(e.second.controller);
 1139|      0|                e.second.controller = 0;
 1140|      0|            }
 1141|  5.73M|        }
 1142|       |
 1143|       |        // don't unload named textures. may be used elsewhere
 1144|       |        // drop references on managed textures, however
 1145|  3.22M|        if(mContentType != CONTENT_NAMED)
  ------------------
  |  Branch (1145:12): [True: 18.9k, False: 3.20M]
  ------------------
 1146|  18.9k|            mFramePtrs[0].reset();
 1147|  3.22M|    }
_ZNK4Ogre16TextureUnitState8isLoadedEv:
 1150|  3.32M|    {
 1151|  3.32M|        return mParent->isLoaded();
 1152|  3.32M|    }
_ZN4Ogre16TextureUnitState7setNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
 1186|  55.4k|    {
 1187|  55.4k|        mName = name;
 1188|  55.4k|    }
_ZN4Ogre16TextureUnitState13_notifyParentEPNS_4PassE:
 1191|  41.4k|    {
 1192|  41.4k|        mParent = parent;
 1193|  41.4k|    }
_ZN4Ogre16TextureUnitState22setCompositorReferenceERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_j:
 1196|  5.47k|    {  
 1197|  5.47k|        mCompositorRefName = compositorName; 
 1198|  5.47k|        mCompositorRefTexName = textureName; 
 1199|  5.47k|        mCompositorRefMrtIndex = mrtIndex; 
 1200|  5.47k|    }
_ZNK4Ogre16TextureUnitState18isDefaultFilteringEv:
 1210|  44.0k|    bool TextureUnitState::isDefaultFiltering() const {
 1211|  44.0k|        return mSampler == TextureManager::getSingleton().getDefaultSampler();
 1212|  44.0k|    }
_ZN4Ogre16TextureUnitState16_getLocalSamplerEv:
 1215|  44.0k|    {
 1216|  44.0k|        if(isDefaultFiltering())
  ------------------
  |  Branch (1216:12): [True: 7.70k, False: 36.3k]
  ------------------
 1217|  7.70k|            mSampler = TextureManager::getSingleton().createSampler();
 1218|       |
 1219|  44.0k|        return mSampler;
 1220|  44.0k|    }

_ZN4Ogre5TimerC2Ev:
   36|      1|{
   37|      1|    reset();
   38|      1|}
_ZN4Ogre5Timer5resetEv:
   42|      1|{
   43|      1|    zeroClock = clock();
   44|      1|    start = steady_clock::now();
   45|      1|}

_ZN4Ogre26UnifiedHighLevelGpuProgramC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE:
   50|    625|        :GpuProgram(creator, name, handle, group, isManual, loader)
   51|    625|    {
   52|    625|        if (createParamDictionary("UnifiedHighLevelGpuProgram"))
  ------------------
  |  Branch (52:13): [True: 1, False: 624]
  ------------------
   53|      1|        {
   54|      1|            setupBaseParamDictionary();
   55|       |
   56|      1|            ParamDictionary* dict = getParamDictionary();
   57|       |
   58|      1|            dict->addParameter(ParameterDef("delegate",
   59|      1|                "Additional delegate programs containing implementations.",
   60|      1|                PT_STRING),&msCmdDelegate);
   61|      1|        }
   62|       |
   63|    625|    }
_ZN4Ogre26UnifiedHighLevelGpuProgramD2Ev:
   66|    625|    {
   67|       |
   68|    625|    }
_ZNK4Ogre26UnifiedHighLevelGpuProgram14chooseDelegateEv:
   71|  7.68k|    {
   72|  7.68k|        OGRE_LOCK_AUTO_MUTEX;
   73|       |
   74|  7.68k|        mChosenDelegate.reset();
   75|       |
   76|  7.68k|        for (const String& dn : mDelegateNames)
  ------------------
  |  Branch (76:31): [True: 3.68M, False: 7.68k]
  ------------------
   77|  3.68M|        {
   78|  3.68M|            GpuProgramPtr deleg = GpuProgramManager::getSingleton().getByName(dn, mGroup);
   79|       |
   80|       |            //recheck with auto resource group
   81|  3.68M|            if (!deleg)
  ------------------
  |  Branch (81:17): [True: 3.67M, False: 10.0k]
  ------------------
   82|  3.67M|                deleg = GpuProgramManager::getSingleton().getByName(dn, RGN_AUTODETECT);
   83|       |
   84|       |            // Silently ignore missing links
   85|  3.68M|            if(!deleg)
  ------------------
  |  Branch (85:16): [True: 3.67M, False: 10.0k]
  ------------------
   86|  3.67M|                continue;
   87|       |
   88|  10.0k|            if (deleg->getLanguage() == sLanguage)
  ------------------
  |  Branch (88:17): [True: 8.35k, False: 1.70k]
  ------------------
   89|  8.35k|            {
   90|  8.35k|                LogManager::getSingleton().logError("unified program '" + getName() +
   91|  8.35k|                                                    "' cannot delegate to another unified program '" + dn + "'");
   92|  8.35k|                continue;
   93|  8.35k|            }
   94|       |
   95|  1.70k|            if (deleg->getType() != getType())
  ------------------
  |  Branch (95:17): [True: 330, False: 1.37k]
  ------------------
   96|    330|            {
   97|    330|                LogManager::getSingleton().logError("unified program '" + getName() +
   98|    330|                                                    "' cannot delegate to program with different type '" + dn + "'");
   99|    330|                continue;
  100|    330|            }
  101|       |
  102|  1.37k|            if(!deleg->isSupported() && !deleg->hasCompileError())
  ------------------
  |  Branch (102:16): [True: 1.37k, False: 0]
  |  Branch (102:41): [True: 1.37k, False: 0]
  ------------------
  103|  1.37k|                continue;
  104|       |
  105|      0|            mChosenDelegate = deleg;
  106|      0|            break;
  107|  1.37k|        }
  108|  7.68k|    }
_ZNK4Ogre26UnifiedHighLevelGpuProgram12_getDelegateEv:
  111|  7.68k|    {
  112|  7.68k|        if (!mChosenDelegate)
  ------------------
  |  Branch (112:13): [True: 7.68k, False: 0]
  ------------------
  113|  7.68k|        {
  114|  7.68k|            chooseDelegate();
  115|  7.68k|        }
  116|  7.68k|        return mChosenDelegate;
  117|  7.68k|    }
_ZN4Ogre26UnifiedHighLevelGpuProgram18addDelegateProgramERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
  120|  8.15k|    {
  121|  8.15k|            OGRE_LOCK_AUTO_MUTEX;
  122|       |
  123|  8.15k|        mDelegateNames.push_back(name);
  124|       |
  125|       |        // reset chosen delegate
  126|  8.15k|        mChosenDelegate.reset();
  127|       |
  128|  8.15k|    }
_ZNK4Ogre26UnifiedHighLevelGpuProgram11getLanguageEv:
  153|  8.35k|    {
  154|  8.35k|        return sLanguage;
  155|  8.35k|    }
_ZN4Ogre26UnifiedHighLevelGpuProgram16createParametersEv:
  158|    407|    {
  159|    407|        if (isSupported())
  ------------------
  |  Branch (159:13): [True: 0, False: 407]
  ------------------
  160|      0|        {
  161|      0|            return _getDelegate()->createParameters();
  162|      0|        }
  163|    407|        else
  164|    407|        {
  165|       |            // return a default set
  166|    407|            GpuProgramParametersSharedPtr params = GpuProgramManager::getSingleton().createParameters();
  167|       |            // avoid any errors on parameter names that don't exist
  168|    407|            params->setIgnoreMissingParams(true);
  169|    407|            return params;
  170|    407|        }
  171|    407|    }
_ZNK4Ogre26UnifiedHighLevelGpuProgram11isSupportedEv:
  182|  5.98k|    {
  183|       |        // Supported if one of the delegates is
  184|  5.98k|        return _getDelegate() && _getDelegate()->isSupported();
  ------------------
  |  Branch (184:16): [True: 0, False: 5.98k]
  |  Branch (184:34): [True: 0, False: 0]
  ------------------
  185|  5.98k|    }
_ZN4Ogre26UnifiedHighLevelGpuProgram6unloadEv:
  308|    609|    {
  309|    609|        if (_getDelegate())
  ------------------
  |  Branch (309:13): [True: 0, False: 609]
  ------------------
  310|      0|            _getDelegate()->unload();
  311|    609|    }
_ZN4Ogre26UnifiedHighLevelGpuProgram11addListenerEPNS_8Resource8ListenerE:
  372|    407|    {
  373|    407|        if (_getDelegate())
  ------------------
  |  Branch (373:13): [True: 0, False: 407]
  ------------------
  374|      0|            _getDelegate()->addListener(lis);
  375|    407|    }
_ZN4Ogre26UnifiedHighLevelGpuProgram14removeListenerEPNS_8Resource8ListenerE:
  378|    677|    {
  379|    677|        if (_getDelegate())
  ------------------
  |  Branch (379:13): [True: 0, False: 677]
  ------------------
  380|      0|            _getDelegate()->removeListener(lis);
  381|    677|    }
_ZN4Ogre11CmdDelegate5doSetEPvRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE:
  412|  8.15k|    {
  413|  8.15k|        static_cast<UnifiedHighLevelGpuProgram*>(target)->addDelegateProgram(val);
  414|  8.15k|    }
_ZN4Ogre33UnifiedHighLevelGpuProgramFactoryC2Ev:
  418|      1|    {
  419|      1|    }
_ZNK4Ogre33UnifiedHighLevelGpuProgramFactory11getLanguageEv:
  426|      1|    {
  427|      1|        return sLanguage;
  428|      1|    }
_ZN4Ogre33UnifiedHighLevelGpuProgramFactory6createEPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE:
  433|    625|    {
  434|       |        return OGRE_NEW UnifiedHighLevelGpuProgram(creator, name, handle, group, isManual, loader);
  435|    625|    }

_ZN4Ogre20DefaultWorkQueueBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE:
   65|      1|        : mName(name)
   66|      1|        , mWorkerThreadCount(1)
   67|      1|        , mWorkerRenderSystemAccess(false)
   68|      1|        , mIsRunning(false)
   69|      1|        , mResposeTimeLimitMS(10)
   70|      1|        , mPaused(false)
   71|      1|        , mAcceptRequests(true)
   72|      1|        , mShuttingDown(false)
   73|      1|    {
   74|      1|    }
_ZN4Ogre20DefaultWorkQueueBase31setWorkersCanAccessRenderSystemEb:
   87|      1|    {
   88|      1|        mWorkerRenderSystemAccess = access;
   89|      1|    }

_ZNK4Ogre17ZipArchiveFactory7getTypeEv:
  321|      2|    {
  322|      2|        static String name = "Zip";
  323|      2|        return name;
  324|      2|    }
_ZN4Ogre25EmbeddedZipArchiveFactoryC2Ev:
  348|      1|    EmbeddedZipArchiveFactory::EmbeddedZipArchiveFactory() {}
_ZNK4Ogre25EmbeddedZipArchiveFactory7getTypeEv:
  368|      2|    {
  369|      2|        static String name = "EmbeddedZip";
  370|      2|        return name;
  371|      2|    }

LLVMFuzzerTestOneInput:
   98|  15.9k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
   99|  15.9k|  if (size == 0 || size > FUZZ_MAX_INPUT)
  ------------------
  |  Branch (99:7): [True: 0, False: 15.9k]
  |  Branch (99:20): [True: 7, False: 15.8k]
  ------------------
  100|      7|    return 0;
  101|       |
  102|  15.8k|  global_init();
  103|       |
  104|  15.8k|  Ogre::DataStreamPtr stream(new Ogre::MemoryDataStream("fuzz.os", const_cast<uint8_t*>(data), size, false, true));
  105|       |
  106|  15.8k|  try
  107|  15.8k|  {
  108|  15.8k|    Ogre::ScriptCompilerManager::getSingleton().parseScript(stream, FUZZ_GROUP);
  109|  15.8k|  }
  110|  15.8k|  catch (std::exception&)
  111|  15.8k|  {
  112|  2.18k|  }
  113|       |
  114|  15.8k|  purge_state();
  115|  15.8k|  return 0;
  116|  15.8k|}
script_fuzz.cpp:_ZL11global_initv:
   63|  15.8k|static void global_init() {
   64|  15.8k|  if (g_initialized)
  ------------------
  |  Branch (64:7): [True: 15.8k, False: 1]
  ------------------
   65|  15.8k|    return;
   66|       |
   67|      1|  auto *logMgr = new Ogre::LogManager();
   68|      1|  logMgr->createLog("fuzz.log", true, false);
   69|      1|  logMgr->setMinLogLevel(Ogre::LML_CRITICAL);
   70|       |
   71|      1|  new Ogre::Root("", "", "");
   72|       |
   73|       |  /* Root::initialise() would do this, but that needs a RenderSystem. */
   74|      1|  Ogre::MaterialManager::getSingleton().initialise();
   75|      1|  new Ogre::DefaultTextureManager();
   76|       |
   77|      1|  static FuzzScriptListener listener;
   78|      1|  Ogre::ScriptCompilerManager::getSingleton().setListener(&listener);
   79|       |
   80|      1|  Ogre::ResourceGroupManager::getSingleton().createResourceGroup(FUZZ_GROUP, false);
   81|      1|  g_initialized = true;
   82|      1|}
_ZN18FuzzScriptListener10importFileEPN4Ogre14ScriptCompilerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE:
   56|  9.45k|    {
   57|  9.45k|        return std::make_shared<Ogre::ConcreteNodeList>();
   58|  9.45k|    }
_ZN18FuzzScriptListener11handleErrorEPN4Ogre14ScriptCompilerEjRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEiSB_:
   53|  13.8M|    void handleError(Ogre::ScriptCompiler*, Ogre::uint32, const Ogre::String&, int, const Ogre::String&) override {}
script_fuzz.cpp:_ZL11purge_statev:
   85|  15.8k|static void purge_state() {
   86|  15.8k|  auto &rgm = Ogre::ResourceGroupManager::getSingleton();
   87|  15.8k|  rgm.destroyResourceGroup(FUZZ_GROUP);
   88|  15.8k|  rgm.createResourceGroup(FUZZ_GROUP, false);
   89|       |
   90|       |  /* Particle system templates are not Resources - they live in a private map
   91|       |   * in ParticleSystemManager and would grow without bound otherwise. */
   92|  15.8k|  Ogre::ParticleSystemManager::getSingleton().removeAllTemplates();
   93|       |
   94|       |  // clean the pass graveyard
   95|  15.8k|  Ogre::Pass::processPendingPassUpdates();
   96|  15.8k|}

