_ZN4Ogre15CompositionPass15setThreadGroupsERKNS_6VectorILi3EiEE: 315| 49| void setThreadGroups(const Vector3i& g) { mThreadGroups = g; } _ZN4Ogre15CompositionPass13setCameraNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 318| 377| void setCameraName(const String& name) { mRenderScene.cameraName = name; } _ZN4Ogre15CompositionPass20setAlignCameraToFaceEb: 321| 308| void setAlignCameraToFace(bool val) { mRenderScene.alignCameraToFace = val; } _ZN4Ogre15CompositionPass8InputTexC2Ev: 240| 55.7k| InputTex() : mrtIndex(0) {} _ZN4Ogre15CompositionPass8InputTexC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEm: 242| 2.43k| : name(_name), mrtIndex(_mrtIndex) {} _ZN4Ogre15CompositionPass12MaterialDataC2Ev: 340| 3.48k| MaterialData() : identifier(0) {} _ZN4Ogre15CompositionPass15RenderSceneDataC2Ev: 358| 3.48k| : firstRenderQueue(RENDER_QUEUE_BACKGROUND), lastRenderQueue(RENDER_QUEUE_TRANSPARENTS), 359| 3.48k| alignCameraToFace(false) 360| 3.48k| { 361| 3.48k| } _ZN4Ogre15CompositionPass9ClearDataC2Ev: 379| 3.48k| : buffers(FBT_COLOUR | FBT_DEPTH), colour(ColourValue::ZERO), automaticColour(false), 380| 3.48k| depth(1.0f), stencil(0) 381| 3.48k| { 382| 3.48k| } _ZN4Ogre15CompositionPass8QuadDataC2Ev: 401| 3.48k| : cornerModified(false), rect(-1, 1, 1, -1), farCorners(false), farCornersViewSpace(false) 402| 3.48k| { 403| 3.48k| } _ZN4Ogre21CompositionTargetPass14setOutputSliceEi: 75| 776| void setOutputSlice(int slice) { mOutputSlice = slice; } _ZNK4Ogre21CompositionTargetPass9getPassesEv: 141| 1.27k| const Passes& getPasses() const { 142| 1.27k| return mPasses; 143| 1.27k| } _ZNK4Ogre28ExternalTextureSourceManager16getCurrentPlugInEv: 67| 17| ExternalTextureSource* getCurrentPlugIn( void ) const { return mCurrExternalTextureSource; } _ZN4Ogre17GpuProgramManager16createParametersEv: 163| 3.00k| static GpuProgramParametersPtr createParameters(void) { return std::make_shared(); } _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| 713k| Real getLoadingOrder(void) const override { return mLoadOrder; } _ZN4Ogre22ScriptCompilerListenerD2Ev: 383| 1| virtual ~ScriptCompilerListener() {} _ZN4Ogre16ScriptTranslator7getRealERKNS_9SharedPtrINS_12AbstractNodeEEEPf: 72| 3.33k| { 73| 3.33k|#if OGRE_DOUBLE_PRECISION == 0 74| 3.33k| return getFloat(node, result); 75| |#else 76| | return getDouble(node, result); 77| |#endif 78| 3.33k| } _ZN4Ogre9SharedPtrINSt3__14listINS0_INS_12ConcreteNodeEEENS1_9allocatorIS4_EEEEEC2IS7_EERKNS1_10shared_ptrIT_EE: 59| 21.2k| SharedPtr(const shared_ptr& r) : shared_ptr(r) {} _ZN4Ogre9SharedPtrINS_10DataStreamEEC2INS_16MemoryDataStreamEEEPT_: 50| 7.20k| explicit SharedPtr(Y* ptr) : shared_ptr(ptr) {} _ZN4Ogre7TextureD2Ev: 144| 694k| virtual ~Texture() {} _ZN4Ogre21DefaultTextureManager10createImplERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmS9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE: 446| 694k| { 447| 694k| return new NullTexture(this, name, handle, group); 448| 694k| } _ZN4Ogre21DefaultTextureManager11NullTextureC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmSC_: 435| 694k| : Texture(creator, name, handle, group) 436| 694k| { 437| 694k| } _ZN4Ogre14TextureManager20getDefaultNumMipmapsEv: 399| 703k| { 400| 703k| return mDefaultNumMipmaps; 401| 703k| } _ZN4Ogre14TextureManager18_createSamplerImplEv: 416| 4.63k| virtual SamplerPtr _createSamplerImpl() { return std::make_shared(); } _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: 1139| 3| { 1140| 3| return MOT_BILLBOARD_SET; 1141| 3| } _ZN4Ogre5Codec13registerCodecEPS0_: 62| 5| { 63| 5| auto ret = msMapCodecs.emplace(pCodec->getType(), pCodec); 64| 5| if (!ret.second) ------------------ | Branch (64:13): [True: 0, False: 5] ------------------ 65| | OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, pCodec->getType() + " already has a registered codec"); 66| 5| } _ZN4Ogre15CompositionPassC2EPNS_21CompositionTargetPassE: 35| 3.48k| mParent(parent), 36| 3.48k| mType(PT_RENDERQUAD) 37| 3.48k|{ 38| 3.48k|} _ZN4Ogre15CompositionPassD2Ev: 41| 3.48k|{ 42| 3.48k|} _ZN4Ogre15CompositionPass7setTypeENS0_8PassTypeE: 45| 3.48k|{ 46| 3.48k| mType = type; 47| 3.48k|} _ZNK4Ogre15CompositionPass7getTypeEv: 50| 3.48k|{ 51| 3.48k| return mType; 52| 3.48k|} _ZN4Ogre15CompositionPass13setIdentifierEj: 55| 678|{ 56| 678| mMaterial.identifier = id; 57| 678|} _ZN4Ogre15CompositionPass11setMaterialERKNS_9SharedPtrINS_8MaterialEEE: 65| 125|{ 66| 125| mMaterial.material = mat; 67| 125|} _ZN4Ogre15CompositionPass15setClearBuffersEj: 80| 91|{ 81| 91| mClear.buffers = val; 82| 91|} _ZN4Ogre15CompositionPass14setClearColourERKNS_11ColourValueE: 90| 16|{ 91| 16| mClear.colour = val; 92| 16|} _ZN4Ogre15CompositionPass8setInputEmRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEm: 110| 2.43k|{ 111| | assert(id < OGRE_MAX_TEXTURE_LAYERS); 112| 2.43k| mMaterial.inputs[id] = InputTex(input, mrtIndex); 113| 2.43k|} _ZN4Ogre15CompositionPass19setFirstRenderQueueEh: 146| 54|{ 147| 54| mRenderScene.firstRenderQueue = id; 148| 54|} _ZN4Ogre15CompositionPass18setLastRenderQueueEh: 156| 89|{ 157| 89| mRenderScene.lastRenderQueue = id; 158| 89|} _ZN4Ogre15CompositionPass17setMaterialSchemeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 166| 22|{ 167| 22| mRenderScene.materialScheme = schemeName; 168| 22|} _ZN4Ogre15CompositionPass13setClearDepthEf: 176| 19|{ 177| 19| mClear.depth = depth; 178| 19|} _ZN4Ogre15CompositionPass14setStencilFuncENS_15CompareFunctionE: 201| 1|{ 202| 1| mStencilState.compareOp = value; 203| 1|} _ZN4Ogre15CompositionPass14setStencilMaskEj: 217| 2|{ 218| 2| mStencilState.compareMask = value; 219| 2|} _ZN4Ogre15CompositionPass17setQuadFarCornersEbb: 257| 290|{ 258| 290| mQuad.farCorners = farCorners; 259| 290| mQuad.farCornersViewSpace = farCornersViewSpace; 260| 290|} _ZN4Ogre15CompositionPass13setCustomTypeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 271| 17|{ 272| 17| mCustomType = customType; 273| 17|} _ZN4Ogre21CompositionTargetPassC2EPNS_20CompositionTechniqueE: 35| 5.15k| mParent(parent), 36| 5.15k| mInputMode(IM_NONE), 37| 5.15k| mOnlyInitial(false), 38| 5.15k| mVisibilityMask(0xFFFFFFFF), 39| 5.15k| mLodBias(1.0f), 40| 5.15k| mMaterialScheme(MaterialManager::DEFAULT_SCHEME_NAME), 41| 5.15k| mShadowsEnabled(true), 42| 5.15k| mOutputSlice(0) 43| 5.15k|{ 44| 5.15k| if (Root::getSingleton().getRenderSystem()) ------------------ | Branch (44:9): [True: 0, False: 5.15k] ------------------ 45| 0| { 46| 0| mMaterialScheme = Root::getSingleton().getRenderSystem()->_getDefaultViewportMaterialScheme(); 47| 0| } 48| 5.15k|} _ZN4Ogre21CompositionTargetPassD2Ev: 51| 5.15k|{ 52| 5.15k| removeAllPasses(); 53| 5.15k|} _ZN4Ogre21CompositionTargetPass12setInputModeENS0_9InputModeE: 56| 5.52k|{ 57| 5.52k| mInputMode = mode; 58| 5.52k|} _ZNK4Ogre21CompositionTargetPass12getInputModeEv: 61| 1.19k|{ 62| 1.19k| return mInputMode; 63| 1.19k|} _ZN4Ogre21CompositionTargetPass13setOutputNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 66| 3.12k|{ 67| 3.12k| mOutputName = out; 68| 3.12k|} _ZN4Ogre21CompositionTargetPass17setVisibilityMaskEj: 86| 609|{ 87| 609| mVisibilityMask = mask; 88| 609|} _ZN4Ogre21CompositionTargetPass10setLodBiasEf: 96| 1|{ 97| 1| mLodBias = bias; 98| 1|} _ZN4Ogre21CompositionTargetPass17setMaterialSchemeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 106| 202|{ 107| 202| mMaterialScheme = schemeName; 108| 202|} _ZN4Ogre21CompositionTargetPass17setShadowsEnabledEb: 116| 66|{ 117| 66| mShadowsEnabled = enabled; 118| 66|} _ZN4Ogre21CompositionTargetPass10createPassENS_15CompositionPass8PassTypeE: 126| 3.48k|{ 127| | CompositionPass *t = OGRE_NEW CompositionPass(this); 128| 3.48k| t->setType(type); 129| 3.48k| mPasses.push_back(t); 130| 3.48k| return t; 131| 3.48k|} _ZN4Ogre21CompositionTargetPass15removeAllPassesEv: 143| 5.15k|{ 144| 5.15k| for (auto p : mPasses) ------------------ | Branch (144:17): [True: 3.48k, False: 5.15k] ------------------ 145| 3.48k| { 146| | OGRE_DELETE (p); 147| 3.48k| } 148| 5.15k| mPasses.clear(); 149| 5.15k|} _ZN4Ogre20CompositionTechniqueC2EPNS_10CompositorE: 34| 2.03k| mParent(parent) 35| 2.03k|{ 36| | mOutputTarget = OGRE_NEW CompositionTargetPass(this); 37| 2.03k|} _ZN4Ogre20CompositionTechniqueD2Ev: 40| 2.03k|{ 41| 2.03k| removeAllTextureDefinitions(); 42| 2.03k| removeAllTargetPasses(); 43| | OGRE_DELETE mOutputTarget; 44| 2.03k|} _ZN4Ogre20CompositionTechnique23createTextureDefinitionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 47| 3.28k|{ 48| 3.28k| if(getTextureDefinition(name)) ------------------ | Branch (48:8): [True: 397, False: 2.89k] ------------------ 49| 3.28k| OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, "Texture '"+name+"' already exists"); 50| | 51| 2.89k| TextureDefinition *t = OGRE_NEW TextureDefinition(); 52| 2.89k| t->name = name; 53| 2.89k| mTextureDefinitions.push_back(t); 54| 2.89k| return t; 55| 3.28k|} _ZNK4Ogre20CompositionTechnique20getTextureDefinitionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 67| 3.28k|{ 68| 3.28k| for (auto *t : mTextureDefinitions) ------------------ | Branch (68:18): [True: 4.07k, False: 2.89k] ------------------ 69| 4.07k| { 70| 4.07k| if (t->name == name) ------------------ | Branch (70:13): [True: 397, False: 3.67k] ------------------ 71| 397| return t; 72| 4.07k| } 73| 2.89k| return 0; 74| | 75| 3.28k|} _ZN4Ogre20CompositionTechnique27removeAllTextureDefinitionsEv: 78| 2.03k|{ 79| 2.03k| for (auto *t : mTextureDefinitions) ------------------ | Branch (79:18): [True: 2.89k, False: 2.03k] ------------------ 80| 2.89k| { 81| | OGRE_DELETE t; 82| 2.89k| } 83| 2.03k| mTextureDefinitions.clear(); 84| 2.03k|} _ZN4Ogre20CompositionTechnique16createTargetPassEv: 93| 3.12k|{ 94| | CompositionTargetPass *t = OGRE_NEW CompositionTargetPass(this); 95| 3.12k| mTargetPasses.push_back(t); 96| 3.12k| return t; 97| 3.12k|} _ZN4Ogre20CompositionTechnique21removeAllTargetPassesEv: 109| 2.03k|{ 110| 2.03k| for (auto *t : mTargetPasses) ------------------ | Branch (110:18): [True: 3.12k, False: 2.03k] ------------------ 111| 3.12k| { 112| | OGRE_DELETE t; 113| 3.12k| } 114| 2.03k| mTargetPasses.clear(); 115| 2.03k|} _ZN4Ogre20CompositionTechnique13setSchemeNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 201| 4|{ 202| 4| mSchemeName = schemeName; 203| 4|} _ZN4Ogre10CompositorC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE: 37| 2.19k| Resource(creator, name, handle, group, isManual, loader), 38| 2.19k| mCompilationRequired(true) 39| 2.19k|{ 40| 2.19k|} _ZN4Ogre10CompositorD2Ev: 44| 2.19k|{ 45| 2.19k| removeAllTechniques(); 46| | // have to call this here reather than in Resource destructor 47| | // since calling virtual methods in base destructors causes crash 48| 2.19k| unload(); 49| 2.19k|} _ZN4Ogre10Compositor15createTechniqueEv: 52| 2.03k|{ 53| | CompositionTechnique *t = OGRE_NEW CompositionTechnique(this); 54| 2.03k| mTechniques.push_back(t); 55| 2.03k| mCompilationRequired = true; 56| 2.03k| return t; 57| 2.03k|} _ZN4Ogre10Compositor19removeAllTechniquesEv: 71| 4.32k|{ 72| 4.32k| for (auto *t : mTechniques) ------------------ | Branch (72:18): [True: 2.03k, False: 4.32k] ------------------ 73| 2.03k| { 74| | OGRE_DELETE t; 75| 2.03k| } 76| 4.32k| mTechniques.clear(); 77| 4.32k| mSupportedTechniques.clear(); 78| 4.32k| mCompilationRequired = true; 79| 4.32k|} _ZN4Ogre17CompositorManager12getSingletonEv: 44| 2.19k|{ 45| | assert( msSingleton ); return ( *msSingleton ); 46| 2.19k|}//----------------------------------------------------------------------- _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.19k|{ 77| | return OGRE_NEW Compositor(this, name, handle, group, isManual, loader); 78| 2.19k|} _ZN4Ogre17CompositorManager6createERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE: 83| 2.19k|{ 84| 2.19k| return static_pointer_cast(createResource(name,group,isManual,loader,createParams)); 85| 2.19k|} _ZN4Ogre8DDSCodec7startupEv: 168| 1| { 169| 1| if (!msInstance) ------------------ | Branch (169:13): [True: 1, False: 0] ------------------ 170| 1| { 171| | 172| 1| LogManager::getSingleton().logMessage( 173| 1| LML_NORMAL, 174| 1| "DDS codec registering"); 175| | 176| 1| msInstance = OGRE_NEW DDSCodec(); 177| 1| Codec::registerCodec(msInstance); 178| 1| } 179| | 180| 1| } _ZN4Ogre8DDSCodecC2Ev: 194| 1| mType("dds"), 195| 1| mDecodeEnforce(false) 196| 1| { 197| 1| } _ZNK4Ogre8DDSCodec7getTypeEv: 1056| 1| { 1057| 1| return mType; 1058| 1| } _ZN4Ogre10DataStream11getAsStringEv: 169| 7.20k| { 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| 7.20k| size_t bufSize = (mSize > 0 ? mSize : 4096); ------------------ | Branch (172:27): [True: 7.20k, False: 0] ------------------ 173| 7.20k| char* pBuf = OGRE_ALLOC_T(char, bufSize, MEMCATEGORY_GENERAL); 174| | // Ensure read from begin of stream 175| 7.20k| seek(0); 176| 7.20k| String result; 177| 14.4k| while (!eof()) ------------------ | Branch (177:16): [True: 7.20k, False: 7.20k] ------------------ 178| 7.20k| { 179| 7.20k| size_t nr = read(pBuf, bufSize); 180| 7.20k| result.append(pBuf, nr); 181| 7.20k| } 182| | OGRE_FREE(pBuf, MEMCATEGORY_GENERAL); 183| 7.20k| return result; 184| 7.20k| } _ZN4Ogre16MemoryDataStreamC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPvmbb: 199| 7.20k| : DataStream(name, static_cast(readOnly ? READ : (READ | WRITE))) ------------------ | Branch (199:48): [True: 7.20k, False: 0] ------------------ 200| 7.20k| { 201| 7.20k| mData = mPos = static_cast(pMem); 202| 7.20k| mSize = inSize; 203| 7.20k| mEnd = mData + mSize; 204| 7.20k| mFreeOnClose = freeOnClose; 205| | assert(mEnd >= mPos); 206| 7.20k| } _ZN4Ogre16MemoryDataStreamD2Ev: 336| 7.20k| { 337| 7.20k| close(); 338| 7.20k| } _ZN4Ogre16MemoryDataStream4readEPvm: 341| 7.20k| { 342| | // Read over end of memory? 343| 7.20k| if (mPos >= mEnd) ------------------ | Branch (343:13): [True: 0, False: 7.20k] ------------------ 344| 0| return 0; 345| 7.20k| size_t cnt = std::min(count, static_cast(mEnd - mPos)); 346| 7.20k| if (cnt == 0) ------------------ | Branch (346:13): [True: 0, False: 7.20k] ------------------ 347| 0| return 0; 348| | 349| 7.20k| assert (cnt<=count); 350| | 351| 7.20k| memcpy(buf, mPos, cnt); 352| 7.20k| mPos += cnt; 353| 7.20k| return cnt; 354| 7.20k| } _ZN4Ogre16MemoryDataStream4seekEm: 443| 7.20k| { 444| 7.20k| if (mData + pos > mEnd) ------------------ | Branch (444:13): [True: 0, False: 7.20k] ------------------ 445| 0| pos = static_cast(mEnd - mData); // will trigger eof 446| 7.20k| mPos = mData + pos; 447| 7.20k| } _ZNK4Ogre16MemoryDataStream3eofEv: 456| 14.4k| { 457| 14.4k| return mPos >= mEnd; 458| 14.4k| } _ZN4Ogre16MemoryDataStream5closeEv: 461| 7.20k| { 462| 7.20k| mAccess = 0; 463| 7.20k| if (mFreeOnClose && mData) ------------------ | Branch (463:13): [True: 0, False: 7.20k] | Branch (463:29): [True: 0, False: 0] ------------------ 464| 0| { 465| | OGRE_FREE(mData, MEMCATEGORY_GENERAL); 466| 0| mData = 0; 467| 0| } 468| 7.20k| } _ZN4Ogre16DefaultWorkQueueC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 34| 1| : DefaultWorkQueueBase(name), mNumThreadsRegisteredWithRS(0) 35| 1| { 36| 1| } _ZN4Ogre23DistanceLodStrategyBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 37| 2| : LodStrategy(name) 38| 2| , mReferenceViewEnabled(false) 39| 2| , mReferenceViewValue(-1) 40| 2| { } _ZNK4Ogre23DistanceLodStrategyBase12getBaseValueEv: 76| 192| { 77| 192| return Real(0); 78| 192| } _ZNK4Ogre23DistanceLodStrategyBase18transformUserValueEf: 87| 211| { 88| | // Square user-supplied distance 89| 211| return Math::Sqr(userValue); 90| 211| } _ZN4Ogre25DistanceLodSphereStrategyC2Ev: 161| 1| : DistanceLodStrategyBase("distance_sphere") 162| 1| { } _ZN4Ogre22DistanceLodBoxStrategyC2Ev: 192| 1| : DistanceLodStrategyBase("distance_box") 193| 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: 2240| 3| { 2241| 3| return MOT_ENTITY; 2242| 3| } _ZN4Ogre9ExceptionC2EiRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_PKcSB_l: 43| 1.16k| line( lin ), 44| 1.16k| typeName(typ), 45| 1.16k| description( desc ), 46| 1.16k| source( src ), 47| 1.16k| file( fil ) 48| 1.16k| { 49| 1.16k| StringStream ss; 50| | 51| 1.16k| ss << typeName << ": " 52| 1.16k| << description 53| 1.16k| << " in " << source; 54| | 55| 1.16k| if( line > 0 ) ------------------ | Branch (55:13): [True: 1.16k, False: 0] ------------------ 56| 1.16k| { 57| 1.16k| ss << " at " << file << " (line " << line << ")"; 58| 1.16k| } 59| | 60| 1.16k| fullDesc = ss.str(); 61| 1.16k| } _ZN4Ogre28ExternalTextureSourceManager12getSingletonEv: 51| 34| { 52| | assert( msSingleton ); return ( *msSingleton ); 53| 34| } _ZN4Ogre28ExternalTextureSourceManagerC2Ev: 58| 1| { 59| 1| mCurrExternalTextureSource = 0; 60| 1| } _ZN4Ogre28ExternalTextureSourceManager16setCurrentPlugInERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 71| 17| { 72| 17| TextureSystemList::iterator i; 73| | 74| 17| for( i = mTextureSystems.begin(); i != mTextureSystems.end(); ++i ) ------------------ | Branch (74:43): [True: 0, False: 17] ------------------ 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| 17| mCurrExternalTextureSource = 0; 84| 17| } _ZNK4Ogre24FileSystemArchiveFactory7getTypeEv: 553| 2| { 554| 2| static String name = "FileSystem"; 555| 2| return name; 556| 2| } _ZN4Ogre10GpuProgramC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE: 98| 4.01k| : Resource(creator, name, handle, group, isManual, loader), mType(GPT_VERTEX_PROGRAM), mLoadFromFile(true), 99| 4.01k| mInstancing(false), mSkeletalAnimation(false), mMorphAnimation(false), mVertexTextureFetch(false), 100| 4.01k| mNeedsAdjacencyInfo(false), mCompileError(false), mLoadedManualNamedConstants(false), mPoseAnimation(0) 101| 4.01k| { 102| 4.01k| createParameterMappingStructures(); 103| 4.01k| } _ZN4Ogre10GpuProgram7setTypeENS_14GpuProgramTypeE: 106| 4.01k| { 107| 4.01k| mType = t; 108| 4.01k| } _ZN4Ogre10GpuProgram13setSyntaxCodeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 111| 4.01k| { 112| 4.01k| mSyntaxCode = syntax; 113| 4.01k| } _ZN4Ogre10GpuProgram13setSourceFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 116| 2.53k| { 117| 2.53k| OgreAssert(!filename.empty(), "invalid filename"); ------------------ | Branch (117:9): [True: 0, False: 2.53k] ------------------ 118| | 119| 2.53k| mFilename = filename; 120| 2.53k| mSource.clear(); 121| 2.53k| mLoadFromFile = true; 122| 2.53k| mCompileError = false; 123| 2.53k| } _ZN4Ogre10GpuProgram32createParameterMappingStructuresEb: 261| 4.01k| { 262| 4.01k| createLogicalParameterMappingStructures(recreateIfExists); 263| 4.01k| createNamedParameterMappingStructures(recreateIfExists); 264| 4.01k| } _ZN4Ogre10GpuProgram39createLogicalParameterMappingStructuresEb: 267| 4.01k| { 268| 4.01k| if (recreateIfExists || !mLogicalToPhysical) ------------------ | Branch (268:13): [True: 4.01k, False: 0] | Branch (268:33): [True: 0, False: 0] ------------------ 269| 4.01k| mLogicalToPhysical = std::make_shared(); 270| 4.01k| } _ZN4Ogre10GpuProgram37createNamedParameterMappingStructuresEb: 273| 4.01k| { 274| 4.01k| if (recreateIfExists || !mConstantDefs) ------------------ | Branch (274:13): [True: 4.01k, False: 0] | Branch (274:33): [True: 0, False: 0] ------------------ 275| 4.01k| mConstantDefs = std::make_shared(); 276| 4.01k| } _ZN4Ogre10GpuProgram16createParametersEv: 310| 2.68k| { 311| | // Default implementation simply returns standard parameters. 312| 2.68k| GpuProgramParametersSharedPtr ret = 313| 2.68k| GpuProgramManager::getSingleton().createParameters(); 314| | 315| | 316| | // optionally load manually supplied named constants 317| 2.68k| if (!mManualNamedConstantsFile.empty() && !mLoadedManualNamedConstants) ------------------ | Branch (317:13): [True: 0, False: 2.68k] | 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| 2.68k| if (mConstantDefs && !mConstantDefs->map.empty()) ------------------ | Branch (339:13): [True: 2.68k, False: 0] | Branch (339:30): [True: 0, False: 2.68k] ------------------ 340| 0| { 341| 0| ret->_setNamedConstants(mConstantDefs); 342| 0| } 343| | // link shared logical / physical map for low-level use 344| 2.68k| ret->_setLogicalIndexes(mLogicalToPhysical); 345| | 346| | // Copy in default parameters if present 347| 2.68k| if (mDefaultParams) ------------------ | Branch (347:13): [True: 0, False: 2.68k] ------------------ 348| 0| ret->copyConstantsFrom(*(mDefaultParams.get())); 349| | 350| 2.68k| return ret; 351| 2.68k| } _ZN4Ogre10GpuProgram18getProgramTypeNameENS_14GpuProgramTypeE: 363| 12| { 364| 12| switch (programType) 365| 12| { 366| 1| case GPT_VERTEX_PROGRAM: ------------------ | Branch (366:9): [True: 1, False: 11] ------------------ 367| 1| return "vertex"; 368| 3| case GPT_GEOMETRY_PROGRAM: ------------------ | Branch (368:9): [True: 3, False: 9] ------------------ 369| 3| return "geometry"; 370| 4| case GPT_FRAGMENT_PROGRAM: ------------------ | Branch (370:9): [True: 4, False: 8] ------------------ 371| 4| return "fragment"; 372| 1| case GPT_DOMAIN_PROGRAM: ------------------ | Branch (372:9): [True: 1, False: 11] ------------------ 373| 1| return "domain"; 374| 1| case GPT_HULL_PROGRAM: ------------------ | Branch (374:9): [True: 1, False: 11] ------------------ 375| 1| return "hull"; 376| 1| case GPT_COMPUTE_PROGRAM: ------------------ | Branch (376:9): [True: 1, False: 11] ------------------ 377| 1| return "compute"; 378| 1| case GPT_MESH_PROGRAM: ------------------ | Branch (378:9): [True: 1, False: 11] ------------------ 379| 1| return "mesh"; 380| 0| case GPT_TASK_PROGRAM: ------------------ | Branch (380:9): [True: 0, False: 12] ------------------ 381| 0| return "task"; 382| 0| default: ------------------ | Branch (382:9): [True: 0, False: 12] ------------------ 383| | OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 384| 12| "Unexpected GPU program type", 385| 12| "GpuProgram::GetName"); 386| 12| } 387| 12| } _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| 33.9k| { 119| | assert( msSingleton ); return ( *msSingleton ); 120| 33.9k| } _ZNK4Ogre17GpuProgramManager9getByNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 123| 20.8k| { 124| 20.8k| return static_pointer_cast(getResourceByName(name, group)); 125| 20.8k| } _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(); 137| 1| addFactory(mNullFactory.get()); 138| 1| mUnifiedFactory = std::make_unique(); 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| 4.01k| { 189| 4.01k| auto prg = getFactory(syntaxCode)->create(this, name, getNextHandle(), group, isManual, loader); 190| 4.01k| prg->setType(gptype); 191| 4.01k| prg->setSyntaxCode(syntaxCode); 192| | 193| 4.01k| ResourcePtr ret(prg); 194| 4.01k| addImpl(ret); 195| | // Tell resource group manager 196| 4.01k| if(ret) ------------------ | Branch (196:12): [True: 3.90k, False: 114] ------------------ 197| 3.90k| ResourceGroupManager::getSingleton()._notifyResourceCreated(ret); 198| 4.01k| return static_pointer_cast(ret); 199| 4.01k| } _ZN4Ogre17GpuProgramManager22createSharedParametersERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 239| 129| { 240| 129| if (mSharedParametersMap.find(name) != mSharedParametersMap.end()) ------------------ | Branch (240:13): [True: 17, False: 112] ------------------ 241| 17| { 242| 17| OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 243| 17| "The shared parameter set '" + name + "' already exists!", 244| 17| "GpuProgramManager::createSharedParameters"); 245| 17| } 246| 112| GpuSharedParametersPtr ret(OGRE_NEW GpuSharedParameters(name)); 247| 112| mSharedParametersMap[name] = ret; 248| 112| return ret; 249| 129| } _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| 4.01k| { 448| 4.01k| FactoryMap::iterator i = mFactories.find(language); 449| | 450| 4.01k| if (i == mFactories.end()) ------------------ | Branch (450:13): [True: 3.21k, False: 809] ------------------ 451| 3.21k| { 452| | // use the null factory to create programs that will never be supported 453| 3.21k| i = mFactories.find(sNullLang); 454| 3.21k| } 455| 4.01k| return i->second; 456| 4.01k| } _ZNK4Ogre17GpuProgramManager19isLanguageSupportedERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 459| 7.71k| { 460| 7.71k| return mFactories.find(lang) != mFactories.end(); 461| 7.71k| } 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.21k| { 84| | return OGRE_NEW NullProgram(creator, name, handle, group, isManual, loader); 85| 3.21k| } OgreGpuProgramManager.cpp:_ZN4Ogre12_GLOBAL__N_111NullProgramC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEmSC_bPNS_20ManualResourceLoaderE: 53| 3.21k| : GpuProgram(creator, name, handle, group, isManual, loader){} OgreGpuProgramManager.cpp:_ZNK4Ogre12_GLOBAL__N_111NullProgram11isSupportedEv: 56| 12.8k| bool isSupported(void) const override { return false; } OgreGpuProgramManager.cpp:_ZNK4Ogre12_GLOBAL__N_111NullProgram11getLanguageEv: 58| 5.03k| const String& getLanguage(void) const override { return sNullLang; } _ZN4Ogre17GpuNamedConstantsC2Ev: 201| 4.13k| GpuNamedConstants::GpuNamedConstants() : bufferSize(0), registerCount(0) {} _ZN4Ogre17GpuNamedConstantsD2Ev: 202| 4.01k| GpuNamedConstants::~GpuNamedConstants() {} _ZN4Ogre22GpuLogicalBufferStructC2Ev: 204| 4.01k| GpuLogicalBufferStruct::GpuLogicalBufferStruct() : bufferSize(0) {} _ZN4Ogre22GpuLogicalBufferStructD2Ev: 205| 4.01k| GpuLogicalBufferStruct::~GpuLogicalBufferStruct() {} _ZN4Ogre19GpuSharedParametersC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 329| 112| : mName(name), mVersion(0), mOffset(0), mDirty(false), mUseLinearColours(false) 330| 112| { 331| 112| } _ZN4Ogre19GpuSharedParameters21addConstantDefinitionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_15GpuConstantTypeEj: 344| 50| { 345| 50| if (mNamedConstants.map.find(name) != mNamedConstants.map.end()) ------------------ | Branch (345:13): [True: 2, False: 48] ------------------ 346| 2| { 347| 2| OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, 348| 2| "Constant entry with name '" + name + "' already exists. ", 349| 2| "GpuSharedParameters::addConstantDefinition"); 350| 2| } 351| 48| GpuConstantDefinition def; 352| 48| def.arraySize = arraySize; 353| 48| def.constType = constType; 354| | 355| | // here, we do not consider padding, but rather alignment 356| 48| def.elementSize = GpuConstantDefinition::getElementSize(constType, false); 357| | 358| | // we try to adhere to GLSL std140 packing rules 359| | // handle alignment requirements 360| 48| size_t align_size = std::min(def.elementSize == 3 ? 4 : def.elementSize, 4); // vec3 is 16 byte aligned, which is max ------------------ | Branch (360:46): [True: 2, False: 46] ------------------ 361| 48| align_size *= 4; // bytes 362| | 363| 48| size_t nextAlignedOffset = ((mOffset + align_size - 1) / align_size) * align_size; 364| | 365| | // abuse logical index to store offset 366| 48| if (mOffset + align_size > nextAlignedOffset) ------------------ | Branch (366:13): [True: 48, False: 0] ------------------ 367| 48| { 368| 48| def.logicalIndex = nextAlignedOffset; 369| 48| } 370| 0| else 371| 0| { 372| 0| def.logicalIndex = mOffset; 373| 0| } 374| | 375| 48| mOffset = def.logicalIndex + (def.constType == GCT_MATRIX_4X3 ? 16 : def.elementSize) * 4; // mat4x3 have a size of 64 bytes ------------------ | Branch (375:39): [True: 0, False: 48] ------------------ 376| | 377| 48| def.variability = (uint16)GPV_GLOBAL; 378| | 379| 48| if (def.isFloat()) ------------------ | Branch (379:13): [True: 9, False: 39] ------------------ 380| 9| { 381| 9| def.physicalIndex = mConstants.size(); 382| 9| mConstants.resize(mConstants.size() + def.arraySize * def.elementSize*4); 383| 9| } 384| 39| else if (def.isDouble()) ------------------ | Branch (384:18): [True: 0, False: 39] ------------------ 385| 0| { 386| 0| def.physicalIndex = mConstants.size(); 387| 0| mConstants.resize(mConstants.size() + def.arraySize * def.elementSize*8); 388| 0| } 389| 39| else if (def.isInt() || def.isUnsignedInt() || def.isBool()) ------------------ | Branch (389:18): [True: 14, False: 25] | Branch (389:33): [True: 25, False: 0] | Branch (389:56): [True: 0, False: 0] ------------------ 390| 39| { 391| 39| def.physicalIndex = mConstants.size(); 392| 39| mConstants.resize(mConstants.size() + def.arraySize * def.elementSize*4); 393| 39| } 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| 48| mNamedConstants.map[name] = def; 403| | 404| 48| ++mVersion; 405| 48| } _ZN4Ogre19GpuSharedParameters15setAutoConstantERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_20GpuProgramParameters16AutoConstantTypeE: 407| 2| { 408| 2| auto& def = mNamedConstants.map[name]; 409| 2| 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| 2| } _ZN4Ogre19GpuSharedParameters16setNamedConstantERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKfj: 602| 8| { 603| 8| _setNamedConstant(name, val, count); 604| 8| } _ZN4Ogre19GpuSharedParameters16setNamedConstantERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKij: 612| 13| { 613| 13| _setNamedConstant(name, val, count); 614| 13| } _ZN4Ogre19GpuSharedParameters16setNamedConstantERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKjj: 617| 7| { 618| 7| _setNamedConstant(name, val, count); 619| 7| } _ZN4Ogre19GpuSharedParameters10_markDirtyEv: 627| 28| { 628| 28| mDirty = true; 629| 28| } _ZN4Ogre20GpuProgramParametersC2Ev: 736| 3.00k| mCombinedVariability(GPV_GLOBAL) 737| 3.00k| , mTransposeMatrices(false) 738| 3.00k| , mIgnoreMissingParams(false) 739| 3.00k| , mActivePassIterationIndex(std::numeric_limits::max()) 740| 3.00k| , mUseLinearColours(false) 741| 3.00k| { 742| 3.00k| static_assert((sizeof(AutoConstantDictionary) / sizeof(AutoConstantDefinition) - 5) == ACT_FROXEL_RECORDS, 743| 3.00k| "AutoConstantDictionary out of sync"); 744| 3.00k| } _ZN4Ogre20GpuProgramParametersD2Ev: 745| 3.00k| GpuProgramParameters::~GpuProgramParameters() {} _ZN4Ogre20GpuProgramParameters18_setLogicalIndexesERKNS_9SharedPtrINS_22GpuLogicalBufferStructEEE: 818| 2.68k| { 819| 2.68k| mLogicalToPhysical = indexMap; 820| | 821| | // resize the internal buffers 822| | // Note that these will only contain something after the first parameter 823| | // set has set some parameters 824| | 825| | // Size and reset buffer (fill with zero to make comparison later ok) 826| 2.68k| if (indexMap && indexMap->bufferSize*4 > mConstants.size()) ------------------ | Branch (826:13): [True: 2.68k, False: 0] | Branch (826:25): [True: 0, False: 2.68k] ------------------ 827| 0| { 828| 0| mConstants.insert(mConstants.end(), indexMap->bufferSize * 4 - mConstants.size(), 0); 829| 0| } 830| 2.68k| } _ZN4Ogre20GpuProgramParameters30copyMatchingNamedConstantsFromERKS0_: 2458| 1.72k| { 2459| 1.72k| if (mNamedConstants && source.mNamedConstants) ------------------ | Branch (2459:13): [True: 0, False: 1.72k] | Branch (2459:32): [True: 0, False: 0] ------------------ 2460| 0| { 2461| 0| std::map srcToDestNamedMap; 2462| 0| for (auto& m : source.mNamedConstants->map) ------------------ | Branch (2462:26): [True: 0, False: 0] ------------------ 2463| 0| { 2464| 0| const String& paramName = m.first; 2465| 0| const GpuConstantDefinition& olddef = m.second; 2466| 0| const GpuConstantDefinition* newdef = _findNamedConstantDefinition(paramName, false); 2467| 0| if (newdef) ------------------ | Branch (2467:21): [True: 0, False: 0] ------------------ 2468| 0| { 2469| | // Copy data across, based on smallest common definition size 2470| 0| size_t srcsz = olddef.elementSize * olddef.arraySize; 2471| 0| size_t destsz = newdef->elementSize * newdef->arraySize; 2472| 0| size_t sz = std::min(srcsz, destsz); 2473| 0| if (newdef->isFloat() || newdef->isInt() || newdef->isUnsignedInt() || newdef->isBool()) ------------------ | Branch (2473:25): [True: 0, False: 0] | Branch (2473:46): [True: 0, False: 0] | Branch (2473:65): [True: 0, False: 0] | Branch (2473:92): [True: 0, False: 0] ------------------ 2474| 0| { 2475| 0| OgreAssert(mConstants.size() >= (newdef->physicalIndex + sz * 4), "Invalid physical index or size"); ------------------ | Branch (2475:25): [True: 0, False: 0] ------------------ 2476| 0| memcpy(getFloatPointer(newdef->physicalIndex), 2477| 0| source.getFloatPointer(olddef.physicalIndex), 2478| 0| sz * 4); 2479| 0| } 2480| 0| else if (newdef->isDouble()) ------------------ | Branch (2480:30): [True: 0, False: 0] ------------------ 2481| 0| { 2482| | 2483| 0| memcpy(getDoublePointer(newdef->physicalIndex), 2484| 0| source.getDoublePointer(olddef.physicalIndex), 2485| 0| sz * sizeof(double)); 2486| 0| } 2487| 0| else if (newdef->isSampler()) ------------------ | Branch (2487:30): [True: 0, False: 0] ------------------ 2488| 0| { 2489| 0| *getRegPointer(newdef->physicalIndex) = *source.getRegPointer(olddef.physicalIndex); 2490| 0| } 2491| 0| else 2492| 0| { 2493| | //TODO exception handling 2494| 0| } 2495| | // we'll use this map to resolve autos later 2496| | // ignore the [0] aliases 2497| 0| if (!StringUtil::endsWith(paramName, "[0]") && source.findAutoConstantEntry(paramName)) ------------------ | Branch (2497:25): [True: 0, False: 0] | Branch (2497:25): [True: 0, False: 0] | Branch (2497:68): [True: 0, False: 0] ------------------ 2498| 0| srcToDestNamedMap[olddef.physicalIndex] = paramName; 2499| 0| } 2500| 0| } 2501| | 2502| 0| for (const auto& autoEntry : source.mAutoConstants) ------------------ | Branch (2502:40): [True: 0, False: 0] ------------------ 2503| 0| { 2504| | // find dest physical index 2505| 0| std::map::iterator mi = srcToDestNamedMap.find(autoEntry.physicalIndex); 2506| 0| if (mi != srcToDestNamedMap.end()) ------------------ | Branch (2506:21): [True: 0, False: 0] ------------------ 2507| 0| { 2508| 0| if (getAutoConstantDefinition(autoEntry.paramType)->dataType == ACDT_REAL) ------------------ | Branch (2508:25): [True: 0, False: 0] ------------------ 2509| 0| { 2510| 0| setNamedAutoConstantReal(mi->second, autoEntry.paramType, autoEntry.fData); 2511| 0| } 2512| 0| else 2513| 0| { 2514| 0| setNamedAutoConstant(mi->second, autoEntry.paramType, autoEntry.data); 2515| 0| } 2516| 0| } 2517| | 2518| 0| } 2519| | 2520| | // Copy shared param sets 2521| 0| for (const auto& usage : source.mSharedParamSets) ------------------ | Branch (2521:36): [True: 0, False: 0] ------------------ 2522| 0| { 2523| 0| if (!isUsingSharedParameters(usage.getName())) ------------------ | Branch (2523:21): [True: 0, False: 0] ------------------ 2524| 0| { 2525| 0| addSharedParameters(usage.getSharedParams()); 2526| 0| } 2527| 0| } 2528| 0| } 2529| 1.72k| } _ZN4Ogre20GpuProgramParameters25getAutoConstantDefinitionERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 2533| 49| { 2534| | // find a constant definition that matches name by iterating through the 2535| | // constant definition array 2536| 49| bool nameFound = false; 2537| 49| size_t i = 0; 2538| 49| const size_t numDefs = getNumAutoConstantDefinitions(); 2539| 7.19k| while (!nameFound && (i < numDefs)) ------------------ | Branch (2539:16): [True: 7.19k, False: 2] | Branch (2539:30): [True: 7.14k, False: 47] ------------------ 2540| 7.14k| { 2541| 7.14k| if (name == AutoConstantDictionary[i].name) ------------------ | Branch (2541:17): [True: 2, False: 7.14k] ------------------ 2542| 2| nameFound = true; 2543| 7.14k| else 2544| 7.14k| ++i; 2545| 7.14k| } 2546| | 2547| 49| if (nameFound) ------------------ | Branch (2547:13): [True: 2, False: 47] ------------------ 2548| 2| return &AutoConstantDictionary[i]; 2549| 47| else 2550| 47| return 0; 2551| 49| } _ZN4Ogre20GpuProgramParameters29getNumAutoConstantDefinitionsEv: 2564| 49| { 2565| 49| return sizeof(AutoConstantDictionary)/sizeof(AutoConstantDefinition); 2566| 49| } _ZN4Ogre19GpuSharedParameters17_setNamedConstantIfEEvRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKT_j: 592| 8| { 593| 8| GpuConstantDefinitionMap::const_iterator i = mNamedConstants.map.find(name); 594| 8| if (i == mNamedConstants.map.end()) ------------------ | Branch (594:13): [True: 0, False: 8] ------------------ 595| 0| return; // ignore 596| | 597| 8| const GpuConstantDefinition& def = i->second; 598| 8| memcpy(&mConstants[def.physicalIndex], val, sizeof(float) * std::min(count, def.elementSize * def.arraySize)); 599| 8| _markDirty(); 600| 8| } _ZN4Ogre19GpuSharedParameters17_setNamedConstantIiEEvRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKT_j: 592| 13| { 593| 13| GpuConstantDefinitionMap::const_iterator i = mNamedConstants.map.find(name); 594| 13| if (i == mNamedConstants.map.end()) ------------------ | Branch (594:13): [True: 0, False: 13] ------------------ 595| 0| return; // ignore 596| | 597| 13| const GpuConstantDefinition& def = i->second; 598| 13| memcpy(&mConstants[def.physicalIndex], val, sizeof(float) * std::min(count, def.elementSize * def.arraySize)); 599| 13| _markDirty(); 600| 13| } _ZN4Ogre19GpuSharedParameters17_setNamedConstantIjEEvRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKT_j: 592| 7| { 593| 7| GpuConstantDefinitionMap::const_iterator i = mNamedConstants.map.find(name); 594| 7| if (i == mNamedConstants.map.end()) ------------------ | Branch (594:13): [True: 0, False: 7] ------------------ 595| 0| return; // ignore 596| | 597| 7| const GpuConstantDefinition& def = i->second; 598| 7| memcpy(&mConstants[def.physicalIndex], val, sizeof(float) * std::min(count, def.elementSize * def.arraySize)); 599| 7| _markDirty(); 600| 7| } _ZN4Ogre15GpuProgramUsageC2ENS_14GpuProgramTypeEPNS_4PassE: 36| 1.28k| mParent(parent), mProgram(), mRecreateParams(false),mType(gptype) 37| 1.28k| { 38| 1.28k| } _ZN4Ogre15GpuProgramUsageD2Ev: 51| 1.28k| { 52| 1.28k| if (mProgram) ------------------ | Branch (52:13): [True: 1.28k, False: 0] ------------------ 53| 1.28k| mProgram->removeListener(this); 54| 1.28k| } _ZN4Ogre15GpuProgramUsage17_getProgramByNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_NS_14GpuProgramTypeE: 59| 515| { 60| 515| GpuProgramPtr program = 61| 515| GpuProgramManager::getSingleton().getByName(name, group); 62| | 63| | //Look again without the group if not found 64| 515| if (!program) ------------------ | Branch (64:13): [True: 12, False: 503] ------------------ 65| 12| program = GpuProgramManager::getSingleton().getByName( 66| 12| name, ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME); 67| | 68| 515| if (!program) ------------------ | Branch (68:13): [True: 12, False: 503] ------------------ 69| 12| { 70| 12| String progType = GpuProgram::getProgramTypeName(type); 71| 12| OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, 72| 12| "Unable to locate " + progType + " program called " + name); 73| 12| } 74| | 75| 503| return program; 76| 515| } _ZN4Ogre15GpuProgramUsage10setProgramERKNS_9SharedPtrINS_10GpuProgramEEEb: 100| 3.00k| { 101| 3.00k| if (mProgram) ------------------ | Branch (101:13): [True: 1.72k, False: 1.28k] ------------------ 102| 1.72k| { 103| 1.72k| mProgram->removeListener(this); 104| 1.72k| mRecreateParams = true; 105| 1.72k| } 106| | 107| 3.00k| mProgram = prog; 108| | 109| | // Reset parameters 110| 3.00k| if (resetParams || !mParameters || mRecreateParams) ------------------ | Branch (110:13): [True: 3.00k, False: 0] | Branch (110:28): [True: 0, False: 0] | Branch (110:44): [True: 0, False: 0] ------------------ 111| 3.00k| { 112| 3.00k| recreateParameters(); 113| 3.00k| } 114| | 115| | // Listen in on reload events so we can regenerate params 116| 3.00k| mProgram->addListener(this); 117| 3.00k| } _ZN4Ogre15GpuProgramUsage18recreateParametersEv: 170| 3.00k| { 171| | // Keep a reference to old ones to copy 172| 3.00k| GpuProgramParametersSharedPtr savedParams = mParameters; 173| | 174| | // Create new params 175| 3.00k| mParameters = mProgram->createParameters(); 176| | 177| | // Copy old (matching) values across 178| | // Don't use copyConstantsFrom since program may be different 179| 3.00k| if (savedParams) ------------------ | Branch (179:13): [True: 1.72k, False: 1.28k] ------------------ 180| 1.72k| mParameters->copyMatchingNamedConstantsFrom(*savedParams.get()); 181| | 182| 3.00k| mRecreateParams = false; 183| | 184| 3.00k| } _ZNK4Ogre12LightFactory7getTypeEv: 874| 3| { 875| 3| return MOT_LIGHT; 876| 3| } _ZN4Ogre11LodStrategyC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 35| 4| : mName(name) 36| 4| { } _ZN4Ogre18LodStrategyManager12getSingletonEv: 43| 13.0k| { 44| | assert( msSingleton ); return ( *msSingleton ); 45| 13.0k| } _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| 124| { 111| | // If name is "default", return the default strategy instead of performing a lookup 112| 124| if (name == "default") { ------------------ | Branch (112:13): [True: 0, False: 124] ------------------ 113| 0| return getDefaultStrategy(); 114| 124| } else if (name == "Distance") { ------------------ | Branch (114:20): [True: 0, False: 124] ------------------ 115| 0| return getStrategy("distance_box"); // Backward compatibility for loading old meshes. 116| 124| } else if (name == "PixelCount") { ------------------ | Branch (116:20): [True: 0, False: 124] ------------------ 117| 0| return getStrategy("pixel_count"); // Backward compatibility for loading old meshes. 118| 0| } 119| | // Find strategy with specified name 120| 124| StrategyMap::iterator it = mStrategies.find(name); 121| | 122| | // If not found, return null 123| 124| if (it == mStrategies.end()) ------------------ | Branch (123:13): [True: 124, False: 0] ------------------ 124| 124| return 0; 125| | 126| | // Otherwise, return the strategy 127| 0| return it->second; 128| 124| } _ZN4Ogre18LodStrategyManager18setDefaultStrategyEPNS_11LodStrategyE: 131| 1| { 132| 1| mDefaultStrategy = strategy; 133| 1| } _ZN4Ogre18LodStrategyManager18getDefaultStrategyEv: 142| 12.9k| { 143| 12.9k| return mDefaultStrategy; 144| 12.9k| } _ZN4Ogre3LogC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbb: 52| 1| mLogLevel(LML_NORMAL), mDebugOut(debuggerOutput), 53| 1| mSuppressFile(suppressFile), mTimeStamp(true), mLogName(name), mTermHasColours(false) 54| 1| { 55| 1| if (!mSuppressFile) ------------------ | Branch (55:13): [True: 1, False: 0] ------------------ 56| 1| { 57| 1| mLog.open(name.c_str()); 58| | 59| |#if (OGRE_PLATFORM == OGRE_PLATFORM_WIN32 || OGRE_PLATFORM == OGRE_PLATFORM_WINRT) && _WIN32_WINNT >= _WIN32_WINNT_VISTA 60| | // Register log file to be collected by Windows Error Reporting 61| | const int utf16Length = ::MultiByteToWideChar(CP_ACP, 0, name.c_str(), (int)name.size(), NULL, 0); 62| | if(utf16Length > 0) 63| | { 64| | std::wstring wname; 65| | wname.resize(utf16Length); 66| | if (0 != ::MultiByteToWideChar(CP_ACP, 0, name.c_str(), (int)name.size(), &wname[0], (int)wname.size())) 67| | WerRegisterFile(wname.c_str(), WerRegFileTypeOther, WER_FILE_ANONYMOUS_DATA); 68| | } 69| |#endif 70| 1| } 71| | 72| 1|#if OGRE_PLATFORM != OGRE_PLATFORM_WINRT 73| 1| char* val = getenv("OGRE_MIN_LOGLEVEL"); 74| 1| int min_lml; 75| 1| if(val && StringConverter::parse(val, min_lml)) ------------------ | Branch (75:12): [True: 0, False: 1] | Branch (75:12): [True: 0, False: 1] | Branch (75:19): [True: 0, False: 0] ------------------ 76| 0| setMinLogLevel(LogMessageLevel(min_lml)); 77| | 78| 1| if(mDebugOut) ------------------ | Branch (78:12): [True: 0, False: 1] ------------------ 79| 0| { 80| 0| val = getenv("TERM"); 81| 0| mTermHasColours = val && String(val).find("xterm") != String::npos; ------------------ | Branch (81:31): [True: 0, False: 0] | Branch (81:38): [True: 0, False: 0] ------------------ 82| 0| } 83| 1|#endif 84| 1| } _ZN4Ogre3Log10logMessageERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_15LogMessageLevelEb: 97| 33.5k| { 98| 33.5k| OGRE_LOCK_AUTO_MUTEX; 99| 33.5k| if (lml >= mLogLevel) ------------------ | Branch (99:13): [True: 4.67k, False: 28.8k] ------------------ 100| 4.67k| { 101| 4.67k| bool skipThisMessage = false; 102| 4.67k| for(auto & l : mListeners) ------------------ | Branch (102:26): [True: 0, False: 4.67k] ------------------ 103| 0| l->messageLogged( message, lml, maskDebug, mLogName, skipThisMessage); 104| | 105| 4.67k| if (!skipThisMessage) ------------------ | Branch (105:17): [True: 4.67k, False: 0] ------------------ 106| 4.67k| { 107| 4.67k| if (mDebugOut && !maskDebug) ------------------ | Branch (107:21): [True: 0, False: 4.67k] | Branch (107:34): [True: 0, False: 0] ------------------ 108| 0| { 109| |# if (OGRE_PLATFORM == OGRE_PLATFORM_WIN32 || OGRE_PLATFORM == OGRE_PLATFORM_WINRT) && OGRE_DEBUG_MODE 110| | OutputDebugStringA("Ogre: "); 111| | OutputDebugStringA(message.c_str()); 112| | OutputDebugStringA("\n"); 113| |# endif 114| | 115| 0| std::ostream& os = int(lml) >= int(LML_WARNING) ? std::cerr : std::cout; ------------------ | Branch (115:40): [True: 0, False: 0] ------------------ 116| | 117| 0| if(mTermHasColours) { ------------------ | Branch (117:24): [True: 0, False: 0] ------------------ 118| 0| if(lml == LML_WARNING) ------------------ | Branch (118:28): [True: 0, False: 0] ------------------ 119| 0| os << YELLOW; 120| 0| if(lml == LML_CRITICAL) ------------------ | Branch (120:28): [True: 0, False: 0] ------------------ 121| 0| os << RED; 122| 0| } 123| | 124| 0| os << message; 125| | 126| 0| if(mTermHasColours) { ------------------ | Branch (126:24): [True: 0, False: 0] ------------------ 127| 0| os << RESET; 128| 0| } 129| | 130| 0| os << std::endl; 131| 0| } 132| | 133| | // Write time into log 134| 4.67k| if (!mSuppressFile) ------------------ | Branch (134:21): [True: 4.67k, False: 0] ------------------ 135| 4.67k| { 136| 4.67k| if (mTimeStamp) ------------------ | Branch (136:25): [True: 4.67k, False: 0] ------------------ 137| 4.67k| { 138| 4.67k| auto t = std::time(nullptr); 139| 4.67k| auto pTime = std::localtime(&t); 140| 4.67k| mLog << std::put_time(pTime, "%H:%M:%S: "); 141| 4.67k| } 142| 4.67k| mLog << message << std::endl; 143| | 144| | // Flush stcmdream to ensure it is written (incase of a crash, we need log to be up to date) 145| 4.67k| mLog.flush(); 146| 4.67k| } 147| 4.67k| } 148| 4.67k| } 149| 33.5k| } _ZN4Ogre3Log14setMinLogLevelENS_15LogMessageLevelE: 173| 1| { 174| 1| OGRE_LOCK_AUTO_MUTEX; 175| 1| mLogLevel = lml; 176| 1| } _ZN4Ogre3Log6streamENS_15LogMessageLevelEb: 196| 4.67k| { 197| 4.67k| return Stream(this, lml, maskDebug); 198| | 199| 4.67k| } _ZN4Ogre10LogManager15getSingletonPtrEv: 35| 1| { 36| 1| return msSingleton; 37| 1| } _ZN4Ogre10LogManager12getSingletonEv: 39| 33.5k| { 40| | assert( msSingleton ); return ( *msSingleton ); 41| 33.5k| } _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| 28.8k| { 126| 28.8k| OGRE_LOCK_AUTO_MUTEX; 127| 28.8k| if (mDefaultLog) ------------------ | Branch (127:13): [True: 28.8k, False: 0] ------------------ 128| 28.8k| { 129| 28.8k| mDefaultLog->logMessage(message, lml, maskDebug); 130| 28.8k| } 131| 28.8k| } _ZN4Ogre10LogManager8logErrorERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb: 134| 4.67k| { 135| 4.67k| stream(LML_CRITICAL, maskDebug) << "Error: " << message; 136| 4.67k| } _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| 4.67k| { 165| 4.67k| OGRE_LOCK_AUTO_MUTEX; 166| 4.67k| OgreAssert(mDefaultLog, "Default log not found"); ------------------ | Branch (166:9): [True: 0, False: 4.67k] ------------------ 167| 4.67k| return mDefaultLog->stream(lml, maskDebug); 168| 4.67k| } _ZNK4Ogre19ManualObjectFactory7getTypeEv: 723| 3| { 724| 3| return MOT_MANUAL_OBJECT; 725| 3| } _ZN4Ogre8MaterialC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE: 39| 12.9k| :Resource(creator, name, handle, group, false, NULL), 40| 12.9k| mReceiveShadows(true), 41| 12.9k| mTransparencyCastsShadows(false), 42| 12.9k| mCompilationRequired(true) 43| 12.9k| { 44| | // Override isManual, not applicable for Material (we always want to call loadImpl) 45| 12.9k| if(isManual) ------------------ | Branch (45:12): [True: 0, False: 12.9k] ------------------ 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| 12.9k| mLodStrategy = LodStrategyManager::getSingleton().getDefaultStrategy(); 54| | 55| 12.9k| mLodValues.push_back(0.0f); 56| | 57| 12.9k| 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| 12.9k| createParamDictionary("Material"); 65| 12.9k| } _ZN4Ogre8MaterialD2Ev: 68| 12.9k| { 69| 12.9k| removeAllTechniques(); 70| | // have to call this here reather than in Resource destructor 71| | // since calling virtual methods in base destructors causes crash 72| 12.9k| unload(); 73| 12.9k| } _ZN4Ogre8MaterialaSERKS0_: 76| 12.9k| { 77| 12.9k| if (this == &rhs) ------------------ | Branch (77:13): [True: 0, False: 12.9k] ------------------ 78| 0| return *this; 79| | 80| 12.9k| Resource::operator=(rhs); 81| 12.9k| mReceiveShadows = rhs.mReceiveShadows; 82| 12.9k| mTransparencyCastsShadows = rhs.mTransparencyCastsShadows; 83| | 84| | // Copy Techniques 85| 12.9k| this->removeAllTechniques(); 86| 12.9k| for(auto *t : rhs.mTechniques) ------------------ | Branch (86:21): [True: 12.9k, False: 12.9k] ------------------ 87| 12.9k| { 88| 12.9k| Technique* tech = this->createTechnique(); 89| 12.9k| *tech = *t; 90| 12.9k| if (t->isSupported()) ------------------ | Branch (90:17): [True: 0, False: 12.9k] ------------------ 91| 0| { 92| 0| insertSupportedTechnique(tech); 93| 0| } 94| 12.9k| } 95| | 96| | // Also copy LOD information 97| 12.9k| mUserLodValues = rhs.mUserLodValues; 98| 12.9k| mLodValues = rhs.mLodValues; 99| 12.9k| mLodStrategy = rhs.mLodStrategy; 100| 12.9k| mCompilationRequired = rhs.mCompilationRequired; 101| | 102| | // creating techniques moves us into unloaded state 103| | // insertSupportedTechnique is equivalent to prepare 104| 12.9k| if(rhs.isLoaded()) ------------------ | Branch (104:12): [True: 0, False: 12.9k] ------------------ 105| 0| load(); 106| | 107| 12.9k| return *this; 108| 12.9k| } _ZN4Ogre8Material13applyDefaultsEv: 217| 12.9k| { 218| 12.9k| MaterialPtr defaults = MaterialManager::getSingleton().getDefaultSettings(); 219| | 220| 12.9k| if (defaults) ------------------ | Branch (220:13): [True: 12.9k, False: 1] ------------------ 221| 12.9k| { 222| | // save name & handle 223| 12.9k| String savedName = mName; 224| 12.9k| String savedGroup = mGroup; 225| 12.9k| ResourceHandle savedHandle = mHandle; 226| 12.9k| *this = *defaults; 227| | // restore name & handle 228| 12.9k| mName = savedName; 229| 12.9k| mHandle = savedHandle; 230| 12.9k| mGroup = savedGroup; 231| 12.9k| } 232| 12.9k| _notifyNeedsRecompile(); 233| | 234| 12.9k| } _ZN4Ogre8Material15createTechniqueEv: 237| 24.6k| { 238| | Technique *t = OGRE_NEW Technique(this); 239| 24.6k| mTechniques.push_back(t); 240| 24.6k| _notifyNeedsRecompile(); 241| 24.6k| return t; 242| 24.6k| } _ZN4Ogre8Material19removeAllTechniquesEv: 367| 38.5k| { 368| 38.5k| for (auto *t : mTechniques) ------------------ | Branch (368:22): [True: 24.6k, False: 38.5k] ------------------ 369| 24.6k| { 370| | OGRE_DELETE t; 371| 24.6k| } 372| 38.5k| mTechniques.clear(); 373| 38.5k| clearBestTechniqueList(); 374| 38.5k| } _ZN4Ogre8Material22clearBestTechniqueListEv: 437| 38.5k| { 438| 38.5k| mSupportedTechniques.clear(); 439| 38.5k| mBestTechniquesBySchemeList.clear(); 440| 38.5k| _notifyNeedsRecompile(); 441| 38.5k| } _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| 92.0k| { 535| 92.0k| mCompilationRequired = true; 536| | // Also need to unload to ensure we loaded any new items 537| 92.0k| if (isLoaded()) // needed to stop this being called in 'loading' state ------------------ | Branch (537:13): [True: 0, False: 92.0k] ------------------ 538| 0| unload(); 539| 92.0k| } _ZN4Ogre8Material12setLodLevelsERKNSt3__16vectorIfNS1_9allocatorIfEEEE: 542| 191| { 543| | // Square the distances for the internal list 544| | // First, clear and add single zero entry 545| 191| mLodValues.clear(); 546| 191| mUserLodValues.clear(); 547| 191| mUserLodValues.push_back(0); 548| 191| if (mLodStrategy) ------------------ | Branch (548:13): [True: 191, False: 0] ------------------ 549| 191| mLodValues.push_back(mLodStrategy->getBaseValue()); 550| 191| for (auto& v : lodValues) ------------------ | Branch (550:22): [True: 211, False: 191] ------------------ 551| 211| { 552| 211| mUserLodValues.push_back(v); 553| 211| if (mLodStrategy) ------------------ | Branch (553:17): [True: 211, False: 0] ------------------ 554| 211| mLodValues.push_back(mLodStrategy->transformUserValue(v)); 555| 211| } 556| 191| } _ZN4Ogre8Material14setLodStrategyEPNS_11LodStrategyE: 579| 1| { 580| 1| mLodStrategy = lodStrategy; 581| | 582| 1| assert(mLodValues.size()); 583| 1| mLodValues[0] = mLodStrategy->getBaseValue(); 584| | 585| | // Re-transform all user LOD values (starting at index 1, no need to transform base value) 586| 1| for (size_t i = 1; i < mUserLodValues.size(); ++i) ------------------ | Branch (586:28): [True: 0, False: 1] ------------------ 587| 0| mLodValues[i] = mLodStrategy->transformUserValue(mUserLodValues[i]); 588| 1| } _ZN4Ogre15MaterialManager15getSingletonPtrEv: 40| 37.6k| { 41| 37.6k| return msSingleton; 42| 37.6k| } _ZN4Ogre15MaterialManager12getSingletonEv: 44| 65.7k| { 45| | assert( msSingleton ); return ( *msSingleton ); 46| 65.7k| } _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| 12.9k| { 84| | return OGRE_NEW Material(this, name, handle, group, isManual, loader); 85| 12.9k| } _ZN4Ogre15MaterialManager6createERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE: 90| 12.9k| { 91| 12.9k| return static_pointer_cast(createResource(name,group,isManual,loader,createParams)); 92| 12.9k| } _ZNK4Ogre15MaterialManager9getByNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 95| 1.99k| { 96| 1.99k| return static_pointer_cast(getResourceByName(name, groupName)); 97| 1.99k| } _ZN4Ogre15MaterialManager18getDefaultMaterialEb: 99| 10| MaterialPtr MaterialManager::getDefaultMaterial(bool useLighting) { 100| 10| MaterialPtr ret = getByName(useLighting ? "BaseWhite" : "BaseWhiteNoLighting", ------------------ | Branch (100:37): [True: 10, False: 0] ------------------ 101| 10| ResourceGroupManager::INTERNAL_RESOURCE_GROUP_NAME); 102| | 103| 10| OgreAssert(ret, ------------------ | Branch (103:9): [True: 0, False: 10] ------------------ 104| 10| "Can't find default material Did you forget to call MaterialManager::initialise()?"); 105| | 106| 10| return ret; 107| 10| } _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| 189| { 162| 189| unsigned short ret = 0; 163| 189| SchemeMap::iterator i = mSchemes.find(schemeName); 164| 189| if (i != mSchemes.end()) ------------------ | Branch (164:13): [True: 135, False: 54] ------------------ 165| 135| { 166| 135| ret = i->second; 167| 135| } 168| 54| else 169| 54| { 170| | // Create new 171| 54| ret = static_cast(mSchemes.size()); 172| 54| mSchemes[schemeName] = ret; 173| 54| } 174| 189| return ret; 175| | 176| 189| } _ZN4Ogre15MaterialManager38_notifyBeforeIlluminationPassesClearedEPNS_9TechniqueE: 273| 37.6k| { 274| | // First, check the scheme specific listeners 275| 37.6k| ListenerMap::iterator it = mListenerMap.find(mActiveSchemeName); 276| 37.6k| if(it != mListenerMap.end()) ------------------ | Branch (276:6): [True: 0, False: 37.6k] ------------------ 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| 37.6k| it = mListenerMap.find(BLANKSTRING); 289| 37.6k| if(it != mListenerMap.end()) ------------------ | Branch (289:6): [True: 0, False: 37.6k] ------------------ 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| 37.6k| } _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(); 72| 1| Codec::registerCodec(mMeshCodec.get()); 73| | 74| 1| ResourceGroupManager::getSingleton()._registerResourceManager(mResourceType, this); 75| | 76| 1| mPrefabLoader = std::make_unique(); 77| 1| } _ZNK4Ogre9MeshCodec7getTypeEv: 39| 1| String getType() const override { return "mesh"; } _ZN4Ogre13MovableObjectC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 43| 10| : mName(name) 44| 10| , mCreator(0) 45| 10| , mManager(0) 46| 10| , mParentNode(0) 47| 10| , mListener(0) 48| 10| , mParentIsTagPoint(false) 49| 10| , mVisible(true) 50| 10| , mDebugDisplay(false) 51| 10| , mBeyondFarDistance(false) 52| 10| , mCastShadows(true) 53| 10| , mRenderQueueIDSet(false) 54| 10| , mRenderQueuePrioritySet(false) 55| 10| , mRenderingDisabled(false) 56| 10| , mRenderQueueID(RENDER_QUEUE_MAIN) 57| 10| , mRenderQueuePriority(100) 58| 10| , mUpperDistance(0) 59| 10| , mSquaredUpperDistance(0) 60| 10| , mMinPixelSize(0) 61| 10| , mQueryFlags(msDefaultQueryFlags) 62| 10| , mVisibilityFlags(msDefaultVisibilityFlags) 63| 10| , mLightListUpdated(0) 64| 10| , mLightMask(0xFFFFFFFF) 65| 10| { 66| 10| if (Root::getSingletonPtr()) ------------------ | Branch (66:13): [True: 10, False: 0] ------------------ 67| 10| mMinPixelSize = Root::getSingleton().getDefaultMinPixelSize(); 68| 10| } _ZN4Ogre13MovableObjectD2Ev: 71| 10| { 72| | // Call listener (note, only called if there's something to do) 73| 10| if (mListener) ------------------ | Branch (73:13): [True: 0, False: 10] ------------------ 74| 0| { 75| 0| mListener->objectDestroyed(this); 76| 0| } 77| | 78| 10| detachFromParent(); // this should never throw, if it does terminating is the thing to do 79| 10| } _ZN4Ogre13MovableObject16detachFromParentEv: 118| 10| { 119| 10| if (isAttached()) ------------------ | Branch (119:13): [True: 0, False: 10] ------------------ 120| 0| { 121| 0| if (mParentIsTagPoint) ------------------ | Branch (121:17): [True: 0, False: 0] ------------------ 122| 0| { 123| 0| TagPoint* tp = static_cast(mParentNode); 124| 0| tp->getParentEntity()->detachObjectFromBone(this); 125| 0| } 126| 0| else 127| 0| { 128| 0| SceneNode* sn = static_cast(mParentNode); 129| 0| sn->detachObject(this); 130| 0| } 131| 0| } 132| 10| } _ZN4Ogre18MurmurHash3_x86_32EPKvmjPv: 98| 102|{ 99| 102| const uint8_t * data = (const uint8_t*)key; 100| 102| const int nblocks = len / 4; 101| | 102| 102| uint32_t h1 = seed; 103| | 104| 102| const uint32_t c1 = 0xcc9e2d51; 105| 102| const uint32_t c2 = 0x1b873593; 106| | 107| | //---------- 108| | // body 109| | 110| 102| const uint32_t * blocks = (const uint32_t *)(data + nblocks*4); 111| | 112| 261| for(int i = -nblocks; i; i++) ------------------ | Branch (112:25): [True: 159, False: 102] ------------------ 113| 159| { 114| 159| uint32_t k1 = getblock32(blocks,i); 115| | 116| 159| k1 *= c1; 117| 159| k1 = ROTL32(k1,15); ------------------ | | 44| 159|#define ROTL32(x,y) rotl32(x,y) ------------------ 118| 159| k1 *= c2; 119| | 120| 159| h1 ^= k1; 121| 159| h1 = ROTL32(h1,13); ------------------ | | 44| 159|#define ROTL32(x,y) rotl32(x,y) ------------------ 122| 159| h1 = h1*5+0xe6546b64; 123| 159| } 124| | 125| | //---------- 126| | // tail 127| | 128| 102| const uint8_t * tail = (const uint8_t*)(data + nblocks*4); 129| | 130| 102| uint32_t k1 = 0; 131| | 132| 102| switch(len & 3) ------------------ | Branch (132:10): [True: 93, False: 9] ------------------ 133| 102| { 134| 36| case 3: k1 ^= tail[2] << 16; OGRE_FALLTHROUGH; ------------------ | Branch (134:3): [True: 36, False: 66] ------------------ 135| 57| case 2: k1 ^= tail[1] << 8; OGRE_FALLTHROUGH; ------------------ | Branch (135:3): [True: 21, False: 81] ------------------ 136| 93| case 1: k1 ^= tail[0]; ------------------ | Branch (136:3): [True: 36, False: 66] ------------------ 137| 93| k1 *= c1; k1 = ROTL32(k1,15); k1 *= c2; h1 ^= k1; ------------------ | | 44| 93|#define ROTL32(x,y) rotl32(x,y) ------------------ 138| 102| }; 139| | 140| | //---------- 141| | // finalization 142| | 143| 102| h1 ^= len; 144| | 145| 102| h1 = fmix32(h1); 146| | 147| 102| *(uint32_t*)out = h1; 148| 102|} _ZN4Ogre10getblock32EPKji: 58| 159|{ 59| 159| return p[i]; 60| 159|} _Z6rotl32ja: 35| 411|{ 36| 411| return (x << r) | (x >> (32 - r)); 37| 411|} _ZN4Ogre6fmix32Ej: 71| 102|{ 72| 102| h ^= h >> 16; 73| 102| h *= 0x85ebca6b; 74| 102| h ^= h >> 13; 75| 102| h *= 0xc2b2ae35; 76| 102| h ^= h >> 16; 77| | 78| 102| return h; 79| 102|} _ZN4Ogre13OptimisedUtil21_detectImplementationEv: 326| 2| { 327| | // 328| | // Some speed test results (averaged number of CPU timestamp (RDTSC) per-function call): 329| | // 330| | // Dagon SkeletonAnimation sample - softwareVertexSkinning: 331| | // 332| | // Pentium 4 3.0G HT Athlon XP 2500+ Athlon 64 X2 Dual Core 3800+ 333| | // 334| | // Shared Buffers, General C 763677 462903 473038 335| | // Shared Buffers, Unrolled SSE 210030 *best* 369762 228328 *best* 336| | // Shared Buffers, General SSE 286202 352412 *best* 302796 337| | // 338| | // Separated Buffers, General C 762640 464840 478740 339| | // Separated Buffers, Unrolled SSE 219222 *best* 287992 *best* 238770 *best* 340| | // Separated Buffers, General SSE 290129 341614 307262 341| | // 342| | // PosOnly, General C 388663 257350 262831 343| | // PosOnly, Unrolled SSE 139814 *best* 200323 *best* 168995 *best* 344| | // PosOnly, General SSE 172693 213704 175447 345| | // 346| | // Another my own test scene - softwareVertexSkinning: 347| | // 348| | // Pentium P4 3.0G HT Athlon XP 2500+ 349| | // 350| | // Shared Buffers, General C 74527 - 351| | // Shared Buffers, Unrolled SSE 22743 *best* - 352| | // Shared Buffers, General SSE 28527 - 353| | // 354| | // 355| | // Note that speed test appears unaligned load/store instruction version 356| | // loss performance 5%-10% than aligned load/store version, even if both 357| | // of them access to aligned data. Thus, we should use aligned load/store 358| | // as soon as possible. 359| | // 360| | // 361| | // We are pick up the implementation based on test results above. 362| | // 363| |#ifdef __DO_PROFILE__ 364| | { 365| | static OptimisedUtilProfiler msOptimisedUtilProfiler; 366| | return &msOptimisedUtilProfiler; 367| | } 368| | 369| |#else // !__DO_PROFILE__ 370| | 371| 2|#if __OGRE_HAVE_SSE 372| 2| if (PlatformInformation::getCpuFeatures() & PlatformInformation::CPU_FEATURE_SSE) ------------------ | Branch (372:13): [True: 2, False: 0] ------------------ 373| 2| { 374| 2| return _getOptimisedUtilSSE(); 375| 2| } 376| 0| else 377| |#elif __OGRE_HAVE_NEON 378| | if (PlatformInformation::getCpuFeatures() & PlatformInformation::CPU_FEATURE_NEON) 379| | { 380| | return _getOptimisedUtilSSE(); 381| | } 382| | else 383| |#endif // __OGRE_HAVE_SSE 384| 0| { 385| 0| return _getOptimisedUtilGeneral(); 386| 0| } 387| | 388| 2|#endif // __DO_PROFILE__ 389| 2| } _ZN4Ogre16OptimisedUtilSSEC2Ev: 1040| 2| : mPreferGeneralVersionForSharedBuffers(false) 1041| 2| { 1042| | // For AMD Athlon XP (but not that for Althon 64), it's prefer to never use 1043| | // unrolled version for shared buffers at all, I guess because that version 1044| | // run out of usable CPU registers, or L1/L2 cache related problem, causing 1045| | // slight performance loss than general version. 1046| | // 1047| 2|#if __OGRE_HAVE_NEON == 0 1048| 2| if (PlatformInformation::getCpuIdentifier().find("AuthenticAMD") != String::npos) ------------------ | Branch (1048:13): [True: 2, False: 0] ------------------ 1049| 2| { 1050| | // How can I check it's an Athlon XP but not Althon 64? 1051| | // Ok, just test whether supports SSE2/SSE3 or not, if not, 1052| | // assume general version faster than unrolled version :) 1053| | // 1054| 2| if (!(PlatformInformation::getCpuFeatures() & ------------------ | Branch (1054:17): [True: 0, False: 2] ------------------ 1055| 2| (PlatformInformation::CPU_FEATURE_SSE2 | PlatformInformation::CPU_FEATURE_SSE3))) 1056| 0| { 1057| 0| mPreferGeneralVersionForSharedBuffers = true; 1058| 0| } 1059| 2| } 1060| 2|#endif 1061| 2| } _ZN4Ogre20_getOptimisedUtilSSEEv: 2141| 2| { 2142| 2| static OptimisedUtilSSE msOptimisedUtilSSE; 2143| |#if defined(__OGRE_SIMD_ALIGN_STACK) 2144| | static OptimisedUtilWithStackAlign msOptimisedUtilWithStackAlign(&msOptimisedUtilSSE); 2145| | return &msOptimisedUtilWithStackAlign; 2146| |#else 2147| 2| return &msOptimisedUtilSSE; 2148| 2|#endif 2149| 2| } _ZN4Ogre14ParticleSystemC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 181| 10| : MovableObject(name), 182| 10| mAABB(), 183| 10| mBoundingRadius(1.0f), 184| 10| mBoundsAutoUpdate(true), 185| 10| mBoundsUpdateTime(10.0f), 186| 10| mUpdateRemainTime(0), 187| 10| mResourceGroupName(resourceGroup), 188| 10| mIsRendererConfigured(false), 189| 10| mSpeedFactor(1.0f), 190| 10| mIterationInterval(0), 191| 10| mIterationIntervalSet(false), 192| 10| mSorted(false), 193| 10| mLocalSpace(false), 194| 10| mNonvisibleTimeout(0), 195| 10| mNonvisibleTimeoutSet(false), 196| 10| mTimeSinceLastVisible(0), 197| 10| mLastVisibleFrame(Root::getSingleton().getNextFrameNumber()), 198| 10| mTimeController(0), 199| 10| mEmittedEmitterPoolInitialised(false), 200| 10| mIsEmitting(true), 201| 10| mRenderer(0), 202| 10| mCullIndividual(false), 203| 10| mPoolSize(0), 204| 10| mEmittedEmitterPoolSize(0) 205| 10| { 206| 10| setDefaultDimensions( 100, 100 ); 207| 10| mMaterial = MaterialManager::getSingleton().getDefaultMaterial(); 208| | // Default to 10 particles, expect app to specify (will only be increased, not decreased) 209| 10| setParticleQuota( 10 ); 210| 10| setEmittedEmitterQuota( 3 ); 211| 10| initParameters(); 212| | 213| | // Default to billboard renderer 214| 10| setRenderer("billboard"); 215| 10| mCastShadows = false; 216| 10| } _ZN4Ogre14ParticleSystem16setParticleQuotaEm: 384| 10| { 385| | // Never shrink below size() 386| 10| size_t currSize = mParticlePool.size(); 387| | 388| 10| if( currSize < size ) ------------------ | Branch (388:13): [True: 10, False: 0] ------------------ 389| 10| { 390| | // Will allocate particles on demand 391| 10| mPoolSize = size; 392| | 393| 10| } 394| 10| } _ZN4Ogre14ParticleSystem22setEmittedEmitterQuotaEm: 402| 10| { 403| | // Never shrink below size() 404| 10| size_t currSize = 0; 405| 10| for (auto& kv : mEmittedEmitterPool) ------------------ | Branch (405:23): [True: 0, False: 10] ------------------ 406| 0| { 407| 0| currSize += kv.second.size(); 408| 0| } 409| | 410| 10| if( currSize < size ) ------------------ | Branch (410:13): [True: 10, False: 0] ------------------ 411| 10| { 412| | // Will allocate emitted emitters on demand 413| 10| mEmittedEmitterPoolSize = size; 414| 10| } 415| 10| } _ZN4Ogre14ParticleSystem14initParametersEv: 771| 10| { 772| 10| if (createParamDictionary("ParticleSystem")) ------------------ | Branch (772:13): [True: 1, False: 9] ------------------ 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| 10| } _ZN4Ogre14ParticleSystem20setDefaultDimensionsEff: 932| 10| { 933| 10| assert(width >= 0 && height >= 0 && "Particle dimensions can not be negative"); 934| 10| mDefaultWidth = width; 935| 10| mDefaultHeight = height; 936| 10| if (mRenderer) ------------------ | Branch (936:13): [True: 0, False: 10] ------------------ 937| 0| { 938| 0| mRenderer->_notifyDefaultDimensions(width, height); 939| 0| } 940| 10| } _ZN4Ogre14ParticleSystem11setRendererERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 1068| 10| { 1069| 10| if (mRenderer) ------------------ | Branch (1069:13): [True: 0, False: 10] ------------------ 1070| 0| { 1071| | // Destroy existing 1072| 0| ParticleSystemManager::getSingleton()._destroyRenderer(mRenderer); 1073| 0| mRenderer = 0; 1074| 0| } 1075| | 1076| 10| if (!rendererName.empty()) ------------------ | Branch (1076:13): [True: 10, False: 0] ------------------ 1077| 10| { 1078| 10| mRenderer = ParticleSystemManager::getSingleton()._createRenderer(rendererName); 1079| 10| mIsRendererConfigured = false; 1080| 10| } 1081| 10| } _ZN4Ogre21ParticleSystemManager12getSingletonEv: 47| 7.22k| { 48| | assert( msSingleton ); return ( *msSingleton ); 49| 7.22k| } _ZN4Ogre21ParticleSystemManagerC2Ev: 52| 1| { 53| 1| OGRE_LOCK_AUTO_MUTEX; 54| | mFactory = OGRE_NEW ParticleSystemFactory(); 55| 1| Root::getSingleton().addMovableObjectFactory(mFactory); 56| 1| } _ZN4Ogre21ParticleSystemManager18removeAllTemplatesEb: 133| 7.20k| { 134| 7.20k| OGRE_LOCK_AUTO_MUTEX; 135| 7.20k| if (deleteTemplate) ------------------ | Branch (135:13): [True: 7.20k, False: 0] ------------------ 136| 7.20k| { 137| 7.20k| ParticleTemplateMap::iterator itr; 138| 7.20k| for (itr = mSystemTemplates.begin(); itr != mSystemTemplates.end(); ++itr) ------------------ | Branch (138:50): [True: 0, False: 7.20k] ------------------ 139| 7.20k| OGRE_DELETE itr->second; 140| 7.20k| } 141| | 142| 7.20k| mSystemTemplates.clear(); 143| 7.20k| } _ZN4Ogre21ParticleSystemManager14createTemplateERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 164| 10| { 165| 10| OGRE_LOCK_AUTO_MUTEX; 166| | // check name 167| 10| if (mSystemTemplates.find(name) != mSystemTemplates.end()) ------------------ | Branch (167:13): [True: 0, False: 10] ------------------ 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| 10| ParticleSystem* tpl = OGRE_NEW ParticleSystem(name, resourceGroup); 180| 10| addTemplate(name, tpl); 181| 10| return tpl; 182| | 183| 10| } _ZN4Ogre21ParticleSystemManager15_createRendererERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 293| 10| { 294| 10| OGRE_LOCK_AUTO_MUTEX; 295| | // Locate affector type 296| 10| ParticleSystemRendererFactoryMap::iterator pFact = mRendererFactories.find(rendererType); 297| | 298| 10| if (pFact == mRendererFactories.end()) ------------------ | Branch (298:13): [True: 10, False: 0] ------------------ 299| 10| { 300| 10| OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Cannot find requested renderer type.", 301| 10| "ParticleSystemManager::_createRenderer"); 302| 10| } 303| | 304| 0| return pFact->second->createInstance(rendererType); 305| 10| } _ZNK4Ogre21ParticleSystemFactory7getTypeEv: 397| 3| { 398| 3| return MOT_PARTICLE_SYSTEM; 399| 3| } _ZN4Ogre4Pass22getBuiltinHashFunctionENS0_19BuiltinHashFunctionE: 92| 25.3k| { 93| 25.3k| Pass::HashFunc* hashFunc = NULL; 94| | 95| 25.3k| switch(builtin) ------------------ | Branch (95:16): [True: 25.3k, False: 0] ------------------ 96| 25.3k| { 97| 22.3k| case MIN_TEXTURE_CHANGE: ------------------ | Branch (97:9): [True: 22.3k, False: 3.00k] ------------------ 98| 22.3k| hashFunc = &sMinTextureStateChangeHashFunc; 99| 22.3k| break; 100| 3.00k| case MIN_GPU_PROGRAM_CHANGE: ------------------ | Branch (100:9): [True: 3.00k, False: 22.3k] ------------------ 101| 3.00k| hashFunc = &sMinGpuProgramChangeHashFunc; 102| 3.00k| break; 103| 25.3k| } 104| | 105| 25.3k| return hashFunc; 106| 25.3k| } _ZN4Ogre4PassC2EPNS_9TechniqueEt: 122| 11.5k| : mParent(parent) 123| 11.5k| , mHash(0) 124| 11.5k| , mAmbient(ColourValue::White) 125| 11.5k| , mDiffuse(ColourValue::White) 126| 11.5k| , mSpecular(ColourValue::Black) 127| 11.5k| , mEmissive(ColourValue::Black) 128| 11.5k| , mShininess(0) 129| 11.5k| , mTracking(TVC_NONE) 130| 11.5k| , mHashDirtyQueued(false) 131| 11.5k| , mDepthCheck(true) 132| 11.5k| , mDepthWrite(true) 133| 11.5k| , mAlphaToCoverageEnabled(false) 134| 11.5k| , mTransparentSorting(true) 135| 11.5k| , mTransparentSortingForced(false) 136| 11.5k| , mLightingEnabled(true) 137| 11.5k| , mIteratePerLight(false) 138| 11.5k| , mRunOnlyForOneLightType(false) 139| 11.5k| , mPolygonModeOverrideable(true) 140| 11.5k| , mFogOverride(false) 141| 11.5k| , mQueuedForDeletion(false) 142| 11.5k| , mLightScissoring(false) 143| 11.5k| , mLightClipPlanes(false) 144| 11.5k| , mPointSpritesEnabled(false) 145| 11.5k| , mPointAttenuationEnabled(false) 146| 11.5k| , mContentTypeLookupBuilt(false) 147| 11.5k| , mAlphaRejectVal(0) 148| 11.5k| , mDepthBiasConstant(0.0f) 149| 11.5k| , mDepthBiasSlopeScale(0.0f) 150| 11.5k| , mDepthBiasPerIteration(0.0f) 151| 11.5k| , mDepthFunc(CMPF_LESS_EQUAL) 152| 11.5k| , mAlphaRejectFunc(CMPF_ALWAYS_PASS) 153| 11.5k| , mCullMode(CULL_CLOCKWISE) 154| 11.5k| , mManualCullMode(MANUAL_CULL_BACK) 155| 11.5k| , mMaxSimultaneousLights(OGRE_MAX_SIMULTANEOUS_LIGHTS) 156| 11.5k| , mStartLight(0) 157| 11.5k| , mLightsPerIteration(1) 158| 11.5k| , mIndex(index) 159| 11.5k| , mLightMask(0xFFFFFFFF) 160| 11.5k| , mFogColour(ColourValue::White) 161| 11.5k| , mFogStart(0.0) 162| 11.5k| , mFogEnd(1.0) 163| 11.5k| , mFogDensity(0.001) 164| 11.5k| , mLineWidth(1.0f) 165| 11.5k| , mPassIterationCount(1) 166| 11.5k| , mPointMinSize(0.0f) 167| 11.5k| , mPointMaxSize(0.0f) 168| 11.5k| , mPointAttenution(1.0f, 1.0f, 0.0f, 0.0f) 169| 11.5k| , mShadeOptions(SO_GOURAUD) 170| 11.5k| , mPolygonMode(PM_SOLID) 171| 11.5k| , mIlluminationStage(IS_UNKNOWN) 172| 11.5k| , mOnlyLightType(Light::LT_POINT) 173| 11.5k| , mFogMode(FOG_NONE) 174| 11.5k| { 175| | // init the hash inline 176| 11.5k| _recalculateHash(); 177| 11.5k| } _ZN4Ogre4PassC2EPNS_9TechniqueEtRKS0_: 181| 12.9k| : mParent(parent), mQueuedForDeletion(false), mIndex(index), mPassIterationCount(1) 182| 12.9k| { 183| 12.9k| *this = oth; 184| 12.9k| mParent = parent; 185| 12.9k| mIndex = index; 186| 12.9k| mQueuedForDeletion = false; 187| | 188| | // init the hash inline 189| 12.9k| _recalculateHash(); 190| 12.9k| } _ZN4Ogre4PassD2Ev: 191| 24.5k| Pass::~Pass() = default; // ensure unique_ptr destructors are in cpp _ZN4Ogre4PassaSERKS0_: 194| 12.9k| { 195| 12.9k| mName = oth.mName; 196| 12.9k| mHash = oth.mHash; 197| 12.9k| mAmbient = oth.mAmbient; 198| 12.9k| mDiffuse = oth.mDiffuse; 199| 12.9k| mSpecular = oth.mSpecular; 200| 12.9k| mEmissive = oth.mEmissive; 201| 12.9k| mShininess = oth.mShininess; 202| 12.9k| mTracking = oth.mTracking; 203| | 204| | // Copy fog parameters 205| 12.9k| mFogOverride = oth.mFogOverride; 206| 12.9k| mFogMode = oth.mFogMode; 207| 12.9k| mFogColour = oth.mFogColour; 208| 12.9k| mFogStart = oth.mFogStart; 209| 12.9k| mFogEnd = oth.mFogEnd; 210| 12.9k| mFogDensity = oth.mFogDensity; 211| | 212| | // Default blending (overwrite) 213| 12.9k| mBlendState = oth.mBlendState; 214| | 215| 12.9k| mDepthCheck = oth.mDepthCheck; 216| 12.9k| mDepthWrite = oth.mDepthWrite; 217| 12.9k| mAlphaRejectFunc = oth.mAlphaRejectFunc; 218| 12.9k| mAlphaRejectVal = oth.mAlphaRejectVal; 219| 12.9k| mAlphaToCoverageEnabled = oth.mAlphaToCoverageEnabled; 220| 12.9k| mTransparentSorting = oth.mTransparentSorting; 221| 12.9k| mTransparentSortingForced = oth.mTransparentSortingForced; 222| 12.9k| mDepthFunc = oth.mDepthFunc; 223| 12.9k| mDepthBiasConstant = oth.mDepthBiasConstant; 224| 12.9k| mDepthBiasSlopeScale = oth.mDepthBiasSlopeScale; 225| 12.9k| mDepthBiasPerIteration = oth.mDepthBiasPerIteration; 226| 12.9k| mCullMode = oth.mCullMode; 227| 12.9k| mManualCullMode = oth.mManualCullMode; 228| 12.9k| mLightingEnabled = oth.mLightingEnabled; 229| 12.9k| mMaxSimultaneousLights = oth.mMaxSimultaneousLights; 230| 12.9k| mStartLight = oth.mStartLight; 231| 12.9k| mIteratePerLight = oth.mIteratePerLight; 232| 12.9k| mLightsPerIteration = oth.mLightsPerIteration; 233| 12.9k| mRunOnlyForOneLightType = oth.mRunOnlyForOneLightType; 234| 12.9k| mOnlyLightType = oth.mOnlyLightType; 235| 12.9k| mShadeOptions = oth.mShadeOptions; 236| 12.9k| mPolygonMode = oth.mPolygonMode; 237| 12.9k| mPolygonModeOverrideable = oth.mPolygonModeOverrideable; 238| 12.9k| mPassIterationCount = oth.mPassIterationCount; 239| 12.9k| mLineWidth = oth.mLineWidth; 240| 12.9k| mPointAttenution = oth.mPointAttenution; 241| 12.9k| mPointMinSize = oth.mPointMinSize; 242| 12.9k| mPointMaxSize = oth.mPointMaxSize; 243| 12.9k| mPointSpritesEnabled = oth.mPointSpritesEnabled; 244| 12.9k| mPointAttenuationEnabled = oth.mPointAttenuationEnabled; 245| 12.9k| mShadowContentTypeLookup = oth.mShadowContentTypeLookup; 246| 12.9k| mContentTypeLookupBuilt = oth.mContentTypeLookupBuilt; 247| 12.9k| mLightScissoring = oth.mLightScissoring; 248| 12.9k| mLightClipPlanes = oth.mLightClipPlanes; 249| 12.9k| mIlluminationStage = oth.mIlluminationStage; 250| 12.9k| mLightMask = oth.mLightMask; 251| | 252| 77.7k| for(int i = 0; i < GPT_PIPELINE_COUNT; i++) ------------------ | Branch (252:24): [True: 64.8k, False: 12.9k] ------------------ 253| 64.8k| { 254| 64.8k| auto& programUsage = mProgramUsage[i]; 255| 64.8k| auto& othUsage = oth.mProgramUsage[i]; 256| 64.8k| programUsage = othUsage ? std::make_unique(*othUsage, this) : nullptr; ------------------ | Branch (256:28): [True: 0, False: 64.8k] ------------------ 257| 64.8k| } 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| 12.9k| for (auto *t : mTextureUnitStates) ------------------ | Branch (261:22): [True: 0, False: 12.9k] ------------------ 262| 0| { 263| 0| OGRE_DELETE t; 264| 0| } 265| | 266| 12.9k| mTextureUnitStates.clear(); 267| | 268| | // Copy texture units 269| 12.9k| for (auto *s : oth.mTextureUnitStates) ------------------ | Branch (269:22): [True: 0, False: 12.9k] ------------------ 270| 0| { 271| 0| TextureUnitState* t = OGRE_NEW TextureUnitState(this, *s); 272| 0| mTextureUnitStates.push_back(t); 273| 0| } 274| | 275| 12.9k| _dirtyHash(); 276| | 277| 12.9k| return *this; 278| 12.9k| } _ZN4Ogre4Pass19setPointAttenuationEbfff: 296| 73| { 297| 73| mPointAttenuationEnabled = enabled; 298| 73| mPointAttenution[1] = enabled ? constant : 1.0f; ------------------ | Branch (298:31): [True: 73, False: 0] ------------------ 299| 73| mPointAttenution[2] = enabled ? linear : 0.0f; ------------------ | Branch (299:31): [True: 73, False: 0] ------------------ 300| 73| mPointAttenution[3] = enabled ? quadratic : 0.0f; ------------------ | Branch (300:31): [True: 73, False: 0] ------------------ 301| 73| } _ZN4Ogre4Pass15setPointMinSizeEf: 304| 6| { 305| 6| mPointMinSize = min; 306| 6| } _ZN4Ogre4Pass15setPointMaxSizeEf: 314| 3| { 315| 3| mPointMaxSize = max; 316| 3| } _ZN4Ogre4Pass22createTextureUnitStateEv: 355| 12.7k| { 356| | TextureUnitState *t = OGRE_NEW TextureUnitState(this); 357| 12.7k| addTextureUnitState(t); 358| 12.7k| mContentTypeLookupBuilt = false; 359| 12.7k| return t; 360| 12.7k| } _ZN4Ogre4Pass19addTextureUnitStateEPNS_16TextureUnitStateE: 374| 12.7k| { 375| 12.7k| OGRE_LOCK_MUTEX(mTexUnitChangeMutex); 376| | 377| 12.7k| OgreAssert(state , "TextureUnitState is NULL"); ------------------ | Branch (377:9): [True: 0, False: 12.7k] ------------------ 378| | 379| | // only attach TUS to pass if TUS does not belong to another pass 380| 12.7k| OgreAssert(!state->getParent() || (state->getParent() == this), "TextureUnitState already attached to another pass"); ------------------ | Branch (380:9): [True: 0, False: 12.7k] | Branch (380:9): [True: 12.7k, False: 0] ------------------ 381| | 382| 12.7k| mTextureUnitStates.push_back(state); 383| | // Notify state 384| 12.7k| state->_notifyParent(this); 385| | // if texture unit state name is empty then give it a default name based on its index 386| 12.7k| if (state->getName().empty()) ------------------ | Branch (386:13): [True: 12.7k, False: 0] ------------------ 387| 12.7k| { 388| | // its the last entry in the container so its index is size - 1 389| 12.7k| 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| 12.7k| state->setName( StringUtil::format("%lx", static_cast(idx))); 394| 12.7k| } 395| 12.7k| _notifyNeedsRecompile(); 396| 12.7k| _dirtyHash(); 397| | 398| 12.7k| mContentTypeLookupBuilt = false; 399| 12.7k| } _ZN4Ogre4Pass26removeAllTextureUnitStatesEv: 459| 24.5k| { 460| 24.5k| OGRE_LOCK_MUTEX(mTexUnitChangeMutex); 461| 24.5k| TextureUnitStates::iterator i, iend; 462| 24.5k| iend = mTextureUnitStates.end(); 463| 37.2k| for (i = mTextureUnitStates.begin(); i != iend; ++i) ------------------ | Branch (463:46): [True: 12.7k, False: 24.5k] ------------------ 464| 12.7k| { 465| | OGRE_DELETE *i; 466| 12.7k| } 467| 24.5k| mTextureUnitStates.clear(); 468| 24.5k| _notifyNeedsRecompile(); 469| 24.5k| _dirtyHash(); 470| 24.5k| mContentTypeLookupBuilt = false; 471| 24.5k| } _ZN4Ogre4Pass16setSceneBlendingENS_14SceneBlendTypeE: 502| 2.82k| { 503| | // Convert type into blend factors 504| | 505| 2.82k| SceneBlendFactor source; 506| 2.82k| SceneBlendFactor dest; 507| 2.82k| _getBlendFlags(sbt, source, dest); 508| | 509| | // Set blend factors 510| | 511| 2.82k| setSceneBlending(source, dest); 512| 2.82k| } _ZN4Ogre4Pass16setSceneBlendingENS_16SceneBlendFactorES1_: 533| 2.82k| { 534| 2.82k| mBlendState.sourceFactor = sourceFactor; 535| 2.82k| mBlendState.sourceFactorAlpha = sourceFactor; 536| 2.82k| mBlendState.destFactor = destFactor; 537| 2.82k| mBlendState.destFactorAlpha = destFactor; 538| 2.82k| } _ZN4Ogre4Pass22setAlphaRejectSettingsENS_15CompareFunctionEhb: 578| 79| { 579| 79| mAlphaRejectFunc = func; 580| 79| mAlphaRejectVal = value; 581| 79| mAlphaToCoverageEnabled = alphaToCoverage; 582| 79| } _ZN4Ogre4Pass21setColourWriteEnabledEbbbb: 600| 4| { 601| 4| mBlendState.writeR = red; 602| 4| mBlendState.writeG = green; 603| 4| mBlendState.writeB = blue; 604| 4| mBlendState.writeA = alpha; 605| 4| } _ZN4Ogre4Pass18setIteratePerLightEbbNS_5Light10LightTypesE: 617| 200| { 618| 200| mIteratePerLight = enabled; 619| 200| mRunOnlyForOneLightType = onlyForOneLightType; 620| 200| mOnlyLightType = lightType; 621| 200| } _ZN4Ogre4Pass20setManualCullingModeENS_17ManualCullingModeE: 624| 38| { 625| 38| mManualCullMode = mode; 626| 38| } _ZN4Ogre4Pass6setFogEbNS_7FogModeERKNS_11ColourValueEfff: 634| 81| { 635| 81| mFogOverride = overrideScene; 636| 81| if (overrideScene) ------------------ | Branch (636:13): [True: 80, False: 1] ------------------ 637| 80| { 638| 80| mFogMode = mode; 639| 80| mFogColour = colour; 640| 80| mFogStart = start; 641| 80| mFogEnd = end; 642| 80| mFogDensity = density; 643| 80| } 644| 81| } _ZN4Ogre4Pass12setDepthBiasEff: 647| 26| { 648| 26| mDepthBiasConstant = constantBias; 649| 26| mDepthBiasSlopeScale = slopeScaleBias; 650| 26| } _ZN4Ogre4Pass13setGpuProgramENS_14GpuProgramTypeERKNS_9SharedPtrINS_10GpuProgramEEEb: 770| 3.00k| { 771| 3.00k| OGRE_LOCK_MUTEX(mGpuProgramChangeMutex); 772| | 773| 3.00k| std::unique_ptr& programUsage = getProgramUsage(type); 774| | 775| | // Turn off fragment program if name blank 776| 3.00k| if (!program) ------------------ | Branch (776:13): [True: 0, False: 3.00k] ------------------ 777| 0| { 778| 0| programUsage.reset(); 779| 0| } 780| 3.00k| else 781| 3.00k| { 782| 3.00k| if (!programUsage) ------------------ | Branch (782:17): [True: 1.28k, False: 1.72k] ------------------ 783| 1.28k| { 784| 1.28k| programUsage = std::make_unique(type, this); 785| 1.28k| } 786| 3.00k| programUsage->setProgram(program, resetParams); 787| 3.00k| } 788| | // Needs recompilation 789| 3.00k| _notifyNeedsRecompile(); 790| | 791| 3.00k| if( Pass::getHashFunction() == Pass::getBuiltinHashFunction( Pass::MIN_GPU_PROGRAM_CHANGE ) ) ------------------ | Branch (791:13): [True: 3.00k, False: 0] ------------------ 792| 3.00k| { 793| 3.00k| _dirtyHash(); 794| 3.00k| } 795| 3.00k| } _ZN4Ogre4Pass15getProgramUsageENS_14GpuProgramTypeE: 820| 3.00k| std::unique_ptr& Pass::getProgramUsage(GpuProgramType programType) { 821| 3.00k| return mProgramUsage[programType % GPT_PIPELINE_COUNT]; 822| 3.00k| } _ZNK4Ogre4Pass15getProgramUsageENS_14GpuProgramTypeE: 825| 196k| { 826| 196k| static std::unique_ptr nullUsage; 827| 196k| auto& ret = mProgramUsage[programType % GPT_PIPELINE_COUNT]; 828| 196k| return ret && ret->getType() == programType ? ret : nullUsage; ------------------ | Branch (828:16): [True: 0, False: 196k] | Branch (828:23): [True: 0, False: 0] ------------------ 829| 196k| } _ZNK4Ogre4Pass17getGpuProgramNameENS_14GpuProgramTypeE: 843| 196k| { 844| 196k| OGRE_LOCK_MUTEX(mGpuProgramChangeMutex); 845| | 846| 196k| const std::unique_ptr& programUsage = getProgramUsage(type); 847| 196k| if (!programUsage) ------------------ | Branch (847:13): [True: 196k, False: 0] ------------------ 848| 196k| return BLANKSTRING; 849| 0| else 850| 0| return programUsage->getProgramName(); 851| 196k| } _ZNK4Ogre4Pass8isLoadedEv: 854| 12.6k| { 855| 12.6k| return mParent->isLoaded(); 856| 12.6k| } _ZN4Ogre4Pass16_recalculateHashEv: 859| 24.5k| { 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| 24.5k| mHash = (*msHashFunc)(this); 866| | 867| | // overwrite the 4 upper bits with pass index 868| 24.5k| mHash = (uint32(mIndex) << 28) | (mHash >> 4); 869| 24.5k| } _ZN4Ogre4Pass10_dirtyHashEv: 872| 53.2k| { 873| 53.2k| if (mQueuedForDeletion) ------------------ | Branch (873:13): [True: 24.5k, False: 28.7k] ------------------ 874| 24.5k| return; 875| | 876| 28.7k| Material* mat = mParent->getParent(); 877| 28.7k| if (mat->isLoading() || mat->isLoaded()) ------------------ | Branch (877:13): [True: 0, False: 28.7k] | Branch (877:33): [True: 0, False: 28.7k] ------------------ 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| 28.7k| else 885| 28.7k| { 886| 28.7k| mHashDirtyQueued = true; 887| 28.7k| } 888| 28.7k| } _ZN4Ogre4Pass21_notifyNeedsRecompileEv: 897| 40.2k| { 898| 40.2k| if (!mQueuedForDeletion) ------------------ | Branch (898:13): [True: 15.7k, False: 24.5k] ------------------ 899| 15.7k| mParent->_notifyNeedsRecompile(); 900| 40.2k| } _ZN4Ogre4Pass25processPendingPassUpdatesEv: 934| 7.20k| { 935| 7.20k| { 936| 7.20k| OGRE_LOCK_MUTEX(msPassGraveyardMutex); 937| | // Delete items in the graveyard 938| 7.20k| for (auto& i : msPassGraveyard) ------------------ | Branch (938:26): [True: 24.5k, False: 7.20k] ------------------ 939| 24.5k| { 940| 24.5k| OGRE_DELETE i; 941| 24.5k| } 942| 7.20k| msPassGraveyard.clear(); 943| 7.20k| } 944| 7.20k| PassSet tempDirtyHashList; 945| 7.20k| { 946| 7.20k| OGRE_LOCK_MUTEX(msDirtyHashListMutex); 947| | // The dirty ones will have been removed from the groups above using the old hash now 948| 7.20k| tempDirtyHashList.swap(msDirtyHashList); 949| 7.20k| } 950| 7.20k| for (auto *p : tempDirtyHashList) ------------------ | Branch (950:22): [True: 0, False: 7.20k] ------------------ 951| 0| { 952| 0| p->_recalculateHash(); 953| 0| } 954| 7.20k| } _ZN4Ogre4Pass16queueForDeletionEv: 957| 24.5k| { 958| 24.5k| mQueuedForDeletion = true; 959| | 960| 24.5k| removeAllTextureUnitStates(); 961| 24.5k| for (auto& u : mProgramUsage) ------------------ | Branch (961:22): [True: 122k, False: 24.5k] ------------------ 962| 122k| u.reset(); 963| | 964| | // remove from dirty list, if there 965| 24.5k| { 966| 24.5k| OGRE_LOCK_MUTEX(msDirtyHashListMutex); 967| 24.5k| msDirtyHashList.erase(this); 968| 24.5k| } 969| 24.5k| { 970| 24.5k| OGRE_LOCK_MUTEX(msPassGraveyardMutex); 971| 24.5k| msPassGraveyard.insert(this); 972| 24.5k| } 973| 24.5k| } _ZNK4Ogre4Pass16getResourceGroupEv: 989| 1.36M| { 990| 1.36M| return mParent->getResourceGroup(); 991| 1.36M| } OgrePass.cpp:_ZN4OgreL14_getBlendFlagsENS_14SceneBlendTypeERNS_16SceneBlendFactorES2_: 474| 2.82k| { 475| 2.82k| switch ( type ) 476| 2.82k| { 477| 895| case SBT_TRANSPARENT_ALPHA: ------------------ | Branch (477:9): [True: 895, False: 1.92k] ------------------ 478| 895| source = SBF_SOURCE_ALPHA; 479| 895| dest = SBF_ONE_MINUS_SOURCE_ALPHA; 480| 895| return; 481| 324| case SBT_TRANSPARENT_COLOUR: ------------------ | Branch (481:9): [True: 324, False: 2.49k] ------------------ 482| 324| source = SBF_SOURCE_COLOUR; 483| 324| dest = SBF_ONE_MINUS_SOURCE_COLOUR; 484| 324| return; 485| 217| case SBT_MODULATE: ------------------ | Branch (485:9): [True: 217, False: 2.60k] ------------------ 486| 217| source = SBF_DEST_COLOUR; 487| 217| dest = SBF_ZERO; 488| 217| return; 489| 1.38k| case SBT_ADD: ------------------ | Branch (489:9): [True: 1.38k, False: 1.43k] ------------------ 490| 1.38k| source = SBF_ONE; 491| 1.38k| dest = SBF_ONE; 492| 1.38k| return; 493| 0| default: ------------------ | Branch (493:9): [True: 0, False: 2.82k] ------------------ 494| 0| case SBT_REPLACE: ------------------ | Branch (494:9): [True: 0, False: 2.82k] ------------------ 495| 0| source = SBF_ONE; 496| 0| dest = SBF_ZERO; 497| 0| return; 498| 2.82k| } 499| 2.82k| } _ZNK4Ogre27MinGpuProgramChangeHashFuncclEPKNS_4PassE: 67| 24.5k| { 68| 24.5k| OGRE_LOCK_MUTEX(p->mGpuProgramChangeMutex); 69| 24.5k| uint32 hash = 0; 70| | 71| 220k| for(int i = 0; i < GPT_COUNT; i++) ------------------ | Branch (71:28): [True: 196k, False: 24.5k] ------------------ 72| 196k| { 73| 196k| const String& name = p->getGpuProgramName(GpuProgramType(i)); 74| 196k| if(!name.empty()) { ------------------ | Branch (74:20): [True: 0, False: 196k] ------------------ 75| 0| hash = FastHash(name.c_str(), name.size(), hash); 76| 0| } 77| 196k| } 78| | 79| 24.5k| return hash; 80| 24.5k| } _ZN4Ogre25PixelCountLodStrategyBaseC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 37| 2| : LodStrategy(name) 38| 2| { } _ZN4Ogre29AbsolutePixelCountLodStrategyC2Ev: 92| 1| : PixelCountLodStrategyBase("pixel_count") 93| 1| { } _ZN4Ogre32ScreenRatioPixelCountLodStrategyC2Ev: 172| 1| : PixelCountLodStrategyBase("screen_ratio_pixel_count") 173| 1| { } _ZN4Ogre9PixelUtil8getFlagsENS_11PixelFormatE: 198| 508k| { 199| 508k| return getDescriptionFor(format).flags; 200| 508k| } _ZN4Ogre9PixelUtil12isCompressedENS_11PixelFormatE: 218| 508k| { 219| 508k| return (PixelUtil::getFlags(format) & PFF_COMPRESSED) > 0; 220| 508k| } _ZN4Ogre9PixelUtil13getFormatNameENS_11PixelFormatE: 265| 329k| { 266| 329k| return getDescriptionFor(srcformat).name; 267| 329k| } _ZN4Ogre9PixelUtil12isAccessibleENS_11PixelFormatE: 270| 514k| { 271| 514k| return (srcformat != PF_UNKNOWN) && !isCompressed(srcformat); ------------------ | Branch (271:16): [True: 508k, False: 5.38k] | Branch (271:45): [True: 329k, False: 179k] ------------------ 272| 514k| } _ZN4Ogre9PixelUtil17getFormatFromNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEbb: 287| 5.38k| { 288| 5.38k| String tmp = name; 289| 5.38k| if (!caseSensitive) ------------------ | Branch (289:13): [True: 5.38k, False: 0] ------------------ 290| 5.38k| { 291| | // We are stored upper-case format names. 292| 5.38k| StringUtil::toUpperCase(tmp); 293| 5.38k| } 294| | 295| 518k| for (int i = 0; i < PF_COUNT; ++i) ------------------ | Branch (295:25): [True: 514k, False: 4.48k] ------------------ 296| 514k| { 297| 514k| PixelFormat pf = static_cast(i); 298| 514k| if (!accessibleOnly || isAccessible(pf)) ------------------ | Branch (298:17): [True: 0, False: 514k] | Branch (298:36): [True: 329k, False: 184k] ------------------ 299| 329k| { 300| 329k| if (tmp == getFormatName(pf)) ------------------ | Branch (300:21): [True: 897, False: 328k] ------------------ 301| 897| return pf; 302| 329k| } 303| 514k| } 304| | 305| | // allow look-up by alias name 306| 4.48k| if(tmp == "PF_BYTE_RGB") ------------------ | Branch (306:12): [True: 1.45k, False: 3.03k] ------------------ 307| 1.45k| return PF_BYTE_RGB; 308| 3.03k| if(tmp == "PF_BYTE_RGBA") ------------------ | Branch (308:12): [True: 2.20k, False: 824] ------------------ 309| 2.20k| return PF_BYTE_RGBA; 310| 824| if(tmp == "PF_BYTE_BGR") ------------------ | Branch (310:12): [True: 1, False: 823] ------------------ 311| 1| return PF_BYTE_BGR; 312| 823| if(tmp == "PF_BYTE_BGRA") ------------------ | Branch (312:12): [True: 1, False: 822] ------------------ 313| 1| return PF_BYTE_BGRA; 314| | 315| 822| return PF_UNKNOWN; 316| 823| } OgrePixelFormat.cpp:_ZN4OgreL17getDescriptionForENS_11PixelFormatE: 88| 838k| { 89| 838k| const int ord = (int)fmt; 90| 838k| assert(ord>=0 && ord 2) ------------------ | Branch (310:25): [True: 0, False: 0] ------------------ 311| 0| features |= PlatformInformation::CPU_FEATURE_PRO; 312| | 313| | // Check standard feature 314| 0| _performCpuid(CPUID_FUNC_STANDARD_FEATURES, result); ------------------ | | 269| 0|#define CPUID_FUNC_STANDARD_FEATURES 0x1 ------------------ 315| | 316| 0| if (result._edx & CPUID_STD_FPU) ------------------ | | 274| 0|#define CPUID_STD_FPU (1<<0) ------------------ | Branch (316:25): [True: 0, False: 0] ------------------ 317| 0| features |= PlatformInformation::CPU_FEATURE_FPU; 318| 0| if (result._edx & CPUID_STD_TSC) ------------------ | | 275| 0|#define CPUID_STD_TSC (1<<4) ------------------ | Branch (318:25): [True: 0, False: 0] ------------------ 319| 0| features |= PlatformInformation::CPU_FEATURE_TSC; 320| 0| if (result._edx & CPUID_STD_CMOV) ------------------ | | 276| 0|#define CPUID_STD_CMOV (1<<15) ------------------ | Branch (320:25): [True: 0, False: 0] ------------------ 321| 0| features |= PlatformInformation::CPU_FEATURE_CMOV; 322| 0| if (result._edx & CPUID_STD_MMX) ------------------ | | 277| 0|#define CPUID_STD_MMX (1<<23) ------------------ | Branch (322:25): [True: 0, False: 0] ------------------ 323| 0| features |= PlatformInformation::CPU_FEATURE_MMX; 324| 0| if (result._edx & CPUID_STD_SSE) ------------------ | | 278| 0|#define CPUID_STD_SSE (1<<25) ------------------ | Branch (324:25): [True: 0, False: 0] ------------------ 325| 0| features |= PlatformInformation::CPU_FEATURE_MMXEXT | PlatformInformation::CPU_FEATURE_SSE; 326| 0| if (result._edx & CPUID_STD_SSE2) ------------------ | | 279| 0|#define CPUID_STD_SSE2 (1<<26) ------------------ | Branch (326:25): [True: 0, False: 0] ------------------ 327| 0| features |= PlatformInformation::CPU_FEATURE_SSE2; 328| 0| if (result._ecx & CPUID_STD_SSE3) ------------------ | | 282| 0|#define CPUID_STD_SSE3 (1<<0) // ECX[0] - Bit 0 of standard function 1 indicate SSE3 supported ------------------ | Branch (328:25): [True: 0, False: 0] ------------------ 329| 0| features |= PlatformInformation::CPU_FEATURE_SSE3; 330| 0| if (result._ecx & CPUID_STD_SSE41) ------------------ | | 283| 0|#define CPUID_STD_SSE41 (1<<19) // ECX[19] - Bit 0 of standard function 1 indicate SSE41 supported ------------------ | Branch (330:25): [True: 0, False: 0] ------------------ 331| 0| features |= PlatformInformation::CPU_FEATURE_SSE41; 332| 0| if (result._ecx & CPUID_STD_SSE42) ------------------ | | 284| 0|#define CPUID_STD_SSE42 (1<<20) // ECX[20] - Bit 0 of standard function 1 indicate SSE42 supported ------------------ | Branch (332:25): [True: 0, False: 0] ------------------ 333| 0| features |= PlatformInformation::CPU_FEATURE_SSE42; 334| | 335| | // Check to see if this is a Pentium 4 or later processor 336| 0| if ((result._eax & CPUID_EXT_FAMILY_ID_MASK) || ------------------ | | 287| 0|#define CPUID_EXT_FAMILY_ID_MASK 0x0F00000 // EAX[23:20] - Bit 23 thru 20 contains extended family processor id ------------------ | Branch (336:25): [True: 0, False: 0] ------------------ 337| 0| (result._eax & CPUID_FAMILY_ID_MASK) == CPUID_PENTIUM4_ID) ------------------ | | 286| 0|#define CPUID_FAMILY_ID_MASK 0x0F00 // EAX[11:8] - Bit 11 thru 8 contains family processor id ------------------ (result._eax & CPUID_FAMILY_ID_MASK) == CPUID_PENTIUM4_ID) ------------------ | | 288| 0|#define CPUID_PENTIUM4_ID 0x0F00 // Pentium 4 family processor id ------------------ | Branch (337:25): [True: 0, False: 0] ------------------ 338| 0| { 339| | // Check hyper-threading technology 340| 0| if (result._edx & CPUID_STD_HTT) ------------------ | | 280| 0|#define CPUID_STD_HTT (1<<28) // EDX[28] - Bit 28 set indicates Hyper-Threading Technology is supported in hardware. ------------------ | Branch (340:29): [True: 0, False: 0] ------------------ 341| 0| features |= PlatformInformation::CPU_FEATURE_HTT; 342| 0| } 343| | 344| | 345| 0| const uint maxExtensionFunctionSupport = _performCpuid(CPUID_FUNC_EXTENSION_QUERY, result); ------------------ | | 270| 0|#define CPUID_FUNC_EXTENSION_QUERY 0x80000000 ------------------ 346| 0| if (maxExtensionFunctionSupport >= CPUID_FUNC_ADVANCED_POWER_MANAGEMENT) ------------------ | | 272| 0|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007 ------------------ | Branch (346:25): [True: 0, False: 0] ------------------ 347| 0| { 348| 0| _performCpuid(CPUID_FUNC_ADVANCED_POWER_MANAGEMENT, result); ------------------ | | 272| 0|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007 ------------------ 349| | 350| 0| if (result._edx & CPUID_APM_INVARIANT_TSC) ------------------ | | 295| 0|#define CPUID_APM_INVARIANT_TSC (1<<8) // EDX[8] - Bit 8 of function 0x80000007 indicates support for invariant TSC. ------------------ | Branch (350:29): [True: 0, False: 0] ------------------ 351| 0| features |= PlatformInformation::CPU_FEATURE_INVARIANT_TSC; 352| 0| } 353| 0| } 354| 2| else if (memcmp(&result._ebx, "AuthenticAMD", 12) == 0) ------------------ | Branch (354:26): [True: 2, False: 0] ------------------ 355| 2| { 356| 2| features |= PlatformInformation::CPU_FEATURE_PRO; 357| | 358| | // Check standard feature 359| 2| _performCpuid(CPUID_FUNC_STANDARD_FEATURES, result); ------------------ | | 269| 2|#define CPUID_FUNC_STANDARD_FEATURES 0x1 ------------------ 360| | 361| 2| if (result._edx & CPUID_STD_FPU) ------------------ | | 274| 2|#define CPUID_STD_FPU (1<<0) ------------------ | Branch (361:25): [True: 2, False: 0] ------------------ 362| 2| features |= PlatformInformation::CPU_FEATURE_FPU; 363| 2| if (result._edx & CPUID_STD_TSC) ------------------ | | 275| 2|#define CPUID_STD_TSC (1<<4) ------------------ | Branch (363:25): [True: 2, False: 0] ------------------ 364| 2| features |= PlatformInformation::CPU_FEATURE_TSC; 365| 2| if (result._edx & CPUID_STD_CMOV) ------------------ | | 276| 2|#define CPUID_STD_CMOV (1<<15) ------------------ | Branch (365:25): [True: 2, False: 0] ------------------ 366| 2| features |= PlatformInformation::CPU_FEATURE_CMOV; 367| 2| if (result._edx & CPUID_STD_MMX) ------------------ | | 277| 2|#define CPUID_STD_MMX (1<<23) ------------------ | Branch (367:25): [True: 2, False: 0] ------------------ 368| 2| features |= PlatformInformation::CPU_FEATURE_MMX; 369| 2| if (result._edx & CPUID_STD_SSE) ------------------ | | 278| 2|#define CPUID_STD_SSE (1<<25) ------------------ | Branch (369:25): [True: 2, False: 0] ------------------ 370| 2| features |= PlatformInformation::CPU_FEATURE_SSE; 371| 2| if (result._edx & CPUID_STD_SSE2) ------------------ | | 279| 2|#define CPUID_STD_SSE2 (1<<26) ------------------ | Branch (371:25): [True: 2, False: 0] ------------------ 372| 2| features |= PlatformInformation::CPU_FEATURE_SSE2; 373| | 374| 2| if (result._ecx & CPUID_STD_SSE3) ------------------ | | 282| 2|#define CPUID_STD_SSE3 (1<<0) // ECX[0] - Bit 0 of standard function 1 indicate SSE3 supported ------------------ | Branch (374:25): [True: 2, False: 0] ------------------ 375| 2| features |= PlatformInformation::CPU_FEATURE_SSE3; 376| | 377| | // Has extended feature ? 378| 2| const uint maxExtensionFunctionSupport = _performCpuid(CPUID_FUNC_EXTENSION_QUERY, result); ------------------ | | 270| 2|#define CPUID_FUNC_EXTENSION_QUERY 0x80000000 ------------------ 379| 2| if (maxExtensionFunctionSupport >= CPUID_FUNC_EXTENDED_FEATURES) ------------------ | | 271| 2|#define CPUID_FUNC_EXTENDED_FEATURES 0x80000001 ------------------ | Branch (379:25): [True: 2, False: 0] ------------------ 380| 2| { 381| | // Check extended feature 382| 2| _performCpuid(CPUID_FUNC_EXTENDED_FEATURES, result); ------------------ | | 271| 2|#define CPUID_FUNC_EXTENDED_FEATURES 0x80000001 ------------------ 383| | 384| 2| if (result._edx & CPUID_EXT_3DNOW) ------------------ | | 290| 2|#define CPUID_EXT_3DNOW (1<<31) ------------------ | Branch (384:29): [True: 0, False: 2] ------------------ 385| 0| features |= PlatformInformation::CPU_FEATURE_3DNOW; 386| 2| if (result._edx & CPUID_EXT_AMD_3DNOWEXT) ------------------ | | 291| 2|#define CPUID_EXT_AMD_3DNOWEXT (1<<30) ------------------ | Branch (386:29): [True: 0, False: 2] ------------------ 387| 0| features |= PlatformInformation::CPU_FEATURE_3DNOWEXT; 388| 2| if (result._edx & CPUID_EXT_AMD_MMXEXT) ------------------ | | 292| 2|#define CPUID_EXT_AMD_MMXEXT (1<<22) ------------------ | Branch (388:29): [True: 2, False: 0] ------------------ 389| 2| features |= PlatformInformation::CPU_FEATURE_MMXEXT; 390| 2| } 391| | 392| | 393| 2| if (maxExtensionFunctionSupport >= CPUID_FUNC_ADVANCED_POWER_MANAGEMENT) ------------------ | | 272| 2|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007 ------------------ | Branch (393:25): [True: 2, False: 0] ------------------ 394| 2| { 395| 2| _performCpuid(CPUID_FUNC_ADVANCED_POWER_MANAGEMENT, result); ------------------ | | 272| 2|#define CPUID_FUNC_ADVANCED_POWER_MANAGEMENT 0x80000007 ------------------ 396| | 397| 2| if (result._edx & CPUID_APM_INVARIANT_TSC) ------------------ | | 295| 2|#define CPUID_APM_INVARIANT_TSC (1<<8) // EDX[8] - Bit 8 of function 0x80000007 indicates support for invariant TSC. ------------------ | Branch (397:29): [True: 2, False: 0] ------------------ 398| 2| features |= PlatformInformation::CPU_FEATURE_INVARIANT_TSC; 399| 2| } 400| 2| } 401| 2| } 402| 2| } 403| | 404| 2| return features; 405| 2| } OgrePlatformInformation.cpp:_ZN4OgreL31_checkOperatingSystemSupportSSEEv: 202| 2| { 203| |#if OGRE_COMPILER == OGRE_COMPILER_MSVC 204| | /* 205| | The FP part of SSE introduces a new architectural state and therefore 206| | requires support from the operating system. So even if CPUID indicates 207| | support for SSE FP, the application might not be able to use it. If 208| | CPUID indicates support for SSE FP, check here whether it is also 209| | supported by the OS, and turn off the SSE FP feature bit if there 210| | is no OS support for SSE FP. 211| | 212| | Operating systems that do not support SSE FP return an illegal 213| | instruction exception if execution of an SSE FP instruction is performed. 214| | Here, a sample SSE FP instruction is executed, and is checked for an 215| | exception using the (non-standard) __try/__except mechanism 216| | of Microsoft Visual C/C++. 217| | */ 218| | // Visual Studio 2005, Both AMD and Intel x64 support SSE 219| | // note that even though this is a build rather than runtime setting, all 220| | // 64-bit CPUs support this so since binary is 64-bit only we're ok 221| | #if _MSC_VER >= 1400 && defined(_M_X64) 222| | return true; 223| | #else 224| | __try 225| | { 226| | __asm orps xmm0, xmm0 227| | return true; 228| | } 229| | __except(EXCEPTION_EXECUTE_HANDLER) 230| | { 231| | return false; 232| | } 233| | #endif 234| |#elif (OGRE_COMPILER == OGRE_COMPILER_GNUC || OGRE_COMPILER == OGRE_COMPILER_CLANG) && OGRE_PLATFORM != OGRE_PLATFORM_EMSCRIPTEN 235| | #if OGRE_ARCH_TYPE == OGRE_ARCHITECTURE_64 236| 2| return true; 237| | #else 238| | // Does gcc have __try/__except similar mechanism? 239| | // Use signal, setjmp/longjmp instead. 240| | void (*oldHandler)(int); 241| | oldHandler = signal(SIGILL, _illegalHandler); 242| | 243| | if (setjmp(sIllegalJmpBuf)) 244| | { 245| | signal(SIGILL, oldHandler); 246| | return false; 247| | } 248| | else 249| | { 250| | __asm__ __volatile__ ("orps %xmm0, %xmm0"); 251| | signal(SIGILL, oldHandler); 252| | return true; 253| | } 254| | #endif 255| |#else 256| | // TODO: Supports other compiler, assumed is supported by default 257| | return true; 258| |#endif 259| 2| } OgrePlatformInformation.cpp:_ZN4OgreL15_isSupportCpuidEv: 83| 4| { 84| |#if OGRE_COMPILER == OGRE_COMPILER_MSVC 85| | // Visual Studio 2005 & 64-bit compilers always supports __cpuid intrinsic 86| | // note that even though this is a build rather than runtime setting, all 87| | // 64-bit CPUs support this so since binary is 64-bit only we're ok 88| | #if _MSC_VER >= 1400 && defined(_M_X64) 89| | return true; 90| | #else 91| | // If we can modify flag register bit 21, the cpu is supports CPUID instruction 92| | __asm 93| | { 94| | // Read EFLAG 95| | pushfd 96| | pop eax 97| | mov ecx, eax 98| | 99| | // Modify bit 21 100| | xor eax, 0x200000 101| | push eax 102| | popfd 103| | 104| | // Read back EFLAG 105| | pushfd 106| | pop eax 107| | 108| | // Restore EFLAG 109| | push ecx 110| | popfd 111| | 112| | // Check bit 21 modifiable 113| | xor eax, ecx 114| | neg eax 115| | sbb eax, eax 116| | 117| | // Return values in eax, no return statement requirement here for VC. 118| | } 119| | #endif 120| |#elif (OGRE_COMPILER == OGRE_COMPILER_GNUC || OGRE_COMPILER == OGRE_COMPILER_CLANG) && OGRE_PLATFORM != OGRE_PLATFORM_EMSCRIPTEN 121| | #if OGRE_ARCH_TYPE == OGRE_ARCHITECTURE_64 122| 4| return true; 123| | #else 124| | unsigned oldFlags, newFlags; 125| | __asm__ 126| | ( 127| | "pushfl \n\t" 128| | "pop %0 \n\t" 129| | "mov %0, %1 \n\t" 130| | "xor %2, %0 \n\t" 131| | "push %0 \n\t" 132| | "popfl \n\t" 133| | "pushfl \n\t" 134| | "pop %0 \n\t" 135| | "push %1 \n\t" 136| | "popfl \n\t" 137| | : "=r" (oldFlags), "=r" (newFlags) 138| | : "n" (0x200000) 139| | ); 140| | return oldFlags != newFlags; 141| | #endif // 64 142| |#else 143| | // TODO: Supports other compiler 144| | return false; 145| |#endif 146| 4| } _ZN4Ogre24RenderSystemCapabilities16vendorFromStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 266| 33| { 267| 33| initVendorStrings(); 268| 33| GPUVendor ret = GPU_UNKNOWN; 269| 33| String cmpString = vendorString; 270| 33| StringUtil::toLowerCase(cmpString); 271| 462| for (int i = 0; i < GPU_VENDOR_COUNT; ++i) ------------------ | Branch (271:25): [True: 429, False: 33] ------------------ 272| 429| { 273| | // case insensitive (lower case) 274| 429| if (msGPUVendorStrings[i] == cmpString) ------------------ | Branch (274:17): [True: 0, False: 429] ------------------ 275| 0| { 276| 0| ret = static_cast(i); 277| 0| break; 278| 0| } 279| 429| } 280| | 281| 33| return ret; 282| | 283| 33| } _ZN4Ogre24RenderSystemCapabilities17initVendorStringsEv: 292| 33| { 293| 33| if (msGPUVendorStrings[0].empty()) ------------------ | Branch (293:13): [True: 1, False: 32] ------------------ 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| 33| } _ZN4Ogre31RenderSystemCapabilitiesManagerC2Ev: 49| 1| RenderSystemCapabilitiesManager::RenderSystemCapabilitiesManager() : mSerializer(0), mScriptPattern("*.rendercaps") 50| 1| { 51| | mSerializer = OGRE_NEW RenderSystemCapabilitiesSerializer(); 52| 1| } _ZN4Ogre34RenderSystemCapabilitiesSerializerC2Ev: 37| 1| RenderSystemCapabilitiesSerializer::RenderSystemCapabilitiesSerializer() : mCurrentLineNumber(0), mCurrentLine(0), 38| 1| mCurrentCapabilities(0) 39| 1| { 40| 1| initialiaseDispatchTables(); 41| 1| } _ZN4Ogre34RenderSystemCapabilitiesSerializer25initialiaseDispatchTablesEv: 264| 1| { 265| | // set up driver version parsing 266| 1| addKeywordType("driver_version", SET_STRING_METHOD); 267| | // set up the setters for driver versions 268| 1| addSetStringMethod("driver_version", &RenderSystemCapabilities::parseDriverVersionFromString); 269| | 270| | // set up device name parsing 271| 1| addKeywordType("device_name", SET_STRING_METHOD); 272| | // set up the setters for device names 273| 1| addSetStringMethod("device_name", &RenderSystemCapabilities::setDeviceName); 274| | 275| | // set up render system name parsing 276| 1| addKeywordType("render_system_name", SET_STRING_METHOD); 277| | // set up the setters 278| 1| addSetStringMethod("render_system_name", &RenderSystemCapabilities::setRenderSystemName); 279| | 280| | // set up vendor parsing 281| 1| addKeywordType("vendor", SET_STRING_METHOD); 282| | // set up the setters for driver versions 283| 1| addSetStringMethod("vendor", &RenderSystemCapabilities::parseVendorFromString); 284| | 285| | // initialize int types 286| 1| addKeywordType("num_world_matrices", SET_INT_METHOD); 287| 1| addKeywordType("num_texture_units", SET_INT_METHOD); 288| 1| addKeywordType("stencil_buffer_bit_depth", SET_INT_METHOD); 289| 1| addKeywordType("num_vertex_blend_matrices", SET_INT_METHOD); 290| 1| addKeywordType("num_multi_render_targets", SET_INT_METHOD); 291| 1| addKeywordType("vertex_program_constant_float_count", SET_INT_METHOD); 292| 1| addKeywordType("vertex_program_constant_int_count", SET_INT_METHOD); 293| 1| addKeywordType("vertex_program_constant_bool_count", SET_INT_METHOD); 294| 1| addKeywordType("fragment_program_constant_float_count", SET_INT_METHOD); 295| 1| addKeywordType("fragment_program_constant_int_count", SET_INT_METHOD); 296| 1| addKeywordType("fragment_program_constant_bool_count", SET_INT_METHOD); 297| 1| addKeywordType("geometry_program_constant_float_count", SET_INT_METHOD); 298| 1| addKeywordType("geometry_program_constant_int_count", SET_INT_METHOD); 299| 1| addKeywordType("geometry_program_constant_bool_count", SET_INT_METHOD); 300| 1| addKeywordType("tessellation_hull_program_constant_float_count", SET_INT_METHOD); 301| 1| addKeywordType("tessellation_hull_program_constant_int_count", SET_INT_METHOD); 302| 1| addKeywordType("tessellation_hull_program_constant_bool_count", SET_INT_METHOD); 303| 1| addKeywordType("tessellation_domain_program_constant_float_count", SET_INT_METHOD); 304| 1| addKeywordType("tessellation_domain_program_constant_int_count", SET_INT_METHOD); 305| 1| addKeywordType("tessellation_domain_program_constant_bool_count", SET_INT_METHOD); 306| 1| addKeywordType("compute_program_constant_float_count", SET_INT_METHOD); 307| 1| addKeywordType("compute_program_constant_int_count", SET_INT_METHOD); 308| 1| addKeywordType("compute_program_constant_bool_count", SET_INT_METHOD); 309| 1| addKeywordType("num_vertex_texture_units", SET_INT_METHOD); 310| | 311| | // initialize int setters 312| 1| addSetIntMethod("num_texture_units", &RenderSystemCapabilities::setNumTextureUnits); 313| 1| addSetIntMethod("stencil_buffer_bit_depth", &RenderSystemCapabilities::setStencilBufferBitDepth); 314| 1| addSetIntMethod("num_multi_render_targets", &RenderSystemCapabilities::setNumMultiRenderTargets); 315| 1| addSetIntMethod("vertex_program_constant_float_count", &RenderSystemCapabilities::setVertexProgramConstantFloatCount); 316| 1| addSetIntMethod("fragment_program_constant_float_count", &RenderSystemCapabilities::setFragmentProgramConstantFloatCount); 317| 1| addSetIntMethod("geometry_program_constant_float_count", &RenderSystemCapabilities::setGeometryProgramConstantFloatCount); 318| 1| addSetIntMethod("tessellation_hull_program_constant_float_count", &RenderSystemCapabilities::setTessellationHullProgramConstantFloatCount); 319| 1| addSetIntMethod("tessellation_domain_program_constant_float_count", &RenderSystemCapabilities::setTessellationDomainProgramConstantFloatCount); 320| 1| addSetIntMethod("compute_program_constant_float_count", &RenderSystemCapabilities::setComputeProgramConstantFloatCount); 321| 1| addSetIntMethod("num_vertex_texture_units", &RenderSystemCapabilities::setNumVertexTextureUnits); 322| | 323| | // initialize bool types 324| 1| addKeywordType("non_pow2_textures_limited", SET_BOOL_METHOD); 325| | 326| | // initialize bool setters 327| 1| addSetBoolMethod("non_pow2_textures_limited", &RenderSystemCapabilities::setNonPOW2TexturesLimited); 328| | 329| | // initialize Real types 330| 1| addKeywordType("max_point_size", SET_REAL_METHOD); 331| | 332| | // initialize Real setters 333| 1| addSetRealMethod("max_point_size", &RenderSystemCapabilities::setMaxPointSize); 334| | 335| | // there is no dispatch table for shader profiles, just the type 336| 1| addKeywordType("shader_profile", ADD_SHADER_PROFILE_STRING); 337| | 338| 1| addCapabilitiesMapping("fixed_function", RSC_FIXED_FUNCTION); 339| 1| addCapabilitiesMapping("anisotropy", RSC_ANISOTROPY); 340| 1| addCapabilitiesMapping("hwstencil", RSC_HWSTENCIL); 341| 1| addCapabilitiesMapping("32bit_index", RSC_32BIT_INDEX); 342| 1| addCapabilitiesMapping("vertex_program", RSC_VERTEX_PROGRAM); 343| 1| addCapabilitiesMapping("geometry_program", RSC_GEOMETRY_PROGRAM); 344| 1| addCapabilitiesMapping("tessellation_hull_program", RSC_TESSELLATION_HULL_PROGRAM); 345| 1| addCapabilitiesMapping("tessellation_domain_program", RSC_TESSELLATION_DOMAIN_PROGRAM); 346| 1| addCapabilitiesMapping("compute_program", RSC_COMPUTE_PROGRAM); 347| 1| addCapabilitiesMapping("two_sided_stencil", RSC_TWO_SIDED_STENCIL); 348| 1| addCapabilitiesMapping("stencil_wrap", RSC_STENCIL_WRAP); 349| 1| addCapabilitiesMapping("hwocclusion", RSC_HWOCCLUSION); 350| 1| addCapabilitiesMapping("user_clip_planes", RSC_USER_CLIP_PLANES); 351| 1| addCapabilitiesMapping("hwrender_to_texture", RSC_HWRENDER_TO_TEXTURE); 352| 1| addCapabilitiesMapping("texture_float", RSC_TEXTURE_FLOAT); 353| 1| addCapabilitiesMapping("non_power_of_2_textures", RSC_NON_POWER_OF_2_TEXTURES); 354| 1| addCapabilitiesMapping("texture_3d", RSC_TEXTURE_3D); 355| 1| addCapabilitiesMapping("texture_2d_array", RSC_TEXTURE_3D); 356| 1| addCapabilitiesMapping("texture_1d", RSC_TEXTURE_1D); 357| 1| addCapabilitiesMapping("point_sprites", RSC_POINT_SPRITES); 358| 1| addCapabilitiesMapping("wide_lines", RSC_WIDE_LINES); 359| 1| addCapabilitiesMapping("vertex_texture_fetch", RSC_VERTEX_TEXTURE_FETCH); 360| 1| addCapabilitiesMapping("mipmap_lod_bias", RSC_MIPMAP_LOD_BIAS); 361| 1| addCapabilitiesMapping("atomic_counters", RSC_READ_WRITE_BUFFERS); 362| 1| addCapabilitiesMapping("texture_compression", RSC_TEXTURE_COMPRESSION); 363| 1| addCapabilitiesMapping("texture_compression_dxt", RSC_TEXTURE_COMPRESSION_DXT); 364| 1| addCapabilitiesMapping("texture_compression_vtc", RSC_TEXTURE_COMPRESSION_VTC); 365| 1| addCapabilitiesMapping("texture_compression_pvrtc", RSC_TEXTURE_COMPRESSION_PVRTC); 366| 1| addCapabilitiesMapping("texture_compression_atc", RSC_TEXTURE_COMPRESSION_ATC); 367| 1| addCapabilitiesMapping("texture_compression_etc1", RSC_TEXTURE_COMPRESSION_ETC1); 368| 1| addCapabilitiesMapping("texture_compression_etc2", RSC_TEXTURE_COMPRESSION_ETC2); 369| 1| addCapabilitiesMapping("texture_compression_bc4_bc5", RSC_TEXTURE_COMPRESSION_BC4_BC5); 370| 1| addCapabilitiesMapping("texture_compression_bc6h_bc7", RSC_TEXTURE_COMPRESSION_BC6H_BC7); 371| 1| addCapabilitiesMapping("texture_compression_astc", RSC_TEXTURE_COMPRESSION_ASTC); 372| 1| addCapabilitiesMapping("hwrender_to_vertex_buffer", RSC_HWRENDER_TO_VERTEX_BUFFER); 373| | 374| 1| addCapabilitiesMapping("pbuffer", RSC_PBUFFER); 375| 1| addCapabilitiesMapping("perstageconstant", RSC_PERSTAGECONSTANT); 376| 1| addCapabilitiesMapping("vao", RSC_VAO); 377| 1| addCapabilitiesMapping("separate_shader_objects", RSC_SEPARATE_SHADER_OBJECTS); 378| 1| addCapabilitiesMapping("glsl_sso_redeclare", RSC_GLSL_SSO_REDECLARE); 379| 1| addCapabilitiesMapping("debug", RSC_DEBUG); 380| 1| addCapabilitiesMapping("mapbuffer", RSC_MAPBUFFER); 381| 1| addCapabilitiesMapping("automipmap_compressed", RSC_AUTOMIPMAP_COMPRESSED); 382| 1| } _ZN4Ogre8ResourceC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE: 36| 714k| : mCreator(creator), mName(name), mGroup(group), mHandle(handle), 37| 714k| mLoadingState(LOADSTATE_UNLOADED), mIsBackgroundLoaded(false), 38| 714k| mIsManual(isManual), mSize(0), mLoader(loader), mStateCount(0) 39| 714k| { 40| 714k| } _ZN4Ogre8ResourceD2Ev: 43| 714k| { 44| 714k| } _ZN4Ogre8ResourceaSERKS0_: 46| 12.9k| { 47| 12.9k| mName = rhs.mName; 48| 12.9k| mGroup = rhs.mGroup; 49| 12.9k| mCreator = rhs.mCreator; 50| 12.9k| mIsManual = rhs.mIsManual; 51| 12.9k| mLoader = rhs.mLoader; 52| 12.9k| mHandle = rhs.mHandle; 53| 12.9k| mSize = rhs.mSize; 54| | 55| 12.9k| mLoadingState.store(rhs.mLoadingState.load()); 56| 12.9k| mIsBackgroundLoaded = rhs.mIsBackgroundLoaded; 57| | 58| 12.9k| return *this; 59| 12.9k| } _ZN4Ogre8Resource6unloadEv: 333| 727k| { 334| | // Early-out without lock (mitigate perf cost of ensuring unloaded) 335| 727k| LoadingState old = mLoadingState.load(); 336| 727k| if (old!=LOADSTATE_LOADED && old!=LOADSTATE_PREPARED) return; ------------------ | Branch (336:13): [True: 727k, False: 0] | Branch (336:38): [True: 727k, 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| 2.68k| { 387| 2.68k| OGRE_LOCK_MUTEX(mListenerListMutex); 388| 2.68k| mListenerList.insert(lis); 389| 2.68k| } _ZN4Ogre8Resource14removeListenerEPNS0_8ListenerE: 392| 2.68k| { 393| | // O(n) but not called very often 394| 2.68k| OGRE_LOCK_MUTEX(mListenerListMutex); 395| 2.68k| mListenerList.erase(lis); 396| 2.68k| } _ZN4Ogre23ResourceBackgroundQueueC2Ev: 47| 1| ResourceBackgroundQueue::ResourceBackgroundQueue() {} _ZN4Ogre20ResourceGroupManager12getSingletonEv: 40| 4.96M| { 41| | assert( msSingleton ); return ( *msSingleton ); 42| 4.96M| } _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| 7.21k| { 84| 7.21k| LogManager::getSingleton().logMessage("Creating resource group " + name); 85| 7.21k| if (getResourceGroup(name)) ------------------ | Branch (85:13): [True: 0, False: 7.21k] ------------------ 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| 7.21k| ResourceGroup* grp = OGRE_NEW_T(ResourceGroup, MEMCATEGORY_RESOURCE)(); 92| 7.21k| grp->groupStatus = ResourceGroup::UNINITIALSED; 93| 7.21k| grp->name = name; 94| 7.21k| grp->inGlobalPool = inGlobalPool; 95| 7.21k| grp->customStageCount = 0; 96| | 97| 7.21k| OGRE_LOCK_AUTO_MUTEX; 98| 7.21k| mResourceGroupMap.emplace(name, grp); 99| 7.21k| } _ZN4Ogre20ResourceGroupManager19unloadResourceGroupERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb: 281| 7.20k| { 282| 7.20k| LogManager::getSingleton().logMessage("Unloading resource group " + name); 283| 7.20k| ResourceGroup* grp = getResourceGroup(name, true); 284| 7.20k| OGRE_LOCK_AUTO_MUTEX; 285| | // Set current group 286| 7.20k| mCurrentGroup = grp; 287| 7.20k| OGRE_LOCK_MUTEX(grp->OGRE_AUTO_MUTEX_NAME); // lock group mutex 288| | 289| | // unload in reverse order 290| 7.20k| for (auto& oi : grp->loadResourceOrderMap) ------------------ | Branch (290:23): [True: 6.50k, False: 7.20k] ------------------ 291| 6.50k| { 292| 6.50k| for (auto& l : oi.second) ------------------ | Branch (292:26): [True: 713k, False: 6.50k] ------------------ 293| 713k| { 294| 713k| Resource* resource = l.get(); 295| 713k| if (!reloadableOnly || resource->isReloadable()) ------------------ | Branch (295:21): [True: 713k, False: 0] | Branch (295:40): [True: 0, False: 0] ------------------ 296| 713k| { 297| 713k| resource->unload(); 298| 713k| } 299| 713k| } 300| 6.50k| } 301| | 302| 7.20k| grp->groupStatus = ResourceGroup::INITIALISED; 303| | 304| | // reset current group 305| 7.20k| mCurrentGroup = 0; 306| 7.20k| LogManager::getSingleton().logMessage("Finished unloading resource group " + name); 307| 7.20k| } _ZN4Ogre20ResourceGroupManager20destroyResourceGroupERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 362| 7.20k| { 363| 7.20k| LogManager::getSingleton().logMessage("Destroying resource group " + name); 364| 7.20k| ResourceGroup* grp = getResourceGroup(name, true); 365| 7.20k| OGRE_LOCK_AUTO_MUTEX; 366| | // set current group 367| 7.20k| mCurrentGroup = grp; 368| 7.20k| unloadResourceGroup(name, false); // will throw an exception if name not valid 369| 7.20k| dropGroupContents(grp); 370| 7.20k| deleteGroup(grp); 371| 7.20k| mResourceGroupMap.erase(mResourceGroupMap.find(name)); 372| | // reset current group 373| 7.20k| mCurrentGroup = 0; 374| 7.20k| } _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: 869| 713k| { 870| 713k| if (mCurrentGroup && res->getGroup() == mCurrentGroup->name) ------------------ | Branch (870:13): [True: 0, False: 713k] | Branch (870:30): [True: 0, False: 0] ------------------ 871| 0| { 872| | // Use current group (batch loading) 873| 0| addCreatedResource(res, *mCurrentGroup); 874| 0| } 875| 713k| else 876| 713k| { 877| | // Find group 878| 713k| ResourceGroup* grp = getResourceGroup(res->getGroup()); 879| 713k| if (grp) ------------------ | Branch (879:17): [True: 713k, False: 0] ------------------ 880| 713k| { 881| 713k| addCreatedResource(res, *grp); 882| 713k| } 883| 713k| } 884| | 885| 713k| fireResourceCreated(res); 886| 713k| } _ZNK4Ogre20ResourceGroupManager22_notifyResourceRemovedERKNS_9SharedPtrINS_8ResourceEEE: 889| 713k| { 890| 713k| fireResourceRemove(res); 891| | 892| 713k| if (mCurrentGroup && res->getGroup() == mCurrentGroup->name) ------------------ | Branch (892:13): [True: 713k, False: 0] | Branch (892:30): [True: 713k, False: 0] ------------------ 893| 713k| { 894| | // Do nothing - we're batch unloading so list will be cleared 895| 713k| } 896| 0| else 897| 0| { 898| | // Find group 899| 0| ResourceGroup* grp = getResourceGroup(res->getGroup()); 900| 0| if (grp) ------------------ | Branch (900:17): [True: 0, False: 0] ------------------ 901| 0| { 902| 0| OGRE_LOCK_MUTEX(grp->OGRE_AUTO_MUTEX_NAME); // lock group mutex 903| 0| ResourceGroup::LoadResourceOrderMap::iterator i = 904| 0| grp->loadResourceOrderMap.find( 905| 0| res->getCreator()->getLoadingOrder()); 906| 0| if (i != grp->loadResourceOrderMap.end()) ------------------ | Branch (906:21): [True: 0, False: 0] ------------------ 907| 0| { 908| | // Iterate over the resource list and remove 909| 0| LoadUnloadResourceList& resList = i->second; 910| 0| for (LoadUnloadResourceList::iterator l = resList.begin(); 911| 0| l != resList.end(); ++ l) ------------------ | Branch (911:25): [True: 0, False: 0] ------------------ 912| 0| { 913| 0| if ((*l).get() == res.get()) ------------------ | Branch (913:29): [True: 0, False: 0] ------------------ 914| 0| { 915| | // this is the one 916| 0| resList.erase(l); 917| 0| break; 918| 0| } 919| 0| } 920| 0| } 921| 0| } 922| 0| } 923| 713k| } _ZNK4Ogre20ResourceGroupManager18addCreatedResourceERNS_9SharedPtrINS_8ResourceEEERNS0_13ResourceGroupE: 996| 713k| { 997| 713k| OGRE_LOCK_MUTEX(grp.OGRE_AUTO_MUTEX_NAME); 998| 713k| Real order = res->getCreator()->getLoadingOrder(); 999| | 1000| 713k| ResourceGroup::LoadResourceOrderMap::iterator i = grp.loadResourceOrderMap.find(order); 1001| 713k| LoadUnloadResourceList& loadList = 1002| 713k| i == grp.loadResourceOrderMap.end() ? grp.loadResourceOrderMap[order] : i->second; ------------------ | Branch (1002:13): [True: 6.50k, False: 706k] ------------------ 1003| | 1004| 713k| loadList.push_back(res); 1005| 713k| } _ZNK4Ogre20ResourceGroupManager16getResourceGroupERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEb: 1009| 3.55M| { 1010| 3.55M| OGRE_LOCK_AUTO_MUTEX; 1011| 3.55M| ResourceGroupMap::const_iterator i = mResourceGroupMap.find(name); 1012| | 1013| 3.55M| if (i == mResourceGroupMap.end()) ------------------ | Branch (1013:13): [True: 7.21k, False: 3.54M] ------------------ 1014| 7.21k| { 1015| 7.21k| if (throwOnFailure) ------------------ | Branch (1015:17): [True: 0, False: 7.21k] ------------------ 1016| 7.21k| OGRE_EXCEPT(Exception::ERR_ITEM_NOT_FOUND, "Cannot locate a resource group called '" + name + "'"); 1017| | 1018| 7.21k| return nullptr; 1019| 7.21k| } 1020| | 1021| 3.54M| return i->second; 1022| 3.55M| } _ZN4Ogre20ResourceGroupManager17dropGroupContentsEPNS0_13ResourceGroupE: 1040| 7.20k| { 1041| 7.20k| OGRE_LOCK_MUTEX(grp->OGRE_AUTO_MUTEX_NAME); 1042| | 1043| 7.20k| bool groupSet = false; 1044| 7.20k| if (!mCurrentGroup) ------------------ | Branch (1044:13): [True: 7.20k, False: 0] ------------------ 1045| 7.20k| { 1046| | // Set current group to indicate ignoring of notifications 1047| 7.20k| mCurrentGroup = grp; 1048| 7.20k| groupSet = true; 1049| 7.20k| } 1050| | // delete all the load list entries 1051| 7.20k| for (auto& j : grp->loadResourceOrderMap) ------------------ | Branch (1051:22): [True: 6.50k, False: 7.20k] ------------------ 1052| 6.50k| { 1053| | // Iterate over resources 1054| 6.50k| for (auto& k : j.second) ------------------ | Branch (1054:26): [True: 713k, False: 6.50k] ------------------ 1055| 713k| { 1056| 713k| k->getCreator()->remove(k); 1057| 713k| } 1058| 6.50k| } 1059| 7.20k| grp->loadResourceOrderMap.clear(); 1060| | 1061| 7.20k| if (groupSet) ------------------ | Branch (1061:13): [True: 7.20k, False: 0] ------------------ 1062| 7.20k| { 1063| 7.20k| mCurrentGroup = 0; 1064| 7.20k| } 1065| 7.20k| } _ZN4Ogre20ResourceGroupManager11deleteGroupEPNS0_13ResourceGroupE: 1068| 7.20k| { 1069| 7.20k| { 1070| 7.20k| OGRE_LOCK_MUTEX(grp->OGRE_AUTO_MUTEX_NAME); 1071| | // delete all the load list entries 1072| 7.20k| grp->loadResourceOrderMap.clear(); 1073| 7.20k| } 1074| | 1075| | // delete ResourceGroup 1076| | OGRE_DELETE_T(grp, ResourceGroup, MEMCATEGORY_RESOURCE); 1077| 7.20k| } _ZNK4Ogre20ResourceGroupManager19fireResourceCreatedERKNS_9SharedPtrINS_8ResourceEEE: 1209| 713k| { 1210| 713k| OGRE_LOCK_AUTO_MUTEX; 1211| 713k| for (auto l : mResourceGroupListenerList) ------------------ | Branch (1211:21): [True: 0, False: 713k] ------------------ 1212| 0| { 1213| 0| l->resourceCreated(resource); 1214| 0| } 1215| 713k| } _ZNK4Ogre20ResourceGroupManager18fireResourceRemoveERKNS_9SharedPtrINS_8ResourceEEE: 1218| 713k| { 1219| 713k| OGRE_LOCK_AUTO_MUTEX; 1220| 713k| for (auto l : mResourceGroupListenerList) ------------------ | Branch (1220:21): [True: 0, False: 713k] ------------------ 1221| 0| { 1222| 0| l->resourceRemove(resource); 1223| 0| } 1224| 713k| } _ZNK4Ogre20ResourceGroupManager27isResourceGroupInGlobalPoolERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 1468| 2.81M| { 1469| 2.81M| return getResourceGroup(name, true)->inGlobalPool; 1470| 2.81M| } _ZNK4Ogre20ResourceGroupManager18getLoadingListenerEv: 1501| 714k| { 1502| 714k| return mLoadingListener; 1503| 714k| } _ZN4Ogre15ResourceManagerC2Ev: 35| 6| : mNextHandle(1), mMemoryUsage(0), mVerbose(true), mLoadOrder(0) 36| 6| { 37| | // Init memory limit & usage 38| 6| mMemoryBudget = std::numeric_limits::max(); 39| 6| } _ZN4Ogre15ResourceManager14createResourceERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE: 53| 710k| { 54| 710k| OgreAssert(!name.empty(), "resource name must not be empty"); ------------------ | Branch (54:9): [True: 2, False: 710k] ------------------ 55| | 56| | // Call creation implementation 57| 710k| ResourcePtr ret = ResourcePtr( 58| 710k| createImpl(name, getNextHandle(), group, isManual, loader, params)); 59| 710k| if (params) ------------------ | Branch (59:13): [True: 0, False: 710k] ------------------ 60| 0| ret->setParameterList(*params); 61| | 62| 710k| addImpl(ret); 63| | // Tell resource group manager 64| 710k| if(ret) ------------------ | Branch (64:12): [True: 709k, False: 431] ------------------ 65| 709k| ResourceGroupManager::getSingleton()._notifyResourceCreated(ret); 66| 710k| return ret; 67| | 68| 710k| } _ZN4Ogre15ResourceManager16createOrRetrieveERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_bPNS_20ManualResourceLoaderEPKNS1_3mapIS7_S7_NS1_4lessIS7_EENS5_INS1_4pairIS8_S7_EEEEEE: 75| 1.35M| { 76| | // Lock for the whole get / insert 77| 1.35M| OGRE_LOCK_AUTO_MUTEX; 78| | 79| 1.35M| ResourcePtr res = getResourceByName(name, group); 80| 1.35M| bool created = false; 81| 1.35M| if (!res) ------------------ | Branch (81:13): [True: 694k, False: 665k] ------------------ 82| 694k| { 83| 694k| created = true; 84| 694k| res = createResource(name, group, isManual, loader, params); 85| 694k| } 86| | 87| 1.35M| return ResourceCreateOrRetrieveResult(res, created); 88| 1.35M| } _ZN4Ogre15ResourceManager7addImplERNS_9SharedPtrINS_8ResourceEEE: 112| 714k| { 113| 714k| OGRE_LOCK_AUTO_MUTEX; 114| | 115| 714k| std::pair result; 116| 714k| if(ResourceGroupManager::getSingleton().isResourceGroupInGlobalPool(res->getGroup())) ------------------ | Branch (116:12): [True: 3, False: 714k] ------------------ 117| 3| { 118| 3| result = mResources.emplace(res->getName(), res); 119| 3| } 120| 714k| else 121| 714k| { 122| | // we will create the group if it doesn't exists in our list 123| 714k| auto resgroup = mResourcesWithGroup.emplace(res->getGroup(), ResourceMap()).first; 124| 714k| result = resgroup->second.emplace(res->getName(), res); 125| 714k| } 126| | 127| | // Attempt to resolve the collision 128| 714k| ResourceLoadingListener* listener = ResourceGroupManager::getSingleton().getLoadingListener(); 129| 714k| if (!result.second && listener) ------------------ | Branch (129:13): [True: 545, False: 713k] | Branch (129:31): [True: 0, False: 545] ------------------ 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| 714k| if (!result.second) ------------------ | Branch (150:13): [True: 545, False: 713k] ------------------ 151| 545| { 152| 545| OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, getResourceType()+" with the name " + res->getName() + 153| 545| " already exists.", "ResourceManager::add"); 154| 545| } 155| | 156| | // Insert the handle 157| 713k| std::pair resultHandle = mResourcesByHandle.emplace(res->getHandle(), res); 158| 713k| if (!resultHandle.second) ------------------ | Branch (158:13): [True: 0, False: 713k] ------------------ 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| 713k| } _ZN4Ogre15ResourceManager10removeImplERKNS_9SharedPtrINS_8ResourceEEE: 167| 713k| { 168| 713k| OgreAssert(res, "attempting to remove nullptr"); ------------------ | Branch (168:9): [True: 0, False: 713k] ------------------ 169| | 170| 713k|#if OGRE_RESOURCEMANAGER_STRICT 171| 713k| if (res->getCreator() != this) ------------------ | Branch (171:13): [True: 0, False: 713k] ------------------ 172| 713k| OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Resource '" + res->getName() + "' was not created by the '" + 173| 713k| getResourceType() + "' ResourceManager"); 174| 713k|#endif 175| | 176| 713k| OGRE_LOCK_AUTO_MUTEX; 177| | 178| 713k| if(ResourceGroupManager::getSingleton().isResourceGroupInGlobalPool(res->getGroup())) ------------------ | Branch (178:12): [True: 0, False: 713k] ------------------ 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| 713k| else 187| 713k| { 188| 713k| ResourceWithGroupMap::iterator groupIt = mResourcesWithGroup.find(res->getGroup()); 189| 713k| if (groupIt != mResourcesWithGroup.end()) ------------------ | Branch (189:17): [True: 713k, False: 0] ------------------ 190| 713k| { 191| 713k| ResourceMap::iterator nameIt = groupIt->second.find(res->getName()); 192| 713k| if (nameIt != groupIt->second.end()) ------------------ | Branch (192:21): [True: 713k, False: 0] ------------------ 193| 713k| { 194| 713k| groupIt->second.erase(nameIt); 195| 713k| } 196| | 197| 713k| if (groupIt->second.empty()) ------------------ | Branch (197:21): [True: 6.50k, False: 706k] ------------------ 198| 6.50k| { 199| 6.50k| mResourcesWithGroup.erase(groupIt); 200| 6.50k| } 201| 713k| } 202| 713k| } 203| | 204| 713k| ResourceHandleMap::iterator handleIt = mResourcesByHandle.find(res->getHandle()); 205| 713k| if (handleIt != mResourcesByHandle.end()) ------------------ | Branch (205:13): [True: 713k, False: 0] ------------------ 206| 713k| { 207| 713k| mResourcesByHandle.erase(handleIt); 208| 713k| } 209| | // Tell resource group manager 210| 713k| ResourceGroupManager::getSingleton()._notifyResourceRemoved(res); 211| 713k| } _ZN4Ogre15ResourceManager6removeERKNS_9SharedPtrINS_8ResourceEEE: 298| 713k| { 299| 713k| removeImpl(res); 300| 713k| } _ZNK4Ogre15ResourceManager17getResourceByNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 368| 1.39M| { 369| 1.39M| OGRE_LOCK_AUTO_MUTEX; 370| | 371| | // resource should be in global pool 372| 1.39M| bool isGlobal = ResourceGroupManager::getSingleton().isResourceGroupInGlobalPool(groupName); 373| | 374| 1.39M| if(isGlobal) ------------------ | Branch (374:12): [True: 6.58k, False: 1.38M] ------------------ 375| 6.58k| { 376| 6.58k| auto it = mResources.find(name); 377| 6.58k| if( it != mResources.end()) ------------------ | Branch (377:17): [True: 10, False: 6.57k] ------------------ 378| 10| { 379| 10| return it->second; 380| 10| } 381| 6.58k| } 382| | 383| | // look in all grouped pools 384| 1.39M| if (groupName == ResourceGroupManager::AUTODETECT_RESOURCE_GROUP_NAME) ------------------ | Branch (384:13): [True: 6.57k, False: 1.38M] ------------------ 385| 6.57k| { 386| 6.57k| for (auto& r : mResourcesWithGroup) ------------------ | Branch (386:26): [True: 5.24k, False: 6.46k] ------------------ 387| 5.24k| { 388| 5.24k| auto resMapIt = r.second.find(name); 389| | 390| 5.24k| if( resMapIt != r.second.end()) ------------------ | Branch (390:21): [True: 104, False: 5.14k] ------------------ 391| 104| { 392| 104| return resMapIt->second; 393| 104| } 394| 5.24k| } 395| 6.57k| } 396| 1.38M| else if (!isGlobal) ------------------ | Branch (396:18): [True: 1.38M, False: 0] ------------------ 397| 1.38M| { 398| | // look in the grouped pool 399| 1.38M| auto itGroup = mResourcesWithGroup.find(groupName); 400| 1.38M| if (itGroup != mResourcesWithGroup.end()) ------------------ | Branch (400:17): [True: 1.37M, False: 5.33k] ------------------ 401| 1.37M| { 402| 1.37M| auto it = itGroup->second.find(name); 403| | 404| 1.37M| if( it != itGroup->second.end()) ------------------ | Branch (404:21): [True: 676k, False: 703k] ------------------ 405| 676k| { 406| 676k| return it->second; 407| 676k| } 408| 1.37M| } 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| 1.38M| } 419| | 420| 715k| return ResourcePtr(); 421| 1.39M| } _ZN4Ogre15ResourceManager13getNextHandleEv: 431| 714k| { 432| | // This is an atomic operation and hence needs no locking 433| 714k| return mNextHandle++; 434| 714k| } _ZNK4Ogre18RibbonTrailFactory7getTypeEv: 433| 3| { 434| 3| return MOT_RIBBON_TRAIL; 435| 3| } _ZN4Ogre4Root15getSingletonPtrEv: 86| 10| { 87| 10| return msSingleton; 88| 10| } _ZN4Ogre4Root12getSingletonEv: 90| 5.18k| { 91| | assert( msSingleton ); return ( *msSingleton ); 92| 5.18k| } _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(); 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(); 141| 1| mArchiveManager = std::make_unique(); 142| 1| mResourceGroupManager = std::make_unique(); 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(); 159| | 160| | // Create SceneManager enumerator (note - will be managed by singleton) 161| 1| mSceneManagerEnum = std::make_unique(); 162| 1| mShadowTextureManager = std::make_unique(); 163| 1| mRenderSystemCapabilitiesManager = std::make_unique(); 164| 1| mMaterialManager = std::make_unique(); 165| 1| mMeshManager = std::make_unique(); 166| 1| mSkeletonManager = std::make_unique(); 167| 1| mParticleManager = std::make_unique(); 168| 1| mTimer = std::make_unique(); 169| 1| mLodStrategyManager = std::make_unique(); 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(); 179| 1| ArchiveManager::getSingleton().addArchiveFactory( mFileSystemArchiveFactory.get() ); 180| 1|# if OGRE_NO_ZIP_ARCHIVE == 0 181| 1| mZipArchiveFactory = std::make_unique(); 182| 1| ArchiveManager::getSingleton().addArchiveFactory( mZipArchiveFactory.get() ); 183| 1| mEmbeddedZipArchiveFactory = std::make_unique(); 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| |#if OGRE_NO_PVRTC_CODEC == 0 192| | PVRTCCodec::startup(); 193| |#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(); 202| 1| mExternalTextureSourceManager = std::make_unique(); 203| 1| mCompositorManager = std::make_unique(); 204| 1| mCompilerManager = std::make_unique(); 205| | 206| | // Auto window 207| 1| mAutoWindow = 0; 208| | 209| | // instantiate and register base movable factories 210| 1| mEntityFactory = std::make_unique(); 211| 1| addMovableObjectFactory(mEntityFactory.get()); 212| 1| mLightFactory = std::make_unique(); 213| 1| addMovableObjectFactory(mLightFactory.get()); 214| 1| mBillboardSetFactory = std::make_unique(); 215| 1| addMovableObjectFactory(mBillboardSetFactory.get()); 216| 1| mManualObjectFactory = std::make_unique(); 217| 1| addMovableObjectFactory(mManualObjectFactory.get()); 218| 1| mBillboardChainFactory = std::make_unique(); 219| 1| addMovableObjectFactory(mBillboardChainFactory.get()); 220| 1| mRibbonTrailFactory = std::make_unique(); 221| 1| addMovableObjectFactory(mRibbonTrailFactory.get()); 222| 1| mStaticGeometryFactory = std::make_unique(); 223| 1| addMovableObjectFactory(mStaticGeometryFactory.get()); 224| 1| mRectangle2DFactory = std::make_unique(); 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: 515| 5.15k| { 516| | // Gets the currently active renderer 517| 5.15k| return mActiveRenderer; 518| | 519| 5.15k| } _ZN4Ogre4Root23addMovableObjectFactoryEPNS_20MovableObjectFactoryEb: 1196| 9| { 1197| 9| MovableObjectFactoryMap::iterator facti = mMovableObjectFactoryMap.find( 1198| 9| fact->getType()); 1199| 9| if (!overrideExisting && facti != mMovableObjectFactoryMap.end()) ------------------ | Branch (1199:13): [True: 9, False: 0] | Branch (1199:13): [True: 0, False: 9] | Branch (1199:34): [True: 0, False: 9] ------------------ 1200| 0| { 1201| 0| OGRE_EXCEPT(Exception::ERR_DUPLICATE_ITEM, 1202| 0| "A factory of type '" + fact->getType() + "' already exists.", 1203| 0| "Root::addMovableObjectFactory"); 1204| 0| } 1205| | 1206| 9| if (fact->requestTypeFlags()) ------------------ | Branch (1206:13): [True: 0, False: 9] ------------------ 1207| 0| { 1208| 0| if (facti != mMovableObjectFactoryMap.end() && facti->second->requestTypeFlags()) ------------------ | Branch (1208:17): [True: 0, False: 0] | Branch (1208:17): [True: 0, False: 0] | Branch (1208:60): [True: 0, False: 0] ------------------ 1209| 0| { 1210| | // Copy type flags from the factory we're replacing 1211| 0| fact->_notifyTypeFlags(facti->second->getTypeFlags()); 1212| 0| } 1213| 0| else 1214| 0| { 1215| | // Allocate new 1216| 0| fact->_notifyTypeFlags(_allocateNextMovableObjectTypeFlag()); 1217| 0| } 1218| 0| } 1219| | 1220| | // Save 1221| 9| mMovableObjectFactoryMap[fact->getType()] = fact; 1222| | 1223| 9| LogManager::getSingleton().logMessage("MovableObjectFactory for type '" + 1224| 9| fact->getType() + "' registered."); 1225| | 1226| 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| 847k| :line(0), type(ANT_UNKNOWN), parent(ptr) 41| 847k| {} _ZN4Ogre16AtomAbstractNodeC2EPNS_12AbstractNodeE: 45| 419k| :AbstractNode(ptr), id(0) 46| 419k| { 47| 419k| type = ANT_ATOM; 48| 419k| } _ZNK4Ogre16AtomAbstractNode5cloneEv: 51| 37.7k| { 52| | AtomAbstractNode *node = OGRE_NEW AtomAbstractNode(parent); 53| 37.7k| node->file = file; 54| 37.7k| node->line = line; 55| 37.7k| node->id = id; 56| 37.7k| node->type = type; 57| 37.7k| node->value = value; 58| 37.7k| return node; 59| 37.7k| } _ZN4Ogre18ObjectAbstractNodeC2EPNS_12AbstractNodeE: 63| 131k| :AbstractNode(ptr), id(0), abstract(false) 64| 131k| { 65| 131k| type = ANT_OBJECT; 66| 131k| } _ZNK4Ogre18ObjectAbstractNode5cloneEv: 69| 11.4k| { 70| 11.4k| ObjectAbstractNode *node = OGRE_NEW ObjectAbstractNode(parent); 71| 11.4k| node->file = file; 72| 11.4k| node->line = line; 73| 11.4k| node->type = type; 74| 11.4k| node->name = name; 75| 11.4k| node->cls = cls; 76| 11.4k| node->id = id; 77| 11.4k| node->abstract = abstract; 78| 11.4k| for(const auto & i : children) ------------------ | Branch (78:28): [True: 19.2k, False: 11.4k] ------------------ 79| 19.2k| { 80| 19.2k| AbstractNodePtr newNode = AbstractNodePtr(i->clone()); 81| 19.2k| newNode->parent = node; 82| 19.2k| node->children.push_back(newNode); 83| 19.2k| } 84| 11.4k| for(const auto & value : values) ------------------ | Branch (84:32): [True: 2.28k, False: 11.4k] ------------------ 85| 2.28k| { 86| 2.28k| AbstractNodePtr newNode = AbstractNodePtr(value->clone()); 87| 2.28k| newNode->parent = node; 88| 2.28k| node->values.push_back(newNode); 89| 2.28k| } 90| 11.4k| node->mEnv = mEnv; 91| 11.4k| return node; 92| 11.4k| } _ZN4Ogre18ObjectAbstractNode11setVariableERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 100| 8.54k| { 101| 8.54k| mEnv[inName] = value; 102| 8.54k| } _ZNK4Ogre18ObjectAbstractNode11getVariableERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 105| 11.7k| { 106| 11.7k| std::map::const_iterator i = mEnv.find(inName); 107| 11.7k| if(i != mEnv.end()) ------------------ | Branch (107:12): [True: 5.23k, False: 6.51k] ------------------ 108| 5.23k| return std::make_pair(true, i->second); 109| | 110| 6.51k| auto parentNode = this->parent; 111| 16.0k| while(parentNode && parentNode->type == ANT_OBJECT) ------------------ | Branch (111:15): [True: 12.3k, False: 3.74k] | Branch (111:29): [True: 11.2k, False: 1.09k] ------------------ 112| 11.2k| { 113| 11.2k| ObjectAbstractNode *parentObj = (ObjectAbstractNode*)parentNode; 114| 11.2k| i = parentObj->mEnv.find(inName); 115| 11.2k| if(i != parentObj->mEnv.end()) ------------------ | Branch (115:16): [True: 1.67k, False: 9.57k] ------------------ 116| 1.67k| return std::make_pair(true, i->second); 117| 9.57k| parentNode = parentNode->parent; 118| 9.57k| } 119| 4.84k| return std::make_pair(false, ""); 120| 6.51k| } _ZNK4Ogre18ObjectAbstractNode12getVariablesEv: 123| 5.83k| { 124| 5.83k| return mEnv; 125| 5.83k| } _ZN4Ogre20PropertyAbstractNodeC2EPNS_12AbstractNodeE: 129| 259k| :AbstractNode(ptr), id(0) 130| 259k| { 131| 259k| type = ANT_PROPERTY; 132| 259k| } _ZNK4Ogre20PropertyAbstractNode5cloneEv: 135| 17.5k| { 136| 17.5k| PropertyAbstractNode *node = OGRE_NEW PropertyAbstractNode(parent); 137| 17.5k| node->file = file; 138| 17.5k| node->line = line; 139| 17.5k| node->type = type; 140| 17.5k| node->name = name; 141| 17.5k| node->id = id; 142| 17.5k| for(const auto & value : values) ------------------ | Branch (142:32): [True: 34.1k, False: 17.5k] ------------------ 143| 34.1k| { 144| 34.1k| AbstractNodePtr newNode = AbstractNodePtr(value->clone()); 145| 34.1k| newNode->parent = node; 146| 34.1k| node->values.push_back(newNode); 147| 34.1k| } 148| 17.5k| return node; 149| 17.5k| } _ZN4Ogre18ImportAbstractNodeC2Ev: 153| 21.2k| :AbstractNode(0) 154| 21.2k| { 155| 21.2k| type = ANT_IMPORT; 156| 21.2k| } _ZN4Ogre26VariableAccessAbstractNodeC2EPNS_12AbstractNodeE: 171| 15.4k| :AbstractNode(ptr) 172| 15.4k| { 173| 15.4k| type = ANT_VARIABLE_ACCESS; 174| 15.4k| } _ZNK4Ogre26VariableAccessAbstractNode5cloneEv: 177| 1.03k| { 178| | VariableAccessAbstractNode *node = OGRE_NEW VariableAccessAbstractNode(parent); 179| 1.03k| node->file = file; 180| 1.03k| node->line = line; 181| 1.03k| node->type = type; 182| 1.03k| node->name = name; 183| 1.03k| return node; 184| 1.03k| } _ZN4Ogre22ScriptCompilerListenerC2Ev: 188| 1| { 189| 1| } _ZN4Ogre22ScriptCompilerListener13preConversionEPNS_14ScriptCompilerENS_9SharedPtrINSt3__14listINS3_INS_12ConcreteNodeEEENS4_9allocatorIS7_EEEEEE: 197| 7.10k| { 198| | 199| 7.10k| } _ZN4Ogre22ScriptCompilerListener14postConversionEPNS_14ScriptCompilerERKNS_9SharedPtrINSt3__14listINS3_INS_12AbstractNodeEEENS4_9allocatorIS7_EEEEEE: 202| 7.09k| { 203| 7.09k| return true; 204| 7.09k| } _ZN4Ogre22ScriptCompilerListener11handleEventEPNS_14ScriptCompilerEPNS_19ScriptCompilerEventEPv: 220| 101k| { 221| 101k| return false; 222| 101k| } _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| 7.10k| { 328| 7.10k| if(nodes && !nodes->empty()) ------------------ | Branch (328:12): [True: 7.10k, False: 0] | Branch (328:21): [True: 6.92k, False: 176] ------------------ 329| 6.92k| { 330| 6.92k| mSourceFile = nodes->front()->file; 331| 6.92k| } 332| | 333| | // Set up the compilation context 334| 7.10k| mGroup = group; 335| | 336| | // Clear the past errors 337| 7.10k| mErrors.clear(); 338| | 339| | // Clear the environment 340| 7.10k| mEnv.clear(); 341| | 342| 7.10k| if(mListener) ------------------ | Branch (342:12): [True: 7.10k, False: 0] ------------------ 343| 7.10k| mListener->preConversion(this, nodes); 344| | 345| | // Convert our nodes to an AST 346| 7.10k| AbstractNodeListPtr ast = convertToAST(*nodes); 347| | // Processes the imports for this script 348| 7.10k| processImports(*ast); 349| | // Process object inheritance 350| 7.10k| processObjects(*ast, *ast); 351| | // Process variable expansion 352| 7.10k| std::set expadingVars; 353| 7.10k| processVariables(*ast, expadingVars); 354| | 355| | // Allows early bail-out through the listener 356| 7.10k| if(mListener && !mListener->postConversion(this, ast)) ------------------ | Branch (356:12): [True: 7.09k, False: 7] | Branch (356:25): [True: 0, False: 7.09k] ------------------ 357| 0| return mErrors.empty(); 358| | 359| | // Translate the nodes 360| 7.10k| for(auto & i : *ast) ------------------ | Branch (360:22): [True: 45.8k, False: 7.10k] ------------------ 361| 45.8k| { 362| |#if DEBUG_AST 363| | logAST(0, i); 364| |#endif 365| 45.8k| if(i->type == ANT_OBJECT && static_cast(i.get())->abstract) ------------------ | Branch (365:16): [True: 22.7k, False: 23.0k] | Branch (365:41): [True: 120, False: 22.6k] ------------------ 366| 120| continue; 367| | //LogManager::getSingleton().logMessage(static_cast((*i).get())->name); 368| 45.6k| ScriptTranslator *translator = ScriptCompilerManager::getSingleton().getTranslator(i); 369| 45.6k| if(translator) ------------------ | Branch (369:16): [True: 15.9k, False: 29.7k] ------------------ 370| 15.9k| translator->translate(this, i); 371| 45.6k| } 372| | 373| 7.10k| mImports.clear(); 374| 7.10k| mImportRequests.clear(); 375| 7.10k| mImportTable.clear(); 376| 7.10k| mSourceFile.clear(); 377| | 378| 7.10k| return mErrors.empty(); 379| 7.10k| } _ZN4Ogre14ScriptCompiler8addErrorEjRKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEiS9_: 382| 124k| { 383| 124k| if(mListener) ------------------ | Branch (383:12): [True: 124k, False: 0] ------------------ 384| 124k| { 385| 124k| mListener->handleError(this, code, file, line, msg); 386| 124k| } 387| 0| else 388| 0| { 389| 0| static ScriptCompilerListener defaultListener; 390| 0| defaultListener.handleError(this, code, file, line, msg); 391| 0| } 392| | 393| 124k| mErrors.push_back({file, msg, line, code}); 394| 124k| } _ZN4Ogre14ScriptCompiler8addErrorERKNS_12AbstractNodeERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEj: 397| 33.0k| { 398| 33.0k| addError(code, mSourceFile, node.line, msg); 399| 33.0k| } _ZN4Ogre14ScriptCompiler11setListenerEPNS_22ScriptCompilerListenerE: 402| 1| { 403| 1| mListener = listener; 404| 1| } _ZN4Ogre14ScriptCompiler11getListenerEv: 407| 125| { 408| 125| return mListener; 409| 125| } _ZNK4Ogre14ScriptCompiler16getResourceGroupEv: 412| 44.5k| { 413| 44.5k| return mGroup; 414| 44.5k| } _ZN4Ogre14ScriptCompiler10_fireEventEPNS_19ScriptCompilerEventEPv: 417| 101k| { 418| 101k| if(mListener) ------------------ | Branch (418:12): [True: 101k, False: 0] ------------------ 419| 101k| return mListener->handleEvent(this, evt, retval); 420| 0| return false; 421| 101k| } _ZN4Ogre14ScriptCompiler12convertToASTERKNSt3__14listINS_9SharedPtrINS_12ConcreteNodeEEENS1_9allocatorIS5_EEEE: 424| 37.1k| { 425| 37.1k| AbstractTreeBuilder builder(this); 426| 37.1k| AbstractTreeBuilder::visit(&builder, nodes); 427| 37.1k| return builder.getResult(); 428| 37.1k| } _ZN4Ogre14ScriptCompiler14processImportsERNSt3__14listINS_9SharedPtrINS_12AbstractNodeEEENS1_9allocatorIS5_EEEE: 431| 7.10k| { 432| | // We only need to iterate over the top-level of nodes 433| 7.10k| AbstractNodeList::iterator i = nodes.begin(); 434| 76.5k| while(i != nodes.end()) ------------------ | Branch (434:15): [True: 69.4k, False: 7.10k] ------------------ 435| 69.4k| { 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| 69.4k| AbstractNodeList::iterator cur = i++; 441| 69.4k| if((*cur)->type == ANT_IMPORT) ------------------ | Branch (441:16): [True: 21.2k, False: 48.1k] ------------------ 442| 21.2k| { 443| 21.2k| ImportAbstractNode *import = (ImportAbstractNode*)(*cur).get(); 444| | // Only process if the file's contents haven't been loaded 445| 21.2k| if(mImports.find(import->source) == mImports.end()) ------------------ | Branch (445:20): [True: 21.2k, False: 0] ------------------ 446| 21.2k| { 447| | // Load the script 448| 21.2k| AbstractNodeListPtr importedNodes = loadImportPath(import->source); 449| 21.2k| if(importedNodes && !importedNodes->empty()) ------------------ | Branch (449:24): [True: 21.2k, False: 0] | Branch (449:41): [True: 0, False: 21.2k] ------------------ 450| 0| { 451| 0| processImports(*importedNodes); 452| 0| processObjects(*importedNodes, *importedNodes); 453| 0| } 454| 21.2k| else 455| 21.2k| { 456| 21.2k| addError(CE_REFERENCETOANONEXISTINGOBJECT, import->file, import->line, import->source); 457| 21.2k| } 458| | 459| 21.2k| if(importedNodes && !importedNodes->empty()) ------------------ | Branch (459:24): [True: 21.2k, False: 0] | Branch (459:41): [True: 0, False: 21.2k] ------------------ 460| 0| mImports.insert(std::make_pair(import->source, importedNodes)); 461| 21.2k| } 462| | 463| 21.2k| ImportRequestMap::iterator iter = mImportRequests.lower_bound(import->source), 464| 21.2k| 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| 21.2k| if(import->target == "*") ------------------ | Branch (468:20): [True: 14.8k, False: 6.36k] ------------------ 469| 14.8k| { 470| 14.8k| mImportRequests.erase(iter, end); 471| 14.8k| mImportRequests.insert(std::make_pair(import->source, "*")); 472| 14.8k| } 473| 6.36k| else 474| 6.36k| { 475| 6.36k| if(iter == end || iter->second != "*") ------------------ | Branch (475:24): [True: 813, False: 5.55k] | Branch (475:39): [True: 4.48k, False: 1.06k] ------------------ 476| 5.29k| { 477| 5.29k| mImportRequests.insert(std::make_pair(import->source, import->target)); 478| 5.29k| } 479| 6.36k| } 480| | 481| 21.2k| nodes.erase(cur); 482| 21.2k| } 483| 69.4k| } 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| 7.10k| for(auto & import : mImports) ------------------ | Branch (488:27): [True: 0, False: 7.10k] ------------------ 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| 7.10k| } _ZN4Ogre14ScriptCompiler14loadImportPathERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 518| 21.2k| { 519| 21.2k| AbstractNodeListPtr retval; 520| 21.2k| ConcreteNodeListPtr nodes; 521| | 522| 21.2k| if(mListener) ------------------ | Branch (522:12): [True: 21.2k, False: 0] ------------------ 523| 21.2k| nodes = mListener->importFile(this, name); 524| | 525| 21.2k| if(!nodes && ResourceGroupManager::getSingletonPtr()) ------------------ | Branch (525:12): [True: 0, False: 21.2k] | 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| 21.2k| if(nodes) ------------------ | Branch (535:12): [True: 21.2k, False: 0] ------------------ 536| 21.2k| retval = convertToAST(*nodes); 537| | 538| 21.2k| return retval; 539| 21.2k| } _ZN4Ogre14ScriptCompiler12locateTargetERKNSt3__14listINS_9SharedPtrINS_12AbstractNodeEEENS1_9allocatorIS5_EEEERKNS1_12basic_stringIcNS1_11char_traitsIcEENS6_IcEEEE: 542| 14.3k| { 543| | // Search for a top-level object node 544| 14.3k| for(const auto& n : nodes) ------------------ | Branch (544:27): [True: 188k, False: 9.30k] ------------------ 545| 188k| { 546| 188k| if(n->type == ANT_OBJECT && static_cast(n.get())->name == target) ------------------ | Branch (546:16): [True: 68.7k, False: 120k] | Branch (546:41): [True: 5.06k, False: 63.6k] ------------------ 547| 5.06k| { 548| 5.06k| return n; 549| 5.06k| } 550| 188k| } 551| | 552| 9.30k| return nullptr; 553| 14.3k| } _ZN4Ogre14ScriptCompiler14processObjectsERNSt3__14listINS_9SharedPtrINS_12AbstractNodeEEENS1_9allocatorIS5_EEEERKS8_PKNS_18ObjectAbstractNodeE: 556| 129k| { 557| 129k| for(auto& node : nodes) ------------------ | Branch (557:24): [True: 309k, False: 129k] ------------------ 558| 309k| { 559| 309k| if(node->type == ANT_OBJECT) ------------------ | Branch (559:16): [True: 122k, False: 186k] ------------------ 560| 122k| { 561| 122k| ObjectAbstractNode *obj = (ObjectAbstractNode*)node.get(); 562| | 563| 122k| auto skipNode = exclude ? exclude : obj; // set to us at the top level ------------------ | Branch (563:33): [True: 98.6k, False: 23.8k] ------------------ 564| | 565| 122k|#ifdef OGRE_BUILD_COMPONENT_OVERLAY 566| 122k| bool isOverlayElement = obj->cls == "overlay_element"; 567| 122k|#endif 568| | // Overlay base classes in order. 569| 122k| for (String& base : obj->bases) ------------------ | Branch (569:35): [True: 9.71k, False: 122k] ------------------ 570| 9.71k| { 571| | // Check the top level first, then check the import table 572| 9.71k| auto target = locateTarget(top, base); 573| 9.71k| if(!target) ------------------ | Branch (573:24): [True: 4.65k, False: 5.06k] ------------------ 574| 4.65k| target = locateTarget(mImportTable, base); 575| | 576| 9.71k| if (!target) ------------------ | Branch (576:25): [True: 4.65k, False: 5.06k] ------------------ 577| 4.65k| { 578| 4.65k| addError(CE_OBJECTBASENOTFOUND, obj->file, obj->line, base); 579| 4.65k| continue; 580| 4.65k| } 581| | 582| 5.06k| auto& src = static_cast(*target); 583| | 584| 5.06k| if (target.get() == skipNode) ------------------ | Branch (584:25): [True: 1.27k, False: 3.78k] ------------------ 585| 1.27k| { 586| 1.27k| addError(CE_OBJECTBASENOTFOUND, obj->file, obj->line, "cannot inherit from itself"); 587| 1.27k| continue; 588| 1.27k| } 589| | 590| 3.78k| if (src.cls != obj->cls) ------------------ | Branch (590:25): [True: 719, False: 3.06k] ------------------ 591| 719| { 592| 719| addError(CE_OBJECTBASENOTFOUND, obj->file, obj->line, "cannot inherit from a different type"); 593| 719| continue; 594| 719| } 595| | 596| 3.06k|#ifdef OGRE_BUILD_COMPONENT_OVERLAY 597| | // uses custom inheritance for renaming children 598| 3.06k| if (isOverlayElement) ------------------ | Branch (598:25): [True: 0, False: 3.06k] ------------------ 599| 0| { 600| 0| if (src.abstract) ------------------ | Branch (600:29): [True: 0, False: 0] ------------------ 601| 0| base = ""; // hide from custom inheritance 602| 0| else 603| 0| continue; 604| 0| } 605| 3.06k|#endif 606| 3.06k| overlayObject(src, *obj); 607| 3.06k| } 608| | 609| | // Recurse into children 610| 122k| 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| 122k| obj->children.insert(obj->children.begin(), obj->overrides.begin(), obj->overrides.end()); 616| 122k| } 617| 309k| } 618| 129k| } _ZN4Ogre14ScriptCompiler13overlayObjectERKNS_18ObjectAbstractNodeERS1_: 621| 5.83k| { 622| | // Overlay the environment of one on top the other first 623| 5.83k| for(const auto & i : src.getVariables()) ------------------ | Branch (623:28): [True: 245, False: 5.83k] ------------------ 624| 245| { 625| 245| std::pair var = dest.getVariable(i.first); 626| 245| if(!var.first) ------------------ | Branch (626:16): [True: 234, False: 11] ------------------ 627| 234| dest.setVariable(i.first, i.second); 628| 245| } 629| | 630| | // Create a vector storing each pairing of override between source and destination 631| 5.83k| typedef SharedPtr ObjectAbstractNodePtr; 632| 5.83k| std::vector > overrides; 633| | // A list of indices for each destination node tracks the minimum 634| | // source node they can index-match against 635| 5.83k| std::map indices; 636| | // A map storing which nodes have overridden from the destination node 637| 5.83k| std::map 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| 5.83k| AbstractNodeList::iterator insertPos = dest.children.begin(); 642| 5.83k| for(const auto & i : src.children) ------------------ | Branch (642:28): [True: 14.7k, False: 5.83k] ------------------ 643| 14.7k| { 644| 14.7k| if(i->type == ANT_OBJECT) ------------------ | Branch (644:16): [True: 7.32k, False: 7.40k] ------------------ 645| 7.32k| { 646| 7.32k| overrides.push_back(std::make_pair(static_pointer_cast(i), dest.children.end())); 647| 7.32k| } 648| 7.40k| else 649| 7.40k| { 650| 7.40k| AbstractNodePtr newNode(i->clone()); 651| 7.40k| newNode->parent = &dest; 652| 7.40k| dest.overrides.push_back(newNode); 653| 7.40k| } 654| 14.7k| } 655| | 656| | // Track the running maximum override index in the name-matching phase 657| 5.83k| size_t maxOverrideIndex = 0; 658| | 659| | // Loop through destination children searching for name-matching overrides 660| 14.4k| for(AbstractNodeList::iterator i = dest.children.begin(); i != dest.children.end(); ) ------------------ | Branch (660:67): [True: 8.61k, False: 5.83k] ------------------ 661| 8.61k| { 662| 8.61k| if((*i)->type == ANT_OBJECT) ------------------ | Branch (662:16): [True: 4.53k, False: 4.08k] ------------------ 663| 4.53k| { 664| | // Start tracking the override index position for this object 665| 4.53k| size_t overrideIndex = 0; 666| | 667| 4.53k| ObjectAbstractNode *node = static_cast((*i).get()); 668| 4.53k| indices[node] = maxOverrideIndex; 669| 4.53k| overridden[node] = false; 670| | 671| | // special treatment for materials with * in their name 672| 4.53k| bool nodeHasWildcard=node->name.find('*') != String::npos; 673| | 674| | // Find the matching name node 675| 9.85k| for(size_t j = 0; j < overrides.size(); ++j) ------------------ | Branch (675:35): [True: 5.89k, False: 3.96k] ------------------ 676| 5.89k| { 677| 5.89k| ObjectAbstractNode *temp = overrides[j].first.get(); 678| | // Consider a match a node that has a wildcard and matches an input name 679| 5.89k| bool wildcardMatch = nodeHasWildcard && ------------------ | Branch (679:42): [True: 383, False: 5.50k] ------------------ 680| 383| (StringUtil::match(temp->name,node->name,true) || ------------------ | Branch (680:26): [True: 240, False: 143] ------------------ 681| 143| (node->name.size() == 1 && temp->name.empty())); ------------------ | Branch (681:30): [True: 0, False: 143] | Branch (681:56): [True: 0, False: 0] ------------------ 682| 5.89k| if(temp->cls == node->cls && !node->name.empty() && (temp->name == node->name || wildcardMatch)) ------------------ | Branch (682:24): [True: 3.49k, False: 2.40k] | Branch (682:50): [True: 1.25k, False: 2.23k] | Branch (682:74): [True: 753, False: 500] | Branch (682:102): [True: 14, False: 486] ------------------ 683| 767| { 684| | // Pair these two together unless it's already paired 685| 767| if(overrides[j].second == dest.children.end()) ------------------ | Branch (685:28): [True: 754, False: 13] ------------------ 686| 754| { 687| 754| AbstractNodeList::iterator currentIterator = i; 688| 754| ObjectAbstractNode *currentNode = node; 689| 754| if (wildcardMatch) ------------------ | Branch (689:33): [True: 204, False: 550] ------------------ 690| 204| { 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| 204| AbstractNodePtr newNode((*i)->clone()); 693| 204| currentIterator = dest.children.insert(currentIterator, newNode); 694| 204| currentNode = static_cast((*currentIterator).get()); 695| 204| currentNode->name = temp->name;//make the regex match its matcher 696| 204| } 697| 754| overrides[j] = std::make_pair(overrides[j].first, currentIterator); 698| | // Store the max override index for this matched pair 699| 754| overrideIndex = j; 700| 754| overrideIndex = maxOverrideIndex = std::max(overrideIndex, maxOverrideIndex); 701| 754| indices[currentNode] = overrideIndex; 702| 754| overridden[currentNode] = true; 703| 754| } 704| 13| else 705| 13| { 706| 13| addError(CE_DUPLICATEOVERRIDE, node->file, node->line); 707| 13| } 708| | 709| 767| if(!wildcardMatch) ------------------ | Branch (709:28): [True: 563, False: 204] ------------------ 710| 563| break; 711| 767| } 712| 5.89k| } 713| | 714| 4.53k| if (nodeHasWildcard) ------------------ | Branch (714:21): [True: 300, False: 4.23k] ------------------ 715| 300| { 716| | //if the node has a wildcard it will be deleted since it was duplicated for every match 717| 300| AbstractNodeList::iterator deletable=i++; 718| 300| dest.children.erase(deletable); 719| 300| } 720| 4.23k| else 721| 4.23k| { 722| 4.23k| ++i; //Behavior in absence of regex, just increment iterator 723| 4.23k| } 724| 4.53k| } 725| 4.08k| else 726| 4.08k| { 727| 4.08k| ++i; //Behavior in absence of replaceable object, just increment iterator to find another 728| 4.08k| } 729| 8.61k| } 730| | 731| | // Now make matches based on index 732| | // Loop through destination children searching for index-matching overrides 733| 14.3k| for(AbstractNodeList::iterator i = dest.children.begin(); i != dest.children.end(); ++i) ------------------ | Branch (733:67): [True: 8.52k, False: 5.83k] ------------------ 734| 8.52k| { 735| 8.52k| if((*i)->type == ANT_OBJECT) ------------------ | Branch (735:16): [True: 4.43k, False: 4.08k] ------------------ 736| 4.43k| { 737| 4.43k| ObjectAbstractNode *node = static_cast((*i).get()); 738| 4.43k| if(!overridden[node]) ------------------ | Branch (738:20): [True: 3.68k, False: 754] ------------------ 739| 3.68k| { 740| | // Retrieve the minimum override index from the map 741| 3.68k| size_t overrideIndex = indices[node]; 742| | 743| 3.68k| if(overrideIndex < overrides.size()) ------------------ | Branch (743:24): [True: 3.05k, False: 628] ------------------ 744| 3.05k| { 745| | // Search for minimum matching override 746| 4.99k| for(size_t j = overrideIndex; j < overrides.size(); ++j) ------------------ | Branch (746:55): [True: 3.96k, False: 1.03k] ------------------ 747| 3.96k| { 748| 3.96k| ObjectAbstractNode *temp = overrides[j].first.get(); 749| 3.96k| if(temp->name.empty() && node->name.empty() && temp->cls == node->cls && overrides[j].second == dest.children.end()) ------------------ | Branch (749:32): [True: 2.87k, False: 1.08k] | Branch (749:32): [True: 2.02k, False: 1.94k] | Branch (749:54): [True: 2.65k, False: 224] | Branch (749:76): [True: 2.04k, False: 606] | Branch (749:102): [True: 2.02k, False: 25] ------------------ 750| 2.02k| { 751| 2.02k| overrides[j] = std::make_pair(overrides[j].first, i); 752| 2.02k| break; 753| 2.02k| } 754| 3.96k| } 755| 3.05k| } 756| 3.68k| } 757| 4.43k| } 758| 8.52k| } 759| | 760| | // Loop through overrides, either inserting source nodes or overriding 761| 5.83k| insertPos = dest.children.begin(); 762| 5.83k| for(auto & override : overrides) ------------------ | Branch (762:29): [True: 7.32k, False: 5.83k] ------------------ 763| 7.32k| { 764| 7.32k| if(override.second != dest.children.end()) ------------------ | Branch (764:16): [True: 2.77k, False: 4.54k] ------------------ 765| 2.77k| { 766| | // Override the destination with the source (base) object 767| 2.77k| overlayObject(*override.first, 768| 2.77k| static_cast(**override.second)); 769| 2.77k| insertPos = override.second; 770| 2.77k| insertPos++; 771| 2.77k| } 772| 4.54k| else 773| 4.54k| { 774| | // No override was possible, so insert this node at the insert position 775| | // into the destination (child) object 776| 4.54k| AbstractNodePtr newNode(override.first->clone()); 777| 4.54k| newNode->parent = &dest; 778| 4.54k| if(insertPos != dest.children.end()) ------------------ | Branch (778:20): [True: 2.23k, False: 2.30k] ------------------ 779| 2.23k| { 780| 2.23k| dest.children.insert(insertPos, newNode); 781| 2.23k| } 782| 2.30k| else 783| 2.30k| { 784| 2.30k| dest.children.push_back(newNode); 785| 2.30k| } 786| 4.54k| } 787| 7.32k| } 788| 5.83k| } _ZN4Ogre14ScriptCompiler14isNameExcludedERKNS_18ObjectAbstractNodeEPNS_12AbstractNodeE: 791| 62.3k| { 792| | // Run past the listener 793| 62.3k| bool excludeName = false; 794| 62.3k| ProcessNameExclusionScriptCompilerEvent evt(node.cls, parent); 795| 62.3k| if(_fireEvent(&evt, (void*)&excludeName)) ------------------ | Branch (795:12): [True: 0, False: 62.3k] ------------------ 796| 0| return excludeName; 797| | 798| | // Process the built-in name exclusions 799| 62.3k| if(node.id == ID_EMITTER || node.id == ID_AFFECTOR) ------------------ | Branch (799:12): [True: 549, False: 61.8k] | Branch (799:37): [True: 299, False: 61.5k] ------------------ 800| 848| { 801| | // emitters or affectors inside a particle_system are excluded 802| 2.18k| while(parent && parent->type == ANT_OBJECT) ------------------ | Branch (802:19): [True: 1.85k, False: 327] | Branch (802:29): [True: 1.40k, False: 447] ------------------ 803| 1.40k| { 804| 1.40k| ObjectAbstractNode *obj = static_cast(parent); 805| 1.40k| if(obj->id == ID_PARTICLE_SYSTEM) ------------------ | Branch (805:20): [True: 74, False: 1.33k] ------------------ 806| 74| return true; 807| 1.33k| parent = obj->parent; 808| 1.33k| } 809| 848| } 810| 61.5k| else if(node.id == ID_PASS) ------------------ | Branch (810:17): [True: 8.43k, False: 53.1k] ------------------ 811| 8.43k| { 812| | // passes inside compositors are excluded 813| 20.9k| while(parent && parent->type == ANT_OBJECT) ------------------ | Branch (813:19): [True: 16.9k, False: 4.04k] | Branch (813:29): [True: 16.5k, False: 345] ------------------ 814| 16.5k| { 815| 16.5k| ObjectAbstractNode *obj = static_cast(parent); 816| 16.5k| if(obj->id == ID_TARGET || obj->id == ID_TARGET_OUTPUT) ------------------ | Branch (816:20): [True: 2.50k, False: 14.0k] | Branch (816:44): [True: 1.52k, False: 12.5k] ------------------ 817| 4.03k| return true; 818| 12.5k| parent = obj->parent; 819| 12.5k| } 820| 8.43k| } 821| 53.1k| else if(node.id == ID_TEXTURE_SOURCE) ------------------ | Branch (821:17): [True: 210, False: 52.8k] ------------------ 822| 210| { 823| | // Parent must be texture_unit 824| 638| while(parent && parent->type == ANT_OBJECT) ------------------ | Branch (824:19): [True: 524, False: 114] | Branch (824:29): [True: 468, False: 56] ------------------ 825| 468| { 826| 468| ObjectAbstractNode *obj = static_cast(parent); 827| 468| if(obj->id == ID_TEXTURE_UNIT) ------------------ | Branch (827:20): [True: 40, False: 428] ------------------ 828| 40| return true; 829| 428| parent = obj->parent; 830| 428| } 831| 210| } 832| | 833| 58.2k| return false; 834| 62.3k| } _ZN4Ogre14ScriptCompiler16processVariablesERNSt3__14listINS_9SharedPtrINS_12AbstractNodeEEENS1_9allocatorIS5_EEEERNS1_3setINS1_12basic_stringIcNS1_11char_traitsIcEENS6_IcEEEENS1_4lessISF_EENS6_ISF_EEEE: 837| 535k| { 838| 535k| AbstractNodeList::iterator i = nodes.begin(); 839| 1.35M| while(i != nodes.end()) ------------------ | Branch (839:15): [True: 821k, False: 535k] ------------------ 840| 821k| { 841| 821k| AbstractNodeList::iterator cur = i; 842| 821k| ++i; 843| | 844| 821k| if((*cur)->type == ANT_OBJECT) ------------------ | Branch (844:16): [True: 130k, False: 691k] ------------------ 845| 130k| { 846| | // Only process if this object is not abstract 847| 130k| ObjectAbstractNode *obj = (ObjectAbstractNode*)(*cur).get(); 848| 130k| if(!obj->abstract) ------------------ | Branch (848:20): [True: 130k, False: 314] ------------------ 849| 130k| { 850| 130k| processVariables(obj->children, expandingVars); 851| 130k| processVariables(obj->values, expandingVars); 852| 130k| } 853| 130k| } 854| 691k| else if((*cur)->type == ANT_PROPERTY) ------------------ | Branch (854:21): [True: 258k, False: 432k] ------------------ 855| 258k| { 856| 258k| PropertyAbstractNode *prop = (PropertyAbstractNode*)(*cur).get(); 857| 258k| processVariables(prop->values, expandingVars); 858| 258k| } 859| 432k| else if((*cur)->type == ANT_VARIABLE_ACCESS) ------------------ | Branch (859:21): [True: 15.3k, False: 416k] ------------------ 860| 15.3k| { 861| 15.3k| VariableAccessAbstractNode *var = (VariableAccessAbstractNode*)(*cur).get(); 862| | 863| | // Look up the enclosing scope 864| 15.3k| ObjectAbstractNode *scope = 0; 865| 15.3k| AbstractNode *temp = var->parent; 866| 144k| while(temp) ------------------ | Branch (866:23): [True: 140k, False: 3.86k] ------------------ 867| 140k| { 868| 140k| if(temp->type == ANT_OBJECT) ------------------ | Branch (868:24): [True: 11.5k, False: 128k] ------------------ 869| 11.5k| { 870| 11.5k| scope = (ObjectAbstractNode*)temp; 871| 11.5k| break; 872| 11.5k| } 873| 128k| temp = temp->parent; 874| 128k| } 875| | 876| | // Look up the variable in the environment 877| 15.3k| std::pair varAccess; 878| 15.3k| if(scope) ------------------ | Branch (878:20): [True: 11.5k, False: 3.86k] ------------------ 879| 11.5k| varAccess = scope->getVariable(var->name); 880| 15.3k| if(!scope || !varAccess.first) ------------------ | Branch (880:20): [True: 3.86k, False: 11.5k] | Branch (880:30): [True: 4.60k, False: 6.89k] ------------------ 881| 8.47k| { 882| 8.47k| std::map::iterator k = mEnv.find(var->name); 883| 8.47k| varAccess.first = k != mEnv.end(); 884| 8.47k| if(varAccess.first) ------------------ | Branch (884:24): [True: 1.94k, False: 6.52k] ------------------ 885| 1.94k| varAccess.second = k->second; 886| 8.47k| } 887| | 888| 15.3k| if(varAccess.first) ------------------ | Branch (888:20): [True: 8.84k, False: 6.52k] ------------------ 889| 8.84k| { 890| 8.84k| if(!expandingVars.insert(var->name).second) ------------------ | Branch (890:24): [True: 0, False: 8.84k] ------------------ 891| 0| { 892| | // Error 893| 0| addError(CE_INVALIDPARAMETERS, var->file, var->line, var->name+ " is defined recursively"); 894| 0| nodes.erase(cur); 895| 0| continue; 896| 0| } 897| | 898| | // Found the variable, so process it and insert it into the tree 899| 8.84k| ConcreteNodeListPtr cst = ScriptParser::parseChunk(ScriptLexer::tokenize(varAccess.second, var->file), var->file); 900| 8.84k| AbstractNodeListPtr ast = convertToAST(*cst); 901| | 902| | // Set up ownership for these nodes 903| 8.84k| for(auto & j : *ast) ------------------ | Branch (903:34): [True: 8.97k, False: 8.84k] ------------------ 904| 8.97k| j->parent = var->parent; 905| | 906| | // Recursively handle variable accesses within the variable expansion 907| 8.84k| processVariables(*ast, expandingVars); 908| | 909| | // Insert the nodes in place of the variable 910| 8.84k| nodes.insert(cur, ast->begin(), ast->end()); 911| | 912| 8.84k| expandingVars.erase(var->name); 913| 8.84k| } 914| 6.52k| else 915| 6.52k| { 916| | // Error 917| 6.52k| addError(CE_UNDEFINEDVARIABLE, var->file, var->line, var->name); 918| 6.52k| } 919| | 920| | // Remove the variable node 921| 15.3k| nodes.erase(cur); 922| 15.3k| } 923| 821k| } 924| 535k| } _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| 37.1k| :mNodes(std::make_shared()), mCurrent(0), mCompiler(compiler) 1259| 37.1k| { 1260| 37.1k| } _ZNK4Ogre14ScriptCompiler19AbstractTreeBuilder9getResultEv: 1263| 37.1k| { 1264| 37.1k| return mNodes; 1265| 37.1k| } _ZN4Ogre14ScriptCompiler19AbstractTreeBuilder5visitEPNS_12ConcreteNodeE: 1268| 765k| { 1269| 765k| AbstractNodePtr asn; 1270| | 1271| | // Import = "import" >> 2 children, mCurrent == null 1272| 765k| if(node->type == CNT_IMPORT && mCurrent == 0) ------------------ | Branch (1272:12): [True: 23.1k, False: 741k] | Branch (1272:40): [True: 21.2k, False: 1.86k] ------------------ 1273| 21.2k| { 1274| 21.2k| if(node->children.size() > 2) ------------------ | Branch (1274:16): [True: 0, False: 21.2k] ------------------ 1275| 0| { 1276| 0| mCompiler->addError(CE_FEWERPARAMETERSEXPECTED, node->file, node->line); 1277| 0| return; 1278| 0| } 1279| 21.2k| if(node->children.size() < 2) ------------------ | Branch (1279:16): [True: 0, False: 21.2k] ------------------ 1280| 0| { 1281| 0| mCompiler->addError(CE_STRINGEXPECTED, node->file, node->line); 1282| 0| return; 1283| 0| } 1284| | 1285| 21.2k| ImportAbstractNode *impl = OGRE_NEW ImportAbstractNode(); 1286| 21.2k| impl->line = node->line; 1287| 21.2k| impl->file = node->file; 1288| | 1289| 21.2k| ConcreteNodeList::iterator iter = node->children.begin(); 1290| 21.2k| impl->target = (*iter)->token; 1291| | 1292| 21.2k| iter++; 1293| 21.2k| impl->source = (*iter)->token; 1294| | 1295| 21.2k| asn = AbstractNodePtr(impl); 1296| 21.2k| } 1297| | // variable set = "set" >> 2 children, children[0] == variable 1298| 743k| else if(node->type == CNT_VARIABLE_ASSIGN) ------------------ | Branch (1298:17): [True: 12.5k, False: 731k] ------------------ 1299| 12.5k| { 1300| 12.5k| if(node->children.size() > 2) ------------------ | Branch (1300:16): [True: 0, False: 12.5k] ------------------ 1301| 0| { 1302| 0| mCompiler->addError(CE_FEWERPARAMETERSEXPECTED, node->file, node->line); 1303| 0| return; 1304| 0| } 1305| 12.5k| if(node->children.size() < 2) ------------------ | Branch (1305:16): [True: 0, False: 12.5k] ------------------ 1306| 0| { 1307| 0| mCompiler->addError(CE_STRINGEXPECTED, node->file, node->line); 1308| 0| return; 1309| 0| } 1310| 12.5k| if(node->children.front()->type != CNT_VARIABLE) ------------------ | Branch (1310:16): [True: 0, False: 12.5k] ------------------ 1311| 0| { 1312| 0| mCompiler->addError(CE_VARIABLEEXPECTED, node->children.front()->file, node->children.front()->line); 1313| 0| return; 1314| 0| } 1315| | 1316| 12.5k| ConcreteNodeList::iterator i = node->children.begin(); 1317| 12.5k| String name = (*i)->token; 1318| | 1319| 12.5k| ++i; 1320| 12.5k| String value = (*i)->token; 1321| | 1322| 12.5k| if(mCurrent && mCurrent->type == ANT_OBJECT) ------------------ | Branch (1322:16): [True: 11.1k, False: 1.39k] | Branch (1322:28): [True: 8.30k, False: 2.81k] ------------------ 1323| 8.30k| { 1324| 8.30k| ObjectAbstractNode *ptr = (ObjectAbstractNode*)mCurrent; 1325| 8.30k| ptr->setVariable(name, value); 1326| 8.30k| } 1327| 4.21k| else 1328| 4.21k| { 1329| 4.21k| mCompiler->mEnv.insert(std::make_pair(name, value)); 1330| 4.21k| } 1331| 12.5k| } 1332| | // variable = $*, no children 1333| 731k| else if(node->type == CNT_VARIABLE) ------------------ | Branch (1333:17): [True: 12.9k, False: 718k] ------------------ 1334| 12.9k| { 1335| 12.9k| if(!node->children.empty()) ------------------ | Branch (1335:16): [True: 0, False: 12.9k] ------------------ 1336| 0| { 1337| 0| mCompiler->addError(CE_FEWERPARAMETERSEXPECTED, node->file, node->line); 1338| 0| return; 1339| 0| } 1340| | 1341| 12.9k| VariableAccessAbstractNode *impl = OGRE_NEW VariableAccessAbstractNode(mCurrent); 1342| 12.9k| impl->line = node->line; 1343| 12.9k| impl->file = node->file; 1344| 12.9k| impl->name = node->token; 1345| | 1346| 12.9k| asn = AbstractNodePtr(impl); 1347| 12.9k| } 1348| | // Handle properties and objects here 1349| 718k| else if(!node->children.empty()) ------------------ | Branch (1349:17): [True: 362k, False: 356k] ------------------ 1350| 362k| { 1351| | // Grab the last two nodes 1352| 362k| ConcreteNodePtr temp1, temp2; 1353| 362k| ConcreteNodeList::reverse_iterator riter = node->children.rbegin(); 1354| 362k| if(riter != node->children.rend()) ------------------ | Branch (1354:16): [True: 362k, False: 0] ------------------ 1355| 362k| { 1356| 362k| temp1 = *riter; 1357| 362k| riter++; 1358| 362k| } 1359| 362k| if(riter != node->children.rend()) ------------------ | Branch (1359:16): [True: 185k, False: 176k] ------------------ 1360| 185k| temp2 = *riter; 1361| | 1362| | // object = last 2 children == { and } 1363| 362k| if(temp1 && temp2 && ------------------ | Branch (1363:16): [True: 362k, False: 0] | Branch (1363:25): [True: 185k, False: 176k] ------------------ 1364| 185k| temp1->type == CNT_RBRACE && temp2->type == CNT_LBRACE) ------------------ | Branch (1364:17): [True: 120k, False: 65.7k] | Branch (1364:46): [True: 120k, False: 0] ------------------ 1365| 120k| { 1366| 120k| if(node->children.size() < 2) ------------------ | Branch (1366:20): [True: 0, False: 120k] ------------------ 1367| 0| { 1368| 0| mCompiler->addError(CE_STRINGEXPECTED, node->file, node->line); 1369| 0| return; 1370| 0| } 1371| | 1372| 120k| ObjectAbstractNode *impl = OGRE_NEW ObjectAbstractNode(mCurrent); 1373| 120k| impl->line = node->line; 1374| 120k| impl->file = node->file; 1375| 120k| impl->abstract = false; 1376| | 1377| | // Create a temporary detail list 1378| 120k| std::list temp; 1379| 120k| if(node->token == "abstract") ------------------ | Branch (1379:20): [True: 323, False: 119k] ------------------ 1380| 323| { 1381| 323| impl->abstract = true; 1382| 323| for(const auto& c : node->children) ------------------ | Branch (1382:39): [True: 1.70k, False: 323] ------------------ 1383| 1.70k| temp.push_back(c.get()); 1384| 323| } 1385| 119k| else 1386| 119k| { 1387| 119k| temp.push_back(node); 1388| 119k| for(const auto& c : node->children) ------------------ | Branch (1388:39): [True: 333k, False: 119k] ------------------ 1389| 333k| temp.push_back(c.get()); 1390| 119k| } 1391| | 1392| | // Get the type of object 1393| 120k| std::list::const_iterator iter = temp.begin(); 1394| 120k| impl->cls = (*iter)->token; 1395| 120k| ++iter; 1396| | 1397| | // try to map the cls to an id 1398| 120k| ScriptCompiler::IdMap::const_iterator iter2 = mCompiler->mIds.find(impl->cls); 1399| 120k| if(iter2 != mCompiler->mIds.end()) ------------------ | Branch (1399:20): [True: 97.2k, False: 22.9k] ------------------ 1400| 97.2k| { 1401| 97.2k| impl->id = iter2->second; 1402| 97.2k| } 1403| 22.9k| else 1404| 22.9k| { 1405| 22.9k| mCompiler->addError(CE_UNEXPECTEDTOKEN, impl->file, impl->line, 1406| 22.9k| "'" + impl->cls + "'. If this is a legacy script you must prepend the type (e.g. font, overlay)."); 1407| 22.9k| } 1408| | 1409| | // Get the name 1410| | // Unless the type is in the exclusion list 1411| 120k| if(iter != temp.end() && ((*iter)->type == CNT_WORD || (*iter)->type == CNT_QUOTE || (*iter)->type == CNT_VARIABLE) && ------------------ | Branch (1411:20): [True: 120k, False: 0] | Branch (1411:20): [True: 58.2k, False: 61.9k] | Branch (1411:43): [True: 61.4k, False: 58.6k] | Branch (1411:72): [True: 780, False: 57.8k] | Branch (1411:102): [True: 126, False: 57.7k] ------------------ 1412| 62.3k| !mCompiler->isNameExcluded(*impl, mCurrent)) ------------------ | Branch (1412:21): [True: 58.2k, False: 4.15k] ------------------ 1413| 58.2k| { 1414| 58.2k| impl->name = (*iter)->token; 1415| 58.2k| ++iter; 1416| 58.2k| } 1417| | 1418| | // Everything up until the colon is a "value" of this object 1419| 147k| while(iter != temp.end() && (*iter)->type != CNT_COLON && (*iter)->type != CNT_LBRACE) ------------------ | Branch (1419:23): [True: 147k, False: 40] | Branch (1419:23): [True: 27.4k, False: 120k] | Branch (1419:45): [True: 140k, False: 7.14k] | Branch (1419:75): [True: 27.4k, False: 112k] ------------------ 1420| 27.4k| { 1421| 27.4k| if((*iter)->type == CNT_VARIABLE) ------------------ | Branch (1421:24): [True: 1.47k, False: 25.9k] ------------------ 1422| 1.47k| { 1423| 1.47k| VariableAccessAbstractNode *var = OGRE_NEW VariableAccessAbstractNode(impl); 1424| 1.47k| var->file = (*iter)->file; 1425| 1.47k| var->line = (*iter)->line; 1426| 1.47k| var->type = ANT_VARIABLE_ACCESS; 1427| 1.47k| var->name = (*iter)->token; 1428| 1.47k| impl->values.push_back(AbstractNodePtr(var)); 1429| 1.47k| } 1430| 25.9k| else 1431| 25.9k| { 1432| 25.9k| AtomAbstractNode *atom = OGRE_NEW AtomAbstractNode(impl); 1433| 25.9k| atom->file = (*iter)->file; 1434| 25.9k| atom->line = (*iter)->line; 1435| 25.9k| atom->type = ANT_ATOM; 1436| 25.9k| atom->value = (*iter)->token; 1437| | 1438| 25.9k| auto idpos = mCompiler->mIds.find(atom->value); 1439| 25.9k| if(idpos != mCompiler->mIds.end()) ------------------ | Branch (1439:28): [True: 4.85k, False: 21.0k] ------------------ 1440| 4.85k| atom->id = idpos->second; 1441| | 1442| 25.9k| impl->values.push_back(AbstractNodePtr(atom)); 1443| 25.9k| } 1444| 27.4k| ++iter; 1445| 27.4k| } 1446| | 1447| | // Find the bases 1448| 120k| if(iter != temp.end() && (*iter)->type == CNT_COLON) ------------------ | Branch (1448:20): [True: 120k, False: 40] | Branch (1448:20): [True: 7.14k, False: 112k] | Branch (1448:42): [True: 7.14k, False: 112k] ------------------ 1449| 7.14k| { 1450| | // Children of the ':' are bases 1451| 7.14k| for(auto & j : (*iter)->children) ------------------ | Branch (1451:34): [True: 10.5k, False: 7.14k] ------------------ 1452| 10.5k| impl->bases.push_back(j->token); 1453| 7.14k| ++iter; 1454| 7.14k| } 1455| | 1456| 120k| asn = AbstractNodePtr(impl); 1457| 120k| mCurrent = impl; 1458| | 1459| | // Visit the children of the { 1460| 120k| AbstractTreeBuilder::visit(this, temp2->children); 1461| | 1462| | // Go back up the stack 1463| 120k| mCurrent = impl->parent; 1464| 120k| } 1465| | // Otherwise, it is a property 1466| 242k| else 1467| 242k| { 1468| 242k| PropertyAbstractNode *impl = OGRE_NEW PropertyAbstractNode(mCurrent); 1469| 242k| impl->line = node->line; 1470| 242k| impl->file = node->file; 1471| 242k| impl->name = node->token; 1472| | 1473| 242k| ScriptCompiler::IdMap::const_iterator iter2 = mCompiler->mIds.find(impl->name); 1474| 242k| if(iter2 != mCompiler->mIds.end()) ------------------ | Branch (1474:20): [True: 110k, False: 131k] ------------------ 1475| 110k| impl->id = iter2->second; 1476| | 1477| 242k| asn = AbstractNodePtr(impl); 1478| 242k| mCurrent = impl; 1479| | 1480| | // Visit the children of the { 1481| 242k| AbstractTreeBuilder::visit(this, node->children); 1482| | 1483| | // Go back up the stack 1484| 242k| mCurrent = impl->parent; 1485| 242k| } 1486| 362k| } 1487| | // Otherwise, it is a standard atom 1488| 356k| else 1489| 356k| { 1490| 356k| AtomAbstractNode *impl = OGRE_NEW AtomAbstractNode(mCurrent); 1491| 356k| impl->line = node->line; 1492| 356k| impl->file = node->file; 1493| 356k| impl->value = node->token; 1494| | 1495| 356k| ScriptCompiler::IdMap::const_iterator iter2 = mCompiler->mIds.find(impl->value); 1496| 356k| if(iter2 != mCompiler->mIds.end()) ------------------ | Branch (1496:16): [True: 79.1k, False: 276k] ------------------ 1497| 79.1k| impl->id = iter2->second; 1498| | 1499| 356k| asn = AbstractNodePtr(impl); 1500| | 1501| 356k| if(mCurrent && mCurrent->type != ANT_PROPERTY) ------------------ | Branch (1501:16): [True: 333k, False: 23.0k] | Branch (1501:28): [True: 22.7k, False: 310k] ------------------ 1502| 22.7k| { 1503| | // stray atom outside of a property is likely a property without a value 1504| 22.7k| mCompiler->addError(*impl, "missing property value"); 1505| 22.7k| } 1506| 356k| } 1507| | 1508| | // Here, we must insert the node into the tree 1509| 765k| if(asn) ------------------ | Branch (1509:12): [True: 752k, False: 12.5k] ------------------ 1510| 752k| { 1511| 752k| if(mCurrent) ------------------ | Branch (1511:16): [True: 674k, False: 78.3k] ------------------ 1512| 674k| { 1513| 674k| if(mCurrent->type == ANT_PROPERTY) ------------------ | Branch (1513:20): [True: 421k, False: 253k] ------------------ 1514| 421k| { 1515| 421k| PropertyAbstractNode *impl = static_cast(mCurrent); 1516| 421k| impl->values.push_back(asn); 1517| 421k| } 1518| 253k| else 1519| 253k| { 1520| 253k| ObjectAbstractNode *impl = static_cast(mCurrent); 1521| 253k| impl->children.push_back(asn); 1522| 253k| } 1523| 674k| } 1524| 78.3k| else 1525| 78.3k| { 1526| 78.3k| mNodes->push_back(asn); 1527| 78.3k| } 1528| 752k| } 1529| 765k| } _ZN4Ogre14ScriptCompiler19AbstractTreeBuilder5visitEPS1_RKNSt3__14listINS_9SharedPtrINS_12ConcreteNodeEEENS3_9allocatorIS7_EEEE: 1532| 399k| { 1533| 399k| for(const auto & node : nodes) ------------------ | Branch (1533:31): [True: 765k, False: 399k] ------------------ 1534| 765k| visitor->visit(node.get()); 1535| 399k| } _ZN4Ogre21ScriptCompilerManager12getSingletonEv: 1547| 114k| { 1548| | assert( msSingleton ); return ( *msSingleton ); 1549| 114k| } _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| 107k| { 1608| 107k| ScriptTranslator *translator = 0; 1609| 107k| { 1610| 107k| OGRE_LOCK_AUTO_MUTEX; 1611| | 1612| | // Start looking from the back 1613| 148k| for(std::vector::reverse_iterator i = mManagers.rbegin(); i != mManagers.rend(); ++i) ------------------ | Branch (1613:97): [True: 107k, False: 40.9k] ------------------ 1614| 107k| { 1615| 107k| translator = (*i)->getTranslator(node); 1616| 107k| if(translator != 0) ------------------ | Branch (1616:20): [True: 66.6k, False: 40.9k] ------------------ 1617| 66.6k| break; 1618| 107k| } 1619| 107k| } 1620| 107k| return translator; 1621| 107k| } _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| 7.20k| { 1646| 7.20k| ConcreteNodeListPtr nodes = 1647| 7.20k| ScriptParser::parse(ScriptLexer::tokenize(stream->getAsString(), stream->getName()), stream->getName()); 1648| 7.20k| { 1649| | // compile is not reentrant 1650| 7.20k| OGRE_LOCK_AUTO_MUTEX; 1651| 7.20k| mScriptCompiler.compile(nodes, groupName); 1652| 7.20k| } 1653| 7.20k| } _ZN4Ogre11ScriptLexer8tokenizeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 35| 16.0k| { 36| 16.0k| String error; 37| 16.0k| ScriptTokenList ret = _tokenize(str, source.c_str(), error); 38| | 39| 16.0k| if (!error.empty()) ------------------ | Branch (39:13): [True: 4.66k, False: 11.3k] ------------------ 40| 4.66k| LogManager::getSingleton().logError("ScriptLexer - " + error); 41| | 42| 16.0k| return ret; 43| 16.0k| } _ZN4Ogre11ScriptLexer9_tokenizeERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPKcRS7_: 46| 16.0k| { 47| | // State enums 48| 16.0k| enum{ READY = 0, COMMENT, MULTICOMMENT, WORD, QUOTE, VAR, POSSIBLECOMMENT }; 49| | 50| | // Set up some constant characters of interest 51| 16.0k| const wchar_t varopener = '$', quote = '\"', slash = '/', backslash = '\\', openbrace = '{', closebrace = '}', colon = ':', star = '*', cr = '\r', lf = '\n'; 52| 16.0k| char c = 0, lastc = 0; 53| | 54| 16.0k| String lexeme; 55| 16.0k| uint32 line = 1, state = READY, lastQuote = 0, firstOpenBrace = 0, braceLayer = 0; 56| 16.0k| ScriptTokenList tokens; 57| | 58| | // Iterate over the input 59| 16.0k| for(char i : str) ------------------ | Branch (59:20): [True: 18.5M, False: 13.8k] ------------------ 60| 18.5M| { 61| 18.5M| lastc = c; 62| 18.5M| c = i; 63| | 64| 18.5M| if(c == quote) ------------------ | Branch (64:16): [True: 182k, False: 18.3M] ------------------ 65| 182k| lastQuote = line; 66| | 67| 18.5M| if(state == READY || state == WORD || state == VAR) ------------------ | Branch (67:16): [True: 3.41M, False: 15.1M] | Branch (67:34): [True: 11.8M, False: 3.33M] | Branch (67:51): [True: 735k, False: 2.59M] ------------------ 68| 15.9M| { 69| 15.9M| if(c == openbrace) ------------------ | Branch (69:20): [True: 173k, False: 15.7M] ------------------ 70| 173k| { 71| 173k| if(braceLayer == 0) ------------------ | Branch (71:24): [True: 38.2k, False: 135k] ------------------ 72| 38.2k| firstOpenBrace = line; 73| | 74| 173k| if (braceLayer >= MAX_BRACE_LAYER) ------------------ | Branch (74:25): [True: 120, False: 173k] ------------------ 75| 120| { 76| 120| error = StringUtil::format("too deeply nested open brackets '{' (max %u) at %s:%d", 77| 120| MAX_BRACE_LAYER, source, line); 78| 120| return tokens; 79| 120| } 80| | 81| 173k| braceLayer ++; 82| 173k| } 83| 15.7M| else if(c == closebrace) ------------------ | Branch (83:25): [True: 163k, False: 15.6M] ------------------ 84| 163k| { 85| 163k| if (braceLayer == 0) ------------------ | Branch (85:25): [True: 2.11k, False: 161k] ------------------ 86| 2.11k| { 87| 2.11k| error = StringUtil::format( 88| 2.11k| "no matching open bracket '{' found for close bracket '}' at %s:%d", source, 89| 2.11k| line); 90| 2.11k| return tokens; 91| 2.11k| } 92| | 93| 161k| braceLayer --; 94| 161k| } 95| 15.9M| } 96| | 97| | 98| 18.5M| switch(state) ------------------ | Branch (98:20): [True: 18.5M, False: 0] ------------------ 99| 18.5M| { 100| 3.40M| case READY: ------------------ | Branch (100:13): [True: 3.40M, False: 15.1M] ------------------ 101| 3.40M| if(c == slash && lastc == slash) ------------------ | Branch (101:20): [True: 32.5k, False: 3.37M] | Branch (101:34): [True: 46, False: 32.5k] ------------------ 102| 46| { 103| | // Comment start, clear out the lexeme 104| 46| lexeme = ""; 105| 46| state = COMMENT; 106| 46| } 107| 3.40M| else if(c == star && lastc == slash) ------------------ | Branch (107:25): [True: 20.3k, False: 3.38M] | Branch (107:38): [True: 21, False: 20.3k] ------------------ 108| 21| { 109| 21| lexeme = ""; 110| 21| state = MULTICOMMENT; 111| 21| } 112| 3.40M| else if(c == quote) ------------------ | Branch (112:25): [True: 61.4k, False: 3.34M] ------------------ 113| 61.4k| { 114| | // Clear out the lexeme ready to be filled with quotes! 115| 61.4k| lexeme = c; 116| 61.4k| state = QUOTE; 117| 61.4k| } 118| 3.34M| else if(c == varopener) ------------------ | Branch (118:25): [True: 28.9k, False: 3.31M] ------------------ 119| 28.9k| { 120| | // Set up to read in a variable 121| 28.9k| lexeme = c; 122| 28.9k| state = VAR; 123| 28.9k| } 124| 3.31M| else if(isNewline(c)) ------------------ | Branch (124:25): [True: 98.2k, False: 3.21M] ------------------ 125| 98.2k| { 126| 98.2k| lexeme = c; 127| 98.2k| setToken(lexeme, line, tokens); 128| 98.2k| } 129| 3.21M| else if(!isWhitespace(c)) ------------------ | Branch (129:25): [True: 1.11M, False: 2.10M] ------------------ 130| 1.11M| { 131| 1.11M| lexeme = c; 132| 1.11M| if(c == slash) ------------------ | Branch (132:24): [True: 32.5k, False: 1.08M] ------------------ 133| 32.5k| state = POSSIBLECOMMENT; 134| 1.08M| else 135| 1.08M| state = WORD; 136| 1.11M| } 137| 3.40M| break; 138| 1.20M| case COMMENT: ------------------ | Branch (138:13): [True: 1.20M, False: 17.3M] ------------------ 139| 1.20M| if(isNewline(c)) ------------------ | Branch (139:20): [True: 30.4k, False: 1.17M] ------------------ 140| 30.4k| { 141| 30.4k| lexeme = c; 142| 30.4k| setToken(lexeme, line, tokens); 143| 30.4k| state = READY; 144| 30.4k| } 145| 1.20M| break; 146| 21.9k| case MULTICOMMENT: ------------------ | Branch (146:13): [True: 21.9k, False: 18.5M] ------------------ 147| 21.9k| if(c == slash && lastc == star) ------------------ | Branch (147:20): [True: 678, False: 21.2k] | Branch (147:34): [True: 161, False: 517] ------------------ 148| 161| state = READY; 149| 21.9k| break; 150| 32.5k| case POSSIBLECOMMENT: ------------------ | Branch (150:13): [True: 32.5k, False: 18.5M] ------------------ 151| 32.5k| if(c == slash && lastc == slash) ------------------ | Branch (151:20): [True: 30.4k, False: 2.07k] | Branch (151:34): [True: 30.4k, False: 0] ------------------ 152| 30.4k| { 153| 30.4k| lexeme = ""; 154| 30.4k| state = COMMENT; 155| 30.4k| break; 156| 30.4k| } 157| 2.07k| else if(c == star && lastc == slash) ------------------ | Branch (157:25): [True: 175, False: 1.89k] | Branch (157:38): [True: 175, False: 0] ------------------ 158| 175| { 159| 175| lexeme = ""; 160| 175| state = MULTICOMMENT; 161| 175| break; 162| 175| } 163| 1.89k| else 164| 1.89k| { 165| 1.89k| state = WORD; 166| 1.89k| OGRE_FALLTHROUGH; 167| 1.89k| } 168| 11.8M| case WORD: ------------------ | Branch (168:13): [True: 11.8M, False: 6.74M] ------------------ 169| 11.8M| if(isNewline(c)) ------------------ | Branch (169:20): [True: 490k, False: 11.3M] ------------------ 170| 490k| { 171| 490k| setToken(lexeme, line, tokens); 172| 490k| lexeme = c; 173| 490k| setToken(lexeme, line, tokens); 174| 490k| state = READY; 175| 490k| } 176| 11.3M| else if(isWhitespace(c)) ------------------ | Branch (176:25): [True: 511k, False: 10.8M] ------------------ 177| 511k| { 178| 511k| setToken(lexeme, line, tokens); 179| 511k| state = READY; 180| 511k| } 181| 10.8M| else if(c == openbrace || c == closebrace || c == colon) ------------------ | Branch (181:25): [True: 46.2k, False: 10.7M] | Branch (181:43): [True: 14.6k, False: 10.7M] | Branch (181:62): [True: 8.74k, False: 10.7M] ------------------ 182| 69.6k| { 183| 69.6k| setToken(lexeme, line, tokens); 184| 69.6k| lexeme = c; 185| 69.6k| setToken(lexeme, line, tokens); 186| 69.6k| state = READY; 187| 69.6k| } 188| 10.7M| else 189| 10.7M| { 190| 10.7M| lexeme += c; 191| 10.7M| } 192| 11.8M| break; 193| 1.33M| case QUOTE: ------------------ | Branch (193:13): [True: 1.33M, False: 17.2M] ------------------ 194| 1.33M| if(c != backslash) ------------------ | Branch (194:20): [True: 1.33M, False: 2.76k] ------------------ 195| 1.33M| { 196| | // Allow embedded quotes with escaping 197| 1.33M| if(c == quote && lastc == backslash) ------------------ | Branch (197:24): [True: 61.2k, False: 1.27M] | Branch (197:38): [True: 74, False: 61.1k] ------------------ 198| 74| { 199| 74| lexeme += c; 200| 74| } 201| 1.33M| else if(c == quote) ------------------ | Branch (201:29): [True: 61.1k, False: 1.27M] ------------------ 202| 61.1k| { 203| 61.1k| lexeme += c; 204| 61.1k| setToken(lexeme, line, tokens); 205| 61.1k| state = READY; 206| 61.1k| } 207| 1.27M| else 208| 1.27M| { 209| | // Backtrack here and allow a backslash normally within the quote 210| 1.27M| if(lastc == backslash) ------------------ | Branch (210:28): [True: 2.06k, False: 1.26M] ------------------ 211| 2.06k| lexeme = lexeme + "\\" + c; 212| 1.26M| else 213| 1.26M| lexeme += c; 214| 1.27M| } 215| 1.33M| } 216| 1.33M| break; 217| 735k| case VAR: ------------------ | Branch (217:13): [True: 735k, False: 17.8M] ------------------ 218| 735k| if(isNewline(c)) ------------------ | Branch (218:20): [True: 2.63k, False: 732k] ------------------ 219| 2.63k| { 220| 2.63k| setToken(lexeme, line, tokens); 221| 2.63k| lexeme = c; 222| 2.63k| setToken(lexeme, line, tokens); 223| 2.63k| state = READY; 224| 2.63k| } 225| 732k| else if(isWhitespace(c)) ------------------ | Branch (225:25): [True: 24.7k, False: 708k] ------------------ 226| 24.7k| { 227| 24.7k| setToken(lexeme, line, tokens); 228| 24.7k| state = READY; 229| 24.7k| } 230| 708k| else if(c == openbrace || c == closebrace || c == colon) ------------------ | Branch (230:25): [True: 109, False: 708k] | Branch (230:43): [True: 62, False: 708k] | Branch (230:62): [True: 1.22k, False: 706k] ------------------ 231| 1.39k| { 232| 1.39k| setToken(lexeme, line, tokens); 233| 1.39k| lexeme = c; 234| 1.39k| setToken(lexeme, line, tokens); 235| 1.39k| state = READY; 236| 1.39k| } 237| 706k| else 238| 706k| { 239| 706k| lexeme += c; 240| 706k| } 241| 735k| break; 242| 18.5M| } 243| | 244| | // Separate check for newlines just to track line numbers 245| 18.5M| if(c == cr || (c == lf && lastc != cr)) ------------------ | Branch (245:16): [True: 3.78k, False: 18.5M] | Branch (245:28): [True: 657k, False: 17.8M] | Branch (245:39): [True: 657k, False: 531] ------------------ 246| 660k| line++; 247| 18.5M| } 248| | 249| | // Check for valid exit states 250| 13.8k| if(state == WORD || state == VAR) ------------------ | Branch (250:12): [True: 11.1k, False: 2.65k] | Branch (250:29): [True: 194, False: 2.46k] ------------------ 251| 11.3k| { 252| 11.3k| if(!lexeme.empty()) ------------------ | Branch (252:16): [True: 11.3k, False: 0] ------------------ 253| 11.3k| setToken(lexeme, line, tokens); 254| 11.3k| } 255| 2.46k| else 256| 2.46k| { 257| 2.46k| if(state == QUOTE) ------------------ | Branch (257:16): [True: 315, False: 2.14k] ------------------ 258| 315| { 259| 315| error = StringUtil::format("no matching \" found for \" at %s:%d", source, lastQuote); 260| 315| return tokens; 261| 315| } 262| 2.46k| } 263| | 264| | // Check that all opened brackets have been closed 265| 13.5k| if (braceLayer == 1) ------------------ | Branch (265:13): [True: 900, False: 12.6k] ------------------ 266| 900| { 267| 900| error = StringUtil::format("no matching closing bracket '}' for open bracket '{' at %s:%d", 268| 900| source, firstOpenBrace); 269| 900| } 270| 12.6k| else if (braceLayer > 1) ------------------ | Branch (270:18): [True: 1.21k, False: 11.3k] ------------------ 271| 1.21k| { 272| 1.21k| error = StringUtil::format( 273| 1.21k| "too many open brackets (%d) '{' without matching closing bracket '}' in %s", braceLayer, 274| 1.21k| source); 275| 1.21k| } 276| | 277| 13.5k| return tokens; 278| 13.8k| } _ZN4Ogre11ScriptLexer8setTokenERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEjRNS1_6vectorINS_11ScriptTokenENS5_ISB_EEEE: 281| 1.86M| { 282| 1.86M| const char openBracket = '{', closeBracket = '}', colon = ':', 283| 1.86M| quote = '\"', var = '$'; 284| | 285| 1.86M| ScriptToken token; 286| 1.86M| token.line = line; 287| 1.86M| bool ignore = false; 288| | 289| | // Check the user token map first 290| 1.86M| if(lexeme.size() == 1 && isNewline(lexeme[0])) ------------------ | Branch (290:12): [True: 1.01M, False: 847k] | Branch (290:34): [True: 621k, False: 396k] ------------------ 291| 621k| { 292| 621k| token.type = TID_NEWLINE; 293| 621k| if(!tokens.empty() && tokens.back().type == TID_NEWLINE) ------------------ | Branch (293:16): [True: 619k, False: 2.16k] | Branch (293:35): [True: 89.1k, False: 530k] ------------------ 294| 89.1k| ignore = true; 295| 621k| } 296| 1.24M| else if(lexeme.size() == 1 && lexeme[0] == openBracket) ------------------ | Branch (296:17): [True: 396k, False: 847k] | Branch (296:39): [True: 170k, False: 226k] ------------------ 297| 170k| token.type = TID_LBRACKET; 298| 1.07M| else if(lexeme.size() == 1 && lexeme[0] == closeBracket) ------------------ | Branch (298:17): [True: 226k, False: 847k] | Branch (298:39): [True: 124k, False: 101k] ------------------ 299| 124k| token.type = TID_RBRACKET; 300| 949k| else if(lexeme.size() == 1 && lexeme[0] == colon) ------------------ | Branch (300:17): [True: 101k, False: 847k] | Branch (300:39): [True: 18.3k, False: 83.4k] ------------------ 301| 18.3k| token.type = TID_COLON; 302| 931k| else 303| 931k| { 304| 931k| token.lexeme = lexeme; 305| | 306| | // This is either a non-zero length phrase or quoted phrase 307| 931k| if(lexeme.size() >= 2 && lexeme[0] == quote && lexeme[lexeme.size() - 1] == quote) ------------------ | Branch (307:16): [True: 847k, False: 83.4k] | Branch (307:38): [True: 61.1k, False: 786k] | Branch (307:60): [True: 61.1k, False: 0] ------------------ 308| 61.1k| { 309| 61.1k| token.type = TID_QUOTE; 310| 61.1k| } 311| 869k| else if(lexeme.size() > 1 && lexeme[0] == var) ------------------ | Branch (311:21): [True: 786k, False: 83.4k] | Branch (311:42): [True: 28.4k, False: 757k] ------------------ 312| 28.4k| token.type = TID_VARIABLE; 313| 841k| else 314| 841k| { 315| 841k| token.type = TID_WORD; 316| 841k| } 317| 931k| } 318| | 319| 1.86M| if(!ignore) ------------------ | Branch (319:12): [True: 1.77M, False: 89.1k] ------------------ 320| 1.77M| tokens.push_back(token); 321| 1.86M| } _ZN4Ogre11ScriptLexer12isWhitespaceEc: 324| 15.2M| { 325| 15.2M| return c == ' ' || c == '\r' || c == '\t'; ------------------ | Branch (325:16): [True: 1.89M, False: 13.3M] | Branch (325:28): [True: 0, False: 13.3M] | Branch (325:41): [True: 752k, False: 12.6M] ------------------ 326| 15.2M| } _ZN4Ogre11ScriptLexer9isNewlineEc: 329| 18.0M| { 330| 18.0M| return c == '\n' || c == '\r'; ------------------ | Branch (330:16): [True: 1.23M, False: 16.8M] | Branch (330:29): [True: 7.31k, False: 16.8M] ------------------ 331| 18.0M| } _ZN4Ogre12ScriptParser5parseERKNSt3__16vectorINS_11ScriptTokenENS1_9allocatorIS3_EEEERKNS1_12basic_stringIcNS1_11char_traitsIcEENS4_IcEEEE: 42| 7.20k| { 43| 7.20k| auto nodes = std::make_shared(); 44| | 45| 7.20k| enum{READY, OBJECT}; 46| 7.20k| uint32 state = READY; 47| | 48| 7.20k| ConcreteNode *parent = 0; 49| 7.20k| ConcreteNodePtr node; 50| 7.20k| const ScriptToken *token = 0; 51| 7.20k| ScriptTokenList::const_iterator i = tokens.begin(), end = tokens.end(); 52| 1.64M| while(i != end) ------------------ | Branch (52:15): [True: 1.64M, False: 7.10k] ------------------ 53| 1.64M| { 54| 1.64M| token = &*i; 55| | 56| 1.64M| switch(state) ------------------ | Branch (56:20): [True: 1.64M, False: 0] ------------------ 57| 1.64M| { 58| 785k| case READY: ------------------ | Branch (58:13): [True: 785k, False: 855k] ------------------ 59| 785k| if(token->type == TID_WORD) ------------------ | Branch (59:20): [True: 381k, False: 404k] ------------------ 60| 381k| { 61| 381k| if(token->lexeme == "import") ------------------ | Branch (61:24): [True: 23.3k, False: 358k] ------------------ 62| 23.3k| { 63| 23.3k| node = std::make_shared(); 64| 23.3k| node->token = token->lexeme; 65| 23.3k| node->file = file; 66| 23.3k| node->line = token->line; 67| 23.3k| node->type = CNT_IMPORT; 68| | 69| | // The next token is the target 70| 23.3k| ++i; 71| 23.3k| if(i == end || (i->type != TID_WORD && i->type != TID_QUOTE)) ------------------ | Branch (71:28): [True: 2, False: 23.3k] | Branch (71:41): [True: 5, False: 23.3k] | Branch (71:64): [True: 4, False: 1] ------------------ 72| 23.3k| OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 73| 23.3k| Ogre::String("expected import target at line ") + 74| 23.3k| Ogre::StringConverter::toString(node->line), 75| 23.3k| "ScriptParser::parse"); 76| 23.3k| ConcreteNodePtr temp(OGRE_NEW ConcreteNode()); 77| 23.3k| temp->parent = node.get(); 78| 23.3k| temp->file = file; 79| 23.3k| temp->line = i->line; 80| 23.3k| temp->type = i->type == TID_WORD ? CNT_WORD : CNT_QUOTE; ------------------ | Branch (80:38): [True: 23.3k, False: 1] ------------------ 81| 23.3k| temp->token = unquoted(i->lexeme, temp->type == CNT_QUOTE); 82| 23.3k| node->children.push_back(temp); 83| | 84| | // The next token must be "from" 85| 23.3k| ++i; 86| 23.3k| if (i == end || i->type != TID_WORD || i->lexeme != "from") ------------------ | Branch (86:29): [True: 6, False: 23.3k] | Branch (86:41): [True: 2, False: 23.3k] | Branch (86:64): [True: 25, False: 23.3k] ------------------ 87| 23.3k| OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 88| 23.3k| StringUtil::format("expected 'from' at line %d", node->line)); 89| | // The token after "from" is the source 90| 23.3k| ++i; 91| 23.3k| if(i == end || (i->type != TID_WORD && i->type != TID_QUOTE)) ------------------ | Branch (91:28): [True: 3, False: 23.3k] | Branch (91:41): [True: 21.6k, False: 1.69k] | Branch (91:64): [True: 4, False: 21.6k] ------------------ 92| 23.3k| OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 93| 23.3k| Ogre::String("expected import source at line ") + 94| 23.3k| Ogre::StringConverter::toString(node->line), 95| 23.3k| "ScriptParser::parse"); 96| 23.3k| temp = std::make_shared(); 97| 23.3k| temp->parent = node.get(); 98| 23.3k| temp->file = file; 99| 23.3k| temp->line = i->line; 100| 23.3k| temp->type = i->type == TID_WORD ? CNT_WORD : CNT_QUOTE; ------------------ | Branch (100:38): [True: 1.69k, False: 21.6k] ------------------ 101| 23.3k| temp->token = unquoted(i->lexeme, temp->type == CNT_QUOTE); 102| 23.3k| node->children.push_back(temp); 103| | 104| | // Consume all the newlines 105| 23.3k| i = skipNewlines(i, end); 106| | 107| | // Insert the node 108| 23.3k| if(parent) ------------------ | Branch (108:28): [True: 1.96k, False: 21.3k] ------------------ 109| 1.96k| { 110| 1.96k| node->parent = parent; 111| 1.96k| parent->children.push_back(node); 112| 1.96k| } 113| 21.3k| else 114| 21.3k| { 115| 21.3k| node->parent = 0; 116| 21.3k| nodes->push_back(node); 117| 21.3k| } 118| 23.3k| node = ConcreteNodePtr(); 119| 23.3k| } 120| 358k| else if(token->lexeme == "set") ------------------ | Branch (120:29): [True: 12.5k, False: 345k] ------------------ 121| 12.5k| { 122| 12.5k| node = std::make_shared(); 123| 12.5k| node->token = token->lexeme; 124| 12.5k| node->file = file; 125| 12.5k| node->line = token->line; 126| 12.5k| node->type = CNT_VARIABLE_ASSIGN; 127| | 128| | // The next token is the variable 129| 12.5k| ++i; 130| 12.5k| if(i == end || i->type != TID_VARIABLE) ------------------ | Branch (130:28): [True: 4, False: 12.5k] | Branch (130:40): [True: 3, False: 12.5k] ------------------ 131| 12.5k| OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 132| 12.5k| Ogre::String("expected variable name at line ") + 133| 12.5k| Ogre::StringConverter::toString(node->line), 134| 12.5k| "ScriptParser::parse"); 135| 12.5k| ConcreteNodePtr temp(OGRE_NEW ConcreteNode()); 136| 12.5k| temp->parent = node.get(); 137| 12.5k| temp->file = file; 138| 12.5k| temp->line = i->line; 139| 12.5k| temp->type = CNT_VARIABLE; 140| 12.5k| temp->token = i->lexeme; 141| 12.5k| node->children.push_back(temp); 142| | 143| | // The next token is the assignment 144| 12.5k| ++i; 145| 12.5k| if(i == end || (i->type != TID_WORD && i->type != TID_QUOTE)) ------------------ | Branch (145:28): [True: 3, False: 12.5k] | Branch (145:41): [True: 207, False: 12.3k] | Branch (145:64): [True: 7, False: 200] ------------------ 146| 12.5k| OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 147| 12.5k| Ogre::String("expected variable value at line ") + 148| 12.5k| Ogre::StringConverter::toString(node->line), 149| 12.5k| "ScriptParser::parse"); 150| 12.5k| temp = std::make_shared(); 151| 12.5k| temp->parent = node.get(); 152| 12.5k| temp->file = file; 153| 12.5k| temp->line = i->line; 154| 12.5k| temp->type = i->type == TID_WORD ? CNT_WORD : CNT_QUOTE; ------------------ | Branch (154:38): [True: 12.3k, False: 200] ------------------ 155| 12.5k| temp->token = unquoted(i->lexeme, temp->type == CNT_QUOTE); 156| 12.5k| node->children.push_back(temp); 157| | 158| | // Consume all the newlines 159| 12.5k| i = skipNewlines(i, end); 160| | 161| | // Insert the node 162| 12.5k| if(parent) ------------------ | Branch (162:28): [True: 11.1k, False: 1.42k] ------------------ 163| 11.1k| { 164| 11.1k| node->parent = parent; 165| 11.1k| parent->children.push_back(node); 166| 11.1k| } 167| 1.42k| else 168| 1.42k| { 169| 1.42k| node->parent = 0; 170| 1.42k| nodes->push_back(node); 171| 1.42k| } 172| 12.5k| node = ConcreteNodePtr(); 173| 12.5k| } 174| 345k| else 175| 345k| { 176| 345k| node = std::make_shared(); 177| 345k| node->file = file; 178| 345k| node->line = token->line; 179| 345k| node->type = token->type == TID_WORD ? CNT_WORD : CNT_QUOTE; ------------------ | Branch (179:38): [True: 345k, False: 0] ------------------ 180| 345k| node->token = unquoted(token->lexeme, node->type == CNT_QUOTE); 181| | 182| | // Insert the node 183| 345k| if(parent) ------------------ | Branch (183:28): [True: 301k, False: 44.3k] ------------------ 184| 301k| { 185| 301k| node->parent = parent; 186| 301k| parent->children.push_back(node); 187| 301k| } 188| 44.3k| else 189| 44.3k| { 190| 44.3k| node->parent = 0; 191| 44.3k| nodes->push_back(node); 192| 44.3k| } 193| | 194| | // Set the parent 195| 345k| parent = node.get(); 196| | 197| | // Switch states 198| 345k| state = OBJECT; 199| | 200| 345k| node = ConcreteNodePtr(); 201| 345k| } 202| 381k| } 203| 404k| else if(token->type == TID_RBRACKET) ------------------ | Branch (203:25): [True: 115k, False: 288k] ------------------ 204| 115k| { 205| | // Go up one level if we can 206| 115k| if(parent) ------------------ | Branch (206:24): [True: 111k, False: 3.44k] ------------------ 207| 111k| parent = parent->parent; 208| | 209| 115k| node = std::make_shared(); 210| 115k| node->token = token->lexeme; 211| 115k| node->file = file; 212| 115k| node->line = token->line; 213| 115k| node->type = CNT_RBRACE; 214| | 215| | // Consume all the newlines 216| 115k| i = skipNewlines(i, end); 217| | 218| | // Insert the node 219| 115k| if(parent) ------------------ | Branch (219:24): [True: 111k, False: 3.44k] ------------------ 220| 111k| { 221| 111k| node->parent = parent; 222| 111k| parent->children.push_back(node); 223| 111k| } 224| 3.44k| else 225| 3.44k| { 226| 3.44k| node->parent = 0; 227| 3.44k| nodes->push_back(node); 228| 3.44k| } 229| | 230| | // Move up another level 231| 115k| if(parent) ------------------ | Branch (231:24): [True: 111k, False: 3.44k] ------------------ 232| 111k| parent = parent->parent; 233| | 234| 115k| node = ConcreteNodePtr(); 235| 115k| } 236| 785k| break; 237| 855k| case OBJECT: ------------------ | Branch (237:13): [True: 855k, False: 785k] ------------------ 238| 855k| if(token->type == TID_NEWLINE) ------------------ | Branch (238:20): [True: 275k, False: 579k] ------------------ 239| 275k| { 240| | // Look ahead to the next non-newline token and if it isn't an {, this was a property 241| 275k| ScriptTokenList::const_iterator next = skipNewlines(i, end); 242| 275k| if(next == end || next->type != TID_LBRACKET) ------------------ | Branch (242:24): [True: 506, False: 275k] | Branch (242:39): [True: 170k, False: 104k] ------------------ 243| 171k| { 244| | // Ended a property here 245| 171k| if(parent) ------------------ | Branch (245:28): [True: 171k, False: 0] ------------------ 246| 171k| parent = parent->parent; 247| 171k| state = READY; 248| 171k| } 249| 275k| } 250| 579k| else if(token->type == TID_COLON) ------------------ | Branch (250:25): [True: 17.0k, False: 562k] ------------------ 251| 17.0k| { 252| 17.0k| node = std::make_shared(); 253| 17.0k| node->token = token->lexeme; 254| 17.0k| node->file = file; 255| 17.0k| node->line = token->line; 256| 17.0k| node->type = CNT_COLON; 257| | 258| | // The following token are the parent objects (base classes). 259| | // Require at least one of them. 260| | 261| 17.0k| ScriptTokenList::const_iterator j = i + 1; 262| 17.0k| j = skipNewlines(j, end); 263| 17.0k| if(j == end || (j->type != TID_WORD && j->type != TID_QUOTE)) { ------------------ | Branch (263:24): [True: 20, False: 17.0k] | Branch (263:37): [True: 2.13k, False: 14.8k] | Branch (263:60): [True: 21, False: 2.11k] ------------------ 264| 41| OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 265| 41| Ogre::String("expected object identifier at line ") + 266| 41| Ogre::StringConverter::toString(node->line), 267| 41| "ScriptParser::parse"); 268| 41| } 269| | 270| 44.6k| while(j != end && (j->type == TID_WORD || j->type == TID_QUOTE)) ------------------ | Branch (270:27): [True: 44.5k, False: 126] | Branch (270:40): [True: 24.6k, False: 19.9k] | Branch (270:63): [True: 3.06k, False: 16.8k] ------------------ 271| 27.6k| { 272| 27.6k| ConcreteNodePtr tempNode = std::make_shared(); 273| 27.6k| tempNode->token = j->lexeme; 274| 27.6k| tempNode->file = file; 275| 27.6k| tempNode->line = j->line; 276| 27.6k| tempNode->type = j->type == TID_WORD ? CNT_WORD : CNT_QUOTE; ------------------ | Branch (276:42): [True: 24.6k, False: 3.06k] ------------------ 277| 27.6k| tempNode->parent = node.get(); 278| 27.6k| node->children.push_back(tempNode); 279| 27.6k| ++j; 280| 27.6k| } 281| | 282| | // Move it backwards once, since the end of the loop moves it forwards again anyway 283| 17.0k| i = --j; 284| | 285| | // Insert the node 286| 17.0k| if(parent) ------------------ | Branch (286:24): [True: 17.0k, False: 0] ------------------ 287| 17.0k| { 288| 17.0k| node->parent = parent; 289| 17.0k| parent->children.push_back(node); 290| 17.0k| } 291| 0| else 292| 0| { 293| 0| node->parent = 0; 294| 0| nodes->push_back(node); 295| 0| } 296| 17.0k| node = ConcreteNodePtr(); 297| 17.0k| } 298| 562k| else if(token->type == TID_LBRACKET) ------------------ | Branch (298:25): [True: 163k, False: 399k] ------------------ 299| 163k| { 300| 163k| node = std::make_shared(); 301| 163k| node->token = token->lexeme; 302| 163k| node->file = file; 303| 163k| node->line = token->line; 304| 163k| node->type = CNT_LBRACE; 305| | 306| | // Consume all the newlines 307| 163k| i = skipNewlines(i, end); 308| | 309| | // Insert the node 310| 163k| if(parent) ------------------ | Branch (310:24): [True: 163k, False: 0] ------------------ 311| 163k| { 312| 163k| node->parent = parent; 313| 163k| parent->children.push_back(node); 314| 163k| } 315| 0| else 316| 0| { 317| 0| node->parent = 0; 318| 0| nodes->push_back(node); 319| 0| } 320| | 321| | // Set the parent 322| 163k| parent = node.get(); 323| | 324| | // Change the state 325| 163k| state = READY; 326| | 327| 163k| node = ConcreteNodePtr(); 328| 163k| } 329| 399k| else if(token->type == TID_RBRACKET) ------------------ | Branch (329:25): [True: 9.03k, False: 390k] ------------------ 330| 9.03k| { 331| | // Go up one level if we can 332| 9.03k| if(parent) ------------------ | Branch (332:24): [True: 9.03k, False: 0] ------------------ 333| 9.03k| parent = parent->parent; 334| | 335| | // If the parent is currently a { then go up again 336| 9.03k| if(parent && parent->type == CNT_LBRACE && parent->parent) ------------------ | Branch (336:24): [True: 8.40k, False: 633] | Branch (336:34): [True: 8.40k, False: 0] | Branch (336:64): [True: 8.40k, False: 0] ------------------ 337| 8.40k| parent = parent->parent; 338| | 339| 9.03k| node = std::make_shared(); 340| 9.03k| node->token = token->lexeme; 341| 9.03k| node->file = file; 342| 9.03k| node->line = token->line; 343| 9.03k| node->type = CNT_RBRACE; 344| | 345| | // Consume all the newlines 346| 9.03k| i = skipNewlines(i, end); 347| | 348| | // Insert the node 349| 9.03k| if(parent) ------------------ | Branch (349:24): [True: 8.40k, False: 633] ------------------ 350| 8.40k| { 351| 8.40k| node->parent = parent; 352| 8.40k| parent->children.push_back(node); 353| 8.40k| } 354| 633| else 355| 633| { 356| 633| node->parent = 0; 357| 633| nodes->push_back(node); 358| 633| } 359| | 360| | // Move up another level 361| 9.03k| if(parent) ------------------ | Branch (361:24): [True: 8.40k, False: 633] ------------------ 362| 8.40k| parent = parent->parent; 363| | 364| 9.03k| node = ConcreteNodePtr(); 365| 9.03k| state = READY; 366| 9.03k| } 367| 390k| else if(token->type == TID_VARIABLE) ------------------ | Branch (367:25): [True: 15.0k, False: 375k] ------------------ 368| 15.0k| { 369| 15.0k| node = std::make_shared(); 370| 15.0k| node->token = token->lexeme; 371| 15.0k| node->file = file; 372| 15.0k| node->line = token->line; 373| 15.0k| node->type = CNT_VARIABLE; 374| | 375| | // Insert the node 376| 15.0k| if(parent) ------------------ | Branch (376:24): [True: 15.0k, False: 0] ------------------ 377| 15.0k| { 378| 15.0k| node->parent = parent; 379| 15.0k| parent->children.push_back(node); 380| 15.0k| } 381| 0| else 382| 0| { 383| 0| node->parent = 0; 384| 0| nodes->push_back(node); 385| 0| } 386| 15.0k| node = ConcreteNodePtr(); 387| 15.0k| } 388| 375k| else if(token->type == TID_QUOTE) ------------------ | Branch (388:25): [True: 11.4k, False: 364k] ------------------ 389| 11.4k| { 390| 11.4k| node = std::make_shared(); 391| 11.4k| node->token = unquoted(token->lexeme); 392| 11.4k| node->file = file; 393| 11.4k| node->line = token->line; 394| 11.4k| node->type = CNT_QUOTE; 395| | 396| | // Insert the node 397| 11.4k| if(parent) ------------------ | Branch (397:24): [True: 11.4k, False: 0] ------------------ 398| 11.4k| { 399| 11.4k| node->parent = parent; 400| 11.4k| parent->children.push_back(node); 401| 11.4k| } 402| 0| else 403| 0| { 404| 0| node->parent = 0; 405| 0| nodes->push_back(node); 406| 0| } 407| 11.4k| node = ConcreteNodePtr(); 408| 11.4k| } 409| 364k| else if(token->type == TID_WORD) ------------------ | Branch (409:25): [True: 364k, False: 0] ------------------ 410| 364k| { 411| 364k| node = std::make_shared(); 412| 364k| node->token = token->lexeme; 413| 364k| node->file = file; 414| 364k| node->line = token->line; 415| 364k| node->type = CNT_WORD; 416| | 417| | // Insert the node 418| 364k| if(parent) ------------------ | Branch (418:24): [True: 364k, False: 0] ------------------ 419| 364k| { 420| 364k| node->parent = parent; 421| 364k| parent->children.push_back(node); 422| 364k| } 423| 0| else 424| 0| { 425| 0| node->parent = 0; 426| 0| nodes->push_back(node); 427| 0| } 428| 364k| node = ConcreteNodePtr(); 429| 364k| } 430| 855k| break; 431| 1.64M| } 432| | 433| 1.64M| ++i; 434| 1.64M| } 435| | 436| 7.10k| return nodes; 437| 7.20k| } _ZN4Ogre12ScriptParser10parseChunkERKNSt3__16vectorINS_11ScriptTokenENS1_9allocatorIS3_EEEERKNS1_12basic_stringIcNS1_11char_traitsIcEENS4_IcEEEE: 440| 8.84k| { 441| 8.84k| auto nodes = std::make_shared(); 442| | 443| 8.84k| ConcreteNodePtr node; 444| 8.84k| for(const auto& token : tokens) ------------------ | Branch (444:31): [True: 8.99k, False: 8.83k] ------------------ 445| 8.99k| { 446| 8.99k| switch(token.type) 447| 8.99k| { 448| 9| case TID_VARIABLE: ------------------ | Branch (448:13): [True: 9, False: 8.98k] ------------------ 449| 9| node = std::make_shared(); 450| 9| node->file = file; 451| 9| node->line = token.line; 452| 9| node->parent = 0; 453| 9| node->token = token.lexeme; 454| 9| node->type = CNT_VARIABLE; 455| 9| break; 456| 8.97k| case TID_WORD: ------------------ | Branch (456:13): [True: 8.97k, False: 16] ------------------ 457| 8.97k| node = std::make_shared(); 458| 8.97k| node->file = file; 459| 8.97k| node->line = token.line; 460| 8.97k| node->parent = 0; 461| 8.97k| node->token = token.lexeme; 462| 8.97k| node->type = CNT_WORD; 463| 8.97k| break; 464| 0| case TID_QUOTE: ------------------ | Branch (464:13): [True: 0, False: 8.99k] ------------------ 465| 0| node = std::make_shared(); 466| 0| node->file = file; 467| 0| node->line = token.line; 468| 0| node->parent = 0; 469| 0| node->token= unquoted(token.lexeme); 470| 0| node->type = CNT_QUOTE; 471| 0| break; 472| 7| default: ------------------ | Branch (472:13): [True: 7, False: 8.98k] ------------------ 473| 7| OGRE_EXCEPT(Exception::ERR_INVALID_STATE, 474| 8.99k| Ogre::String("unexpected token") + token.lexeme + " at line " + 475| 8.99k| Ogre::StringConverter::toString(token.line), 476| 8.99k| "ScriptParser::parseChunk"); 477| 8.99k| } 478| | 479| 8.98k| if(node) ------------------ | Branch (479:16): [True: 8.98k, False: 0] ------------------ 480| 8.98k| nodes->push_back(node); 481| 8.98k| } 482| | 483| 8.83k| return nodes; 484| 8.84k| } _ZN4Ogre12ScriptParser12skipNewlinesENSt3__111__wrap_iterIPKNS_11ScriptTokenEEES6_: 496| 615k| { 497| 892k| while(i != end && i->type == TID_NEWLINE) ------------------ | Branch (497:15): [True: 891k, False: 526] | Branch (497:27): [True: 276k, False: 615k] ------------------ 498| 276k| ++i; 499| 615k| return i; 500| 615k| } OgreScriptParser.cpp:_ZN4OgreL8unquotedERKNSt3__112basic_stringIcNS0_11char_traitsIcEENS0_9allocatorIcEEEEb: 37| 416k| { 38| 416k| return trim ? str.substr(1, str.size() - 2) : str; ------------------ | Branch (38:16): [True: 33.2k, False: 383k] ------------------ 39| 416k| } _ZN4Ogre8getValueIfEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 94| 5.34k| { 95| 5.34k| return StringConverter::parse(node->getString(), result); 96| 5.34k| } _ZN4Ogre8getValueIbEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 102| 9.51k| { 103| 9.51k| return ScriptTranslator::getBoolean(node, &result); 104| 9.51k| } _ZN4Ogre8getValueIjEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 106| 3.02k| { 107| 3.02k| return StringConverter::parse(node->getString(), result); 108| 3.02k| } _ZN4Ogre8getValueIiEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 110| 191| { 111| 191| return StringConverter::parse(node->getString(), result); 112| 191| } _ZN4Ogre8getValueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 114| 23.1k| { 115| 23.1k| return ScriptTranslator::getString(node, &result); 116| 23.1k| } _ZN4Ogre8getValueINS_15CompareFunctionEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 119| 156| { 120| 156| return ScriptTranslator::getCompareFunction(node, &result); 121| 156| } _ZN4Ogre8getValueINS_16StencilOperationEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 124| 15| { 125| 15| return ScriptTranslator::getStencilOp(node, &result); 126| 15| } _ZN4Ogre8getValueINS_17IlluminationStageEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 129| 22| { 130| 22| switch (getAtomId(node)) 131| 22| { 132| 2| case ID_AMBIENT: ------------------ | Branch (132:9): [True: 2, False: 20] ------------------ 133| 2| result = IS_AMBIENT; 134| 2| return true; 135| 3| case ID_PER_LIGHT: ------------------ | Branch (135:9): [True: 3, False: 19] ------------------ 136| 3| result = IS_PER_LIGHT; 137| 3| return true; 138| 0| case ID_DECAL: ------------------ | Branch (138:9): [True: 0, False: 22] ------------------ 139| 0| result = IS_DECAL; 140| 0| return true; 141| 17| default: ------------------ | Branch (141:9): [True: 17, False: 5] ------------------ 142| 17| return false; 143| 22| } 144| 22| } _ZN4Ogre8getValueINS_14SceneBlendTypeEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 147| 2.96k| { 148| 2.96k| switch (getAtomId(node)) 149| 2.96k| { 150| 1.38k| case ID_ADD: ------------------ | Branch (150:9): [True: 1.38k, False: 1.58k] ------------------ 151| 1.38k| result = SBT_ADD; 152| 1.38k| break; 153| 217| case ID_MODULATE: ------------------ | Branch (153:9): [True: 217, False: 2.75k] ------------------ 154| 217| result = SBT_MODULATE; 155| 217| break; 156| 324| case ID_COLOUR_BLEND: ------------------ | Branch (156:9): [True: 324, False: 2.64k] ------------------ 157| 324| result = SBT_TRANSPARENT_COLOUR; 158| 324| break; 159| 895| case ID_ALPHA_BLEND: ------------------ | Branch (159:9): [True: 895, False: 2.07k] ------------------ 160| 895| result = SBT_TRANSPARENT_ALPHA; 161| 895| break; 162| 148| default: ------------------ | Branch (162:9): [True: 148, False: 2.82k] ------------------ 163| 148| return false; 164| 2.96k| } 165| 2.82k| return true; 166| 2.96k| } _ZN4Ogre8getValueINS_19SceneBlendOperationEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 169| 15| { 170| 15| switch (getAtomId(node)) 171| 15| { 172| 0| case ID_ADD: ------------------ | Branch (172:9): [True: 0, False: 15] ------------------ 173| 0| result = SBO_ADD; 174| 0| break; 175| 0| case ID_SUBTRACT: ------------------ | Branch (175:9): [True: 0, False: 15] ------------------ 176| 0| result = SBO_SUBTRACT; 177| 0| break; 178| 0| case ID_REVERSE_SUBTRACT: ------------------ | Branch (178:9): [True: 0, False: 15] ------------------ 179| 0| result = SBO_REVERSE_SUBTRACT; 180| 0| break; 181| 0| case ID_MIN: ------------------ | Branch (181:9): [True: 0, False: 15] ------------------ 182| 0| result = SBO_MIN; 183| 0| break; 184| 0| case ID_MAX: ------------------ | Branch (184:9): [True: 0, False: 15] ------------------ 185| 0| result = SBO_MAX; 186| 0| break; 187| 15| default: ------------------ | Branch (187:9): [True: 15, False: 0] ------------------ 188| 15| return false; 189| 15| } 190| 0| return true; 191| 15| } _ZN4Ogre8getValueINS_11CullingModeEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 194| 2.42k| { 195| 2.42k| switch (getAtomId(node)) 196| 2.42k| { 197| 0| case ID_CLOCKWISE: ------------------ | Branch (197:9): [True: 0, False: 2.42k] ------------------ 198| 0| result = CULL_CLOCKWISE; 199| 0| break; 200| 0| case ID_ANTICLOCKWISE: ------------------ | Branch (200:9): [True: 0, False: 2.42k] ------------------ 201| 0| result = CULL_ANTICLOCKWISE; 202| 0| break; 203| 2.34k| case ID_NONE: ------------------ | Branch (203:9): [True: 2.34k, False: 86] ------------------ 204| 2.34k| result = CULL_NONE; 205| 2.34k| break; 206| 86| default: ------------------ | Branch (206:9): [True: 86, False: 2.34k] ------------------ 207| 86| return false; 208| 2.42k| } 209| 2.34k| return true; 210| 2.42k| } _ZN4Ogre8getValueINS_17ManualCullingModeEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 213| 61| { 214| 61| switch (getAtomId(node)) 215| 61| { 216| 0| case ID_FRONT: ------------------ | Branch (216:9): [True: 0, False: 61] ------------------ 217| 0| result = MANUAL_CULL_FRONT; 218| 0| break; 219| 0| case ID_BACK: ------------------ | Branch (219:9): [True: 0, False: 61] ------------------ 220| 0| result = MANUAL_CULL_BACK; 221| 0| break; 222| 38| case ID_NONE: ------------------ | Branch (222:9): [True: 38, False: 23] ------------------ 223| 38| result = MANUAL_CULL_NONE; 224| 38| break; 225| 23| default: ------------------ | Branch (225:9): [True: 23, False: 38] ------------------ 226| 23| return false; 227| 61| } 228| 38| return true; 229| 61| } _ZN4Ogre8getValueINS_12ShadeOptionsEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 232| 7| { 233| 7| switch (getAtomId(node)) 234| 7| { 235| 0| case ID_FLAT: ------------------ | Branch (235:9): [True: 0, False: 7] ------------------ 236| 0| result = SO_FLAT; 237| 0| break; 238| 0| case ID_GOURAUD: ------------------ | Branch (238:9): [True: 0, False: 7] ------------------ 239| 0| result = SO_GOURAUD; 240| 0| break; 241| 0| case ID_PHONG: ------------------ | Branch (241:9): [True: 0, False: 7] ------------------ 242| 0| result = SO_PHONG; 243| 0| break; 244| 7| default: ------------------ | Branch (244:9): [True: 7, False: 0] ------------------ 245| 7| return false; 246| 7| } 247| 0| return true; 248| 7| } _ZN4Ogre8getValueINS_11PolygonModeEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 251| 34| { 252| 34| switch (getAtomId(node)) 253| 34| { 254| 0| case ID_SOLID: ------------------ | Branch (254:9): [True: 0, False: 34] ------------------ 255| 0| result = PM_SOLID; 256| 0| break; 257| 0| case ID_POINTS: ------------------ | Branch (257:9): [True: 0, False: 34] ------------------ 258| 0| result = PM_POINTS; 259| 0| break; 260| 5| case ID_WIREFRAME: ------------------ | Branch (260:9): [True: 5, False: 29] ------------------ 261| 5| result = PM_WIREFRAME; 262| 5| break; 263| 29| default: ------------------ | Branch (263:9): [True: 29, False: 5] ------------------ 264| 29| return false; 265| 34| } 266| 5| return true; 267| 34| } _ZN4Ogre8getValueINS_19LayerBlendOperationEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 270| 64| { 271| 64| switch (getAtomId(node)) 272| 64| { 273| 7| case ID_REPLACE: ------------------ | Branch (273:9): [True: 7, False: 57] ------------------ 274| 7| result = LBO_REPLACE; 275| 7| break; 276| 2| case ID_ADD: ------------------ | Branch (276:9): [True: 2, False: 62] ------------------ 277| 2| result = LBO_ADD; 278| 2| break; 279| 25| case ID_MODULATE: ------------------ | Branch (279:9): [True: 25, False: 39] ------------------ 280| 25| result = LBO_MODULATE; 281| 25| break; 282| 0| case ID_ALPHA_BLEND: ------------------ | Branch (282:9): [True: 0, False: 64] ------------------ 283| 0| result = LBO_ALPHA_BLEND; 284| 0| break; 285| 30| default: ------------------ | Branch (285:9): [True: 30, False: 34] ------------------ 286| 30| return false; 287| 64| } 288| 34| return true; 289| 64| } _ZN4Ogre8getValueINS_21LayerBlendOperationExEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 292| 533| { 293| 533| switch (getAtomId(node)) 294| 533| { 295| 75| case ID_SOURCE1: ------------------ | Branch (295:9): [True: 75, False: 458] ------------------ 296| 75| op = LBX_SOURCE1; 297| 75| break; 298| 9| case ID_SOURCE2: ------------------ | Branch (298:9): [True: 9, False: 524] ------------------ 299| 9| op = LBX_SOURCE2; 300| 9| break; 301| 104| case ID_MODULATE: ------------------ | Branch (301:9): [True: 104, False: 429] ------------------ 302| 104| op = LBX_MODULATE; 303| 104| break; 304| 0| case ID_MODULATE_X2: ------------------ | Branch (304:9): [True: 0, False: 533] ------------------ 305| 0| op = LBX_MODULATE_X2; 306| 0| break; 307| 0| case ID_MODULATE_X4: ------------------ | Branch (307:9): [True: 0, False: 533] ------------------ 308| 0| op = LBX_MODULATE_X4; 309| 0| break; 310| 286| case ID_ADD: ------------------ | Branch (310:9): [True: 286, False: 247] ------------------ 311| 286| op = LBX_ADD; 312| 286| break; 313| 0| case ID_ADD_SIGNED: ------------------ | Branch (313:9): [True: 0, False: 533] ------------------ 314| 0| op = LBX_ADD_SIGNED; 315| 0| break; 316| 0| case ID_ADD_SMOOTH: ------------------ | Branch (316:9): [True: 0, False: 533] ------------------ 317| 0| op = LBX_ADD_SMOOTH; 318| 0| break; 319| 0| case ID_SUBTRACT: ------------------ | Branch (319:9): [True: 0, False: 533] ------------------ 320| 0| op = LBX_SUBTRACT; 321| 0| break; 322| 0| case ID_BLEND_DIFFUSE_ALPHA: ------------------ | Branch (322:9): [True: 0, False: 533] ------------------ 323| 0| op = LBX_BLEND_DIFFUSE_ALPHA; 324| 0| break; 325| 0| case ID_BLEND_TEXTURE_ALPHA: ------------------ | Branch (325:9): [True: 0, False: 533] ------------------ 326| 0| op = LBX_BLEND_TEXTURE_ALPHA; 327| 0| break; 328| 0| case ID_BLEND_CURRENT_ALPHA: ------------------ | Branch (328:9): [True: 0, False: 533] ------------------ 329| 0| op = LBX_BLEND_CURRENT_ALPHA; 330| 0| break; 331| 0| case ID_BLEND_MANUAL: ------------------ | Branch (331:9): [True: 0, False: 533] ------------------ 332| 0| op = LBX_BLEND_MANUAL; 333| 0| break; 334| 0| case ID_DOT_PRODUCT: ------------------ | Branch (334:9): [True: 0, False: 533] ------------------ 335| 0| op = LBX_DOTPRODUCT; 336| 0| break; 337| 0| case ID_BLEND_DIFFUSE_COLOUR: ------------------ | Branch (337:9): [True: 0, False: 533] ------------------ 338| 0| op = LBX_BLEND_DIFFUSE_COLOUR; 339| 0| break; 340| 59| default: ------------------ | Branch (340:9): [True: 59, False: 474] ------------------ 341| 59| return false; 342| 533| } 343| 474| return true; 344| 533| } _ZN4Ogre8getValueINS_16LayerBlendSourceEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 347| 915| { 348| 915| switch (getAtomId(node)) 349| 915| { 350| 304| case ID_SRC_CURRENT: ------------------ | Branch (350:9): [True: 304, False: 611] ------------------ 351| 304| source1 = LBS_CURRENT; 352| 304| break; 353| 363| case ID_SRC_TEXTURE: ------------------ | Branch (353:9): [True: 363, False: 552] ------------------ 354| 363| source1 = LBS_TEXTURE; 355| 363| break; 356| 2| case ID_SRC_DIFFUSE: ------------------ | Branch (356:9): [True: 2, False: 913] ------------------ 357| 2| source1 = LBS_DIFFUSE; 358| 2| break; 359| 1| case ID_SRC_SPECULAR: ------------------ | Branch (359:9): [True: 1, False: 914] ------------------ 360| 1| source1 = LBS_SPECULAR; 361| 1| break; 362| 163| case ID_SRC_MANUAL: ------------------ | Branch (362:9): [True: 163, False: 752] ------------------ 363| 163| source1 = LBS_MANUAL; 364| 163| break; 365| 82| default: ------------------ | Branch (365:9): [True: 82, False: 833] ------------------ 366| 82| return false; 367| 915| } 368| 833| return true; 369| 915| } _ZN4Ogre8getValueINS_21CompositionTargetPass9InputModeEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 372| 5.65k| { 373| 5.65k| switch (getAtomId(node)) 374| 5.65k| { 375| 1.99k| case ID_NONE: ------------------ | Branch (375:9): [True: 1.99k, False: 3.65k] ------------------ 376| 1.99k| result = CompositionTargetPass::IM_NONE; 377| 1.99k| break; 378| 3.52k| case ID_PREVIOUS: ------------------ | Branch (378:9): [True: 3.52k, False: 2.12k] ------------------ 379| 3.52k| result = CompositionTargetPass::IM_PREVIOUS; 380| 3.52k| break; 381| 130| default: ------------------ | Branch (381:9): [True: 130, False: 5.52k] ------------------ 382| 130| return false; 383| 5.65k| } 384| 5.52k| return true; 385| 5.65k| } _ZN4Ogre8getValueINS_13FilterOptionsEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 388| 973| { 389| 973| switch (getAtomId(node)) 390| 973| { 391| 230| case ID_NONE: ------------------ | Branch (391:9): [True: 230, False: 743] ------------------ 392| 230| tmip = FO_NONE; 393| 230| break; 394| 24| case ID_POINT: ------------------ | Branch (394:9): [True: 24, False: 949] ------------------ 395| 24| tmip = FO_POINT; 396| 24| break; 397| 614| case ID_LINEAR: ------------------ | Branch (397:9): [True: 614, False: 359] ------------------ 398| 614| tmip = FO_LINEAR; 399| 614| break; 400| 1| case ID_ANISOTROPIC: ------------------ | Branch (400:9): [True: 1, False: 972] ------------------ 401| 1| tmip = FO_ANISOTROPIC; 402| 1| break; 403| 104| default: ------------------ | Branch (403:9): [True: 104, False: 869] ------------------ 404| 104| return false; 405| 973| } 406| 869| return true; 407| 973| } _ZN4Ogre8getValueINS_21TextureAddressingModeEEEbRKNS_9SharedPtrINS_12AbstractNodeEEERT_: 410| 3.64k| { 411| 3.64k| switch (getAtomId(node)) 412| 3.64k| { 413| 20| case ID_WRAP: ------------------ | Branch (413:9): [True: 20, False: 3.62k] ------------------ 414| 20| result = TextureUnitState::TAM_WRAP; 415| 20| break; 416| 3.45k| case ID_CLAMP: ------------------ | Branch (416:9): [True: 3.45k, False: 188] ------------------ 417| 3.45k| result = TextureUnitState::TAM_CLAMP; 418| 3.45k| break; 419| 5| case ID_MIRROR: ------------------ | Branch (419:9): [True: 5, False: 3.63k] ------------------ 420| 5| result = TextureUnitState::TAM_MIRROR; 421| 5| break; 422| 21| case ID_BORDER: ------------------ | Branch (422:9): [True: 21, False: 3.61k] ------------------ 423| 21| result = TextureUnitState::TAM_BORDER; 424| 21| break; 425| 142| default: ------------------ | Branch (425:9): [True: 142, False: 3.49k] ------------------ 426| 142| return false; 427| 3.64k| } 428| 3.49k| return true; 429| 3.64k| } _ZN4Ogre16ScriptTranslator11processNodeEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE: 506| 61.9k| { 507| 61.9k| if(node->type != ANT_OBJECT) ------------------ | Branch (507:12): [True: 0, False: 61.9k] ------------------ 508| 0| return; 509| | 510| | // Abstract objects are completely skipped 511| 61.9k| if((static_cast(node.get()))->abstract) ------------------ | Branch (511:12): [True: 37, False: 61.9k] ------------------ 512| 37| return; 513| | 514| | // Retrieve the translator to use 515| 61.9k| ScriptTranslator *translator = 516| 61.9k| ScriptCompilerManager::getSingleton().getTranslator(node); 517| | 518| 61.9k| if(translator) ------------------ | Branch (518:12): [True: 50.6k, False: 11.2k] ------------------ 519| 50.6k| translator->translate(compiler, node); 520| 11.2k| else 521| 11.2k| compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, node->file, node->line, 522| 11.2k| "token \"" + static_cast(node.get())->cls + "\" is not recognized"); 523| 61.9k| } _ZN4Ogre16ScriptTranslator9getNodeAtERKNSt3__14listINS_9SharedPtrINS_12AbstractNodeEEENS1_9allocatorIS5_EEEEm: 526| 53.1k| { 527| 53.1k| if(index >= nodes.size()) ------------------ | Branch (527:12): [True: 9.07k, False: 44.1k] ------------------ 528| 9.07k| return nodes.end(); 529| | 530| 44.1k| return std::next(nodes.begin(), index); 531| 53.1k| } _ZN4Ogre16ScriptTranslator10getBooleanERKNS_9SharedPtrINS_12AbstractNodeEEEPb: 534| 10.1k| { 535| 10.1k| if (node->type != ANT_ATOM) ------------------ | Branch (535:13): [True: 34, False: 10.1k] ------------------ 536| 34| return false; 537| 10.1k| AtomAbstractNode *atom = (AtomAbstractNode*)node.get(); 538| 10.1k| if (atom->id == 1 || atom->id == 2) ------------------ | Branch (538:8): [True: 940, False: 9.18k] | Branch (538:25): [True: 8.19k, False: 992] ------------------ 539| 9.13k| { 540| 9.13k| *result = atom->id == 1 ? true : false; ------------------ | Branch (540:14): [True: 940, False: 8.19k] ------------------ 541| 9.13k| return true; 542| 9.13k| } 543| | // return false; 544| 992| return false; 545| 10.1k| } _ZN4Ogre16ScriptTranslator9getStringERKNS_9SharedPtrINS_12AbstractNodeEEEPNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEE: 548| 46.8k| { 549| 46.8k| if(node->type != ANT_ATOM) ------------------ | Branch (549:12): [True: 244, False: 46.6k] ------------------ 550| 244| return false; 551| 46.6k| AtomAbstractNode *atom = (AtomAbstractNode*)node.get(); 552| 46.6k| *result = atom->value; 553| 46.6k| return true; 554| 46.8k| } _ZN4Ogre16ScriptTranslator8getFloatERKNS_9SharedPtrINS_12AbstractNodeEEEPf: 557| 20.9k| { 558| 20.9k| return StringConverter::parse(node->getString(), *result); 559| 20.9k| } _ZN4Ogre16ScriptTranslator6getIntERKNS_9SharedPtrINS_12AbstractNodeEEEPi: 567| 798| { 568| 798| return StringConverter::parse(node->getString(), *result); 569| 798| } _ZN4Ogre16ScriptTranslator7getUIntERKNS_9SharedPtrINS_12AbstractNodeEEEPj: 572| 4.35k| { 573| 4.35k| return StringConverter::parse(node->getString(), *result); 574| 4.35k| } _ZN4Ogre16ScriptTranslator9getColourENSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEES7_PNS_11ColourValueEi: 577| 5.18k| { 578| 5.18k| int n = 0; 579| 22.2k| while(i != end && n < maxEntries) ------------------ | Branch (579:15): [True: 17.5k, False: 4.64k] | Branch (579:27): [True: 17.4k, False: 183] ------------------ 580| 17.4k| { 581| 17.4k| float v = 0; 582| 17.4k| if(getFloat(*i, &v)) ------------------ | Branch (582:16): [True: 17.0k, False: 355] ------------------ 583| 17.0k| { 584| 17.0k| switch(n) ------------------ | Branch (584:24): [True: 17.0k, False: 0] ------------------ 585| 17.0k| { 586| 5.00k| case 0: ------------------ | Branch (586:17): [True: 5.00k, False: 12.0k] ------------------ 587| 5.00k| result->r = v; 588| 5.00k| break; 589| 4.84k| case 1: ------------------ | Branch (589:17): [True: 4.84k, False: 12.2k] ------------------ 590| 4.84k| result->g = v; 591| 4.84k| break; 592| 4.73k| case 2: ------------------ | Branch (592:17): [True: 4.73k, False: 12.3k] ------------------ 593| 4.73k| result->b = v; 594| 4.73k| break; 595| 2.47k| case 3: ------------------ | Branch (595:17): [True: 2.47k, False: 14.5k] ------------------ 596| 2.47k| result->a = v; 597| 2.47k| break; 598| 17.0k| } 599| 17.0k| } 600| 355| else 601| 355| { 602| 355| return false; 603| 355| } 604| 17.0k| ++n; 605| 17.0k| ++i; 606| 17.0k| } 607| | // return error if we found less than rgb before end, unless constrained 608| 4.83k| return (n >= 3 || n == maxEntries); ------------------ | Branch (608:17): [True: 4.67k, False: 156] | Branch (608:27): [True: 0, False: 156] ------------------ 609| 5.18k| } _ZN4Ogre16ScriptTranslator19getSceneBlendFactorERKNS_9SharedPtrINS_12AbstractNodeEEEPNS_16SceneBlendFactorE: 612| 561| { 613| 561| switch(getAtomId(node)) 614| 561| { 615| 450| case ID_ONE: ------------------ | Branch (615:9): [True: 450, False: 111] ------------------ 616| 450| *sbf = SBF_ONE; 617| 450| break; 618| 0| case ID_ZERO: ------------------ | Branch (618:9): [True: 0, False: 561] ------------------ 619| 0| *sbf = SBF_ZERO; 620| 0| break; 621| 0| case ID_DEST_COLOUR: ------------------ | Branch (621:9): [True: 0, False: 561] ------------------ 622| 0| *sbf = SBF_DEST_COLOUR; 623| 0| break; 624| 0| case ID_DEST_ALPHA: ------------------ | Branch (624:9): [True: 0, False: 561] ------------------ 625| 0| *sbf = SBF_DEST_ALPHA; 626| 0| break; 627| 0| case ID_SRC_ALPHA: ------------------ | Branch (627:9): [True: 0, False: 561] ------------------ 628| 0| *sbf = SBF_SOURCE_ALPHA; 629| 0| break; 630| 0| case ID_SRC_COLOUR: ------------------ | Branch (630:9): [True: 0, False: 561] ------------------ 631| 0| *sbf = SBF_SOURCE_COLOUR; 632| 0| break; 633| 0| case ID_ONE_MINUS_DEST_COLOUR: ------------------ | Branch (633:9): [True: 0, False: 561] ------------------ 634| 0| *sbf = SBF_ONE_MINUS_DEST_COLOUR; 635| 0| break; 636| 0| case ID_ONE_MINUS_SRC_COLOUR: ------------------ | Branch (636:9): [True: 0, False: 561] ------------------ 637| 0| *sbf = SBF_ONE_MINUS_SOURCE_COLOUR; 638| 0| break; 639| 0| case ID_ONE_MINUS_DEST_ALPHA: ------------------ | Branch (639:9): [True: 0, False: 561] ------------------ 640| 0| *sbf = SBF_ONE_MINUS_DEST_ALPHA; 641| 0| break; 642| 0| case ID_ONE_MINUS_SRC_ALPHA: ------------------ | Branch (642:9): [True: 0, False: 561] ------------------ 643| 0| *sbf = SBF_ONE_MINUS_SOURCE_ALPHA; 644| 0| break; 645| 111| default: ------------------ | Branch (645:9): [True: 111, False: 450] ------------------ 646| 111| return false; 647| 561| } 648| 450| return true; 649| 561| } _ZN4Ogre16ScriptTranslator18getCompareFunctionERKNS_9SharedPtrINS_12AbstractNodeEEEPNS_15CompareFunctionE: 652| 294| { 653| 294| switch(getAtomId(node)) 654| 294| { 655| 0| case ID_ALWAYS_FAIL: ------------------ | Branch (655:9): [True: 0, False: 294] ------------------ 656| 0| *func = CMPF_ALWAYS_FAIL; 657| 0| break; 658| 111| case ID_ALWAYS_PASS: ------------------ | Branch (658:9): [True: 111, False: 183] ------------------ 659| 111| *func = CMPF_ALWAYS_PASS; 660| 111| break; 661| 0| case ID_LESS: ------------------ | Branch (661:9): [True: 0, False: 294] ------------------ 662| 0| *func = CMPF_LESS; 663| 0| break; 664| 4| case ID_LESS_EQUAL: ------------------ | Branch (664:9): [True: 4, False: 290] ------------------ 665| 4| *func = CMPF_LESS_EQUAL; 666| 4| break; 667| 0| case ID_EQUAL: ------------------ | Branch (667:9): [True: 0, False: 294] ------------------ 668| 0| *func = CMPF_EQUAL; 669| 0| break; 670| 0| case ID_NOT_EQUAL: ------------------ | Branch (670:9): [True: 0, False: 294] ------------------ 671| 0| *func = CMPF_NOT_EQUAL; 672| 0| break; 673| 0| case ID_GREATER_EQUAL: ------------------ | Branch (673:9): [True: 0, False: 294] ------------------ 674| 0| *func = CMPF_GREATER_EQUAL; 675| 0| break; 676| 104| case ID_GREATER: ------------------ | Branch (676:9): [True: 104, False: 190] ------------------ 677| 104| *func = CMPF_GREATER; 678| 104| break; 679| 75| default: ------------------ | Branch (679:9): [True: 75, False: 219] ------------------ 680| 75| return false; 681| 294| } 682| 219| return true; 683| 294| } _ZN4Ogre16ScriptTranslator10getMatrix4ENSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEES7_PNS_7Matrix4E: 686| 35| { 687| 35| int n = 0; 688| 62| while (i != end && n < 16) ------------------ | Branch (688:16): [True: 50, False: 12] | Branch (688:28): [True: 50, False: 0] ------------------ 689| 50| { 690| 50| Real r = 0; 691| 50| if (!getReal(*i, &r)) ------------------ | Branch (691:17): [True: 23, False: 27] ------------------ 692| 23| return false; 693| | 694| 27| (*m)[n/4][n%4] = r; 695| 27| ++i; 696| 27| ++n; 697| 27| } 698| 12| return n == 16; 699| 35| } _ZN4Ogre16ScriptTranslator9getVectorENSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEES7_RNS1_6vectorIfNS1_9allocatorIfEEEEm: 757| 1.73k| { 758| 1.73k| return _getVector(i, end, vals, count); 759| 1.73k| } _ZN4Ogre16ScriptTranslator12getStencilOpERKNS_9SharedPtrINS_12AbstractNodeEEEPNS_16StencilOperationE: 840| 15| { 841| 15| switch(getAtomId(node)) 842| 15| { 843| 0| case ID_KEEP: ------------------ | Branch (843:9): [True: 0, False: 15] ------------------ 844| 0| *op = SOP_KEEP; 845| 0| break; 846| 0| case ID_ZERO: ------------------ | Branch (846:9): [True: 0, False: 15] ------------------ 847| 0| *op = SOP_ZERO; 848| 0| break; 849| 0| case ID_REPLACE: ------------------ | Branch (849:9): [True: 0, False: 15] ------------------ 850| 0| *op = SOP_REPLACE; 851| 0| break; 852| 0| case ID_INCREMENT: ------------------ | Branch (852:9): [True: 0, False: 15] ------------------ 853| 0| *op = SOP_INCREMENT; 854| 0| break; 855| 0| case ID_DECREMENT: ------------------ | Branch (855:9): [True: 0, False: 15] ------------------ 856| 0| *op = SOP_DECREMENT; 857| 0| break; 858| 0| case ID_INCREMENT_WRAP: ------------------ | Branch (858:9): [True: 0, False: 15] ------------------ 859| 0| *op = SOP_INCREMENT_WRAP; 860| 0| break; 861| 0| case ID_DECREMENT_WRAP: ------------------ | Branch (861:9): [True: 0, False: 15] ------------------ 862| 0| *op = SOP_DECREMENT_WRAP; 863| 0| break; 864| 0| case ID_INVERT: ------------------ | Branch (864:9): [True: 0, False: 15] ------------------ 865| 0| *op = SOP_INVERT; 866| 0| break; 867| 15| default: ------------------ | Branch (867:9): [True: 15, False: 0] ------------------ 868| 15| return false; 869| 15| } 870| 0| return true; 871| 15| } _ZN4Ogre16ScriptTranslator15getConstantTypeENSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEEPNS_15GpuConstantTypeE: 874| 89| { 875| 89| const String& val = (*i)->getString(); 876| 89| if(val.empty()) ------------------ | Branch (876:12): [True: 1, False: 88] ------------------ 877| 1| return false; 878| | 879| 88| if (val.find("float") != String::npos) ------------------ | Branch (879:13): [True: 11, False: 77] ------------------ 880| 11| { 881| 11| int count = 1; 882| 11| if (val.size() == 6) ------------------ | Branch (882:17): [True: 7, False: 4] ------------------ 883| 7| count = StringConverter::parseInt(val.substr(5)); 884| 4| else if (val.size() > 6) ------------------ | Branch (884:22): [True: 1, False: 3] ------------------ 885| 1| return false; 886| | 887| 10| if (count > 4 || count == 0) ------------------ | Branch (887:17): [True: 0, False: 10] | Branch (887:30): [True: 1, False: 9] ------------------ 888| 1| return false; 889| | 890| 9| *op = (GpuConstantType)(GCT_FLOAT1 + count - 1); 891| 9| } 892| 77| else if (val.find("double") != String::npos) ------------------ | Branch (892:18): [True: 0, False: 77] ------------------ 893| 0| { 894| 0| int count = 1; 895| 0| if (val.size() == 7) ------------------ | Branch (895:17): [True: 0, False: 0] ------------------ 896| 0| count = StringConverter::parseInt(val.substr(6)); 897| 0| else if (val.size() > 7) ------------------ | Branch (897:22): [True: 0, False: 0] ------------------ 898| 0| return false; 899| | 900| 0| if (count > 4 || count == 0) ------------------ | Branch (900:17): [True: 0, False: 0] | Branch (900:30): [True: 0, False: 0] ------------------ 901| 0| return false; 902| | 903| 0| *op = (GpuConstantType)(GCT_DOUBLE1 + count - 1); 904| 0| } 905| 77| else if (val.find("uint") != String::npos) ------------------ | Branch (905:18): [True: 36, False: 41] ------------------ 906| 36| { 907| 36| int count = 1; 908| 36| if (val.size() == 5) ------------------ | Branch (908:17): [True: 3, False: 33] ------------------ 909| 3| count = StringConverter::parseInt(val.substr(4)); 910| 33| else if (val.size() > 5) ------------------ | Branch (910:22): [True: 9, False: 24] ------------------ 911| 9| return false; 912| | 913| 27| if (count > 4 || count == 0) ------------------ | Branch (913:17): [True: 0, False: 27] | Branch (913:30): [True: 1, False: 26] ------------------ 914| 1| return false; 915| | 916| 26| *op = (GpuConstantType)(GCT_UINT1 + count - 1); 917| 26| } 918| 41| else if (val.find("int") != String::npos) ------------------ | Branch (918:18): [True: 19, False: 22] ------------------ 919| 19| { 920| 19| int count = 1; 921| 19| if (val.size() == 4) ------------------ | Branch (921:17): [True: 1, False: 18] ------------------ 922| 1| count = StringConverter::parseInt(val.substr(3)); 923| 18| else if (val.size() > 4) ------------------ | Branch (923:22): [True: 3, False: 15] ------------------ 924| 3| return false; 925| | 926| 16| if (count > 4 || count == 0) ------------------ | Branch (926:17): [True: 0, False: 16] | Branch (926:30): [True: 1, False: 15] ------------------ 927| 1| return false; 928| | 929| 15| *op = (GpuConstantType)(GCT_INT1 + count - 1); 930| 15| } 931| 22| else if (val.find("bool") != String::npos) ------------------ | Branch (931:18): [True: 0, False: 22] ------------------ 932| 0| { 933| 0| int count = 1; 934| 0| if (val.size() == 5) ------------------ | Branch (934:17): [True: 0, False: 0] ------------------ 935| 0| count = StringConverter::parseInt(val.substr(4)); 936| 0| else if (val.size() > 5) ------------------ | Branch (936:22): [True: 0, False: 0] ------------------ 937| 0| return false; 938| | 939| 0| if (count > 4 || count == 0) ------------------ | Branch (939:17): [True: 0, False: 0] | Branch (939:30): [True: 0, False: 0] ------------------ 940| 0| return false; 941| | 942| 0| *op = (GpuConstantType)(GCT_BOOL1 + count - 1); 943| 0| } 944| 22| else if(val.find("matrix") != String::npos) ------------------ | Branch (944:17): [True: 1, False: 21] ------------------ 945| 1| { 946| 1| int count1, count2; 947| | 948| 1| if (val.size() == 9) ------------------ | Branch (948:17): [True: 0, False: 1] ------------------ 949| 0| { 950| 0| count1 = StringConverter::parseInt(val.substr(6, 1)); 951| 0| count2 = StringConverter::parseInt(val.substr(8, 1)); 952| 0| } 953| 1| else 954| 1| return false; 955| | 956| 0| if (count1 > 4 || count1 < 2 || count2 > 4 || count2 < 2) ------------------ | Branch (956:17): [True: 0, False: 0] | Branch (956:31): [True: 0, False: 0] | Branch (956:45): [True: 0, False: 0] | Branch (956:59): [True: 0, False: 0] ------------------ 957| 0| return false; 958| | 959| 0| switch(count1) ------------------ | Branch (959:20): [True: 0, False: 0] ------------------ 960| 0| { 961| 0| case 2: ------------------ | Branch (961:13): [True: 0, False: 0] ------------------ 962| 0| *op = (GpuConstantType)(GCT_MATRIX_2X2 + count2 - 2); 963| 0| break; 964| 0| case 3: ------------------ | Branch (964:13): [True: 0, False: 0] ------------------ 965| 0| *op = (GpuConstantType)(GCT_MATRIX_3X2 + count2 - 2); 966| 0| break; 967| 0| case 4: ------------------ | Branch (967:13): [True: 0, False: 0] ------------------ 968| 0| *op = (GpuConstantType)(GCT_MATRIX_4X2 + count2 - 2); 969| 0| break; 970| 0| } 971| | 972| 0| } 973| 21| else 974| 21| { 975| 21| return false; 976| 21| } 977| | 978| 50| return true; 979| 88| } _ZN4Ogre18MaterialTranslatorC2Ev: 985| 1| { 986| 1| } _ZN4Ogre18MaterialTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE: 989| 12.9k| { 990| 12.9k| ObjectAbstractNode *obj = static_cast(node.get()); 991| 12.9k| if(obj->name.empty()) ------------------ | Branch (991:12): [True: 13, False: 12.9k] ------------------ 992| 13| { 993| 13| compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line); 994| 13| return; 995| 13| } 996| | 997| 12.9k| Material* mMaterial = 0; 998| | 999| | // Create a material with the given name 1000| 12.9k| CreateMaterialScriptCompilerEvent evt(node->file, obj->name, compiler->getResourceGroup()); 1001| 12.9k| bool processed = compiler->_fireEvent(&evt, (void*)&mMaterial); 1002| | 1003| 12.9k| if(!processed) ------------------ | Branch (1003:12): [True: 12.9k, False: 0] ------------------ 1004| 12.9k| { 1005| 12.9k| mMaterial = MaterialManager::getSingleton().create(obj->name, compiler->getResourceGroup()).get(); 1006| 12.9k| } 1007| | 1008| 12.9k| if(!mMaterial) ------------------ | Branch (1008:12): [True: 0, False: 12.9k] ------------------ 1009| 0| { 1010| 0| compiler->addError(ScriptCompiler::CE_OBJECTALLOCATIONERROR, obj->file, obj->line, obj->name); 1011| 0| return; 1012| 0| } 1013| | 1014| 12.9k| mMaterial->removeAllTechniques(); 1015| 12.9k| obj->context = mMaterial; 1016| 12.9k| mMaterial->_notifyOrigin(obj->file); 1017| | 1018| 12.9k| bool bval; 1019| 12.9k| String sval; 1020| | 1021| 12.9k| for(auto & i : obj->children) ------------------ | Branch (1021:22): [True: 20.9k, False: 12.9k] ------------------ 1022| 20.9k| { 1023| 20.9k| if(i->type == ANT_PROPERTY) ------------------ | Branch (1023:16): [True: 2.83k, False: 18.1k] ------------------ 1024| 2.83k| { 1025| 2.83k| PropertyAbstractNode *prop = static_cast(i.get()); 1026| 2.83k| switch(prop->id) 1027| 2.83k| { 1028| 191| case ID_LOD_VALUES: ------------------ | Branch (1028:17): [True: 191, False: 2.64k] ------------------ 1029| 191| { 1030| 191| Material::LodValueList lods; 1031| 191| for(const auto& j : prop->values) ------------------ | Branch (1031:43): [True: 552, False: 191] ------------------ 1032| 552| { 1033| 552| Real v = 0; 1034| 552| if(getReal(j, &v)) ------------------ | Branch (1034:32): [True: 211, False: 341] ------------------ 1035| 211| lods.push_back(v); 1036| 341| else 1037| 341| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line, 1038| 341| "lod_values expects only numbers as arguments"); 1039| 552| } 1040| 191| mMaterial->setLodLevels(lods); 1041| 191| } 1042| 191| break; 1043| 0| case ID_LOD_DISTANCES: ------------------ | Branch (1043:17): [True: 0, False: 2.83k] ------------------ 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| 127| case ID_LOD_STRATEGY: ------------------ | Branch (1068:17): [True: 127, False: 2.70k] ------------------ 1069| 127| if(getValue(prop, compiler, sval)) ------------------ | Branch (1069:24): [True: 124, False: 3] ------------------ 1070| 124| { 1071| 124| if (sval == "Distance" || sval == "PixelCount") ------------------ | Branch (1071:33): [True: 0, False: 124] | Branch (1071:55): [True: 0, False: 124] ------------------ 1072| 0| compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line, 1073| 0| sval + ". use distance_box or pixel_count"); 1074| | 1075| 124| LodStrategy* strategy = LodStrategyManager::getSingleton().getStrategy(sval); 1076| 124| if (strategy) ------------------ | Branch (1076:33): [True: 0, False: 124] ------------------ 1077| 0| mMaterial->setLodStrategy(strategy); 1078| 124| else 1079| 124| compiler->addError(*prop, sval); 1080| 124| } 1081| 127| break; 1082| 181| case ID_RECEIVE_SHADOWS: ------------------ | Branch (1082:17): [True: 181, False: 2.65k] ------------------ 1083| 181| if(getValue(prop, compiler, bval)) ------------------ | Branch (1083:24): [True: 173, False: 8] ------------------ 1084| 173| mMaterial->setReceiveShadows(bval); 1085| 181| break; 1086| 82| case ID_TRANSPARENCY_CASTS_SHADOWS: ------------------ | Branch (1086:17): [True: 82, False: 2.75k] ------------------ 1087| 82| if(getValue(prop, compiler, bval)) ------------------ | Branch (1087:24): [True: 78, False: 4] ------------------ 1088| 78| mMaterial->setTransparencyCastsShadows(bval); 1089| 82| break; 1090| 22| case ID_SET_TEXTURE_ALIAS: ------------------ | Branch (1090:17): [True: 22, False: 2.81k] ------------------ 1091| 22| if(prop->values.size() != 2) ------------------ | Branch (1091:24): [True: 3, False: 19] ------------------ 1092| 3| { 1093| 3| compiler->addError(*prop, "set_texture_alias must have 2 string arguments"); 1094| 3| } 1095| 19| else 1096| 19| { 1097| 19| compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line, 1098| 19| "set_texture_alias. Use 'set $variable value'"); 1099| | 1100| 19| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1); 1101| 19| String name, value; 1102| 19| if(getString(*i0, &name) && getString(*i1, &value)) ------------------ | Branch (1102:28): [True: 19, False: 0] | Branch (1102:53): [True: 18, False: 1] ------------------ 1103| 18| mTextureAliases.insert(std::make_pair(name, value)); 1104| 19| } 1105| 22| break; 1106| 2.23k| default: ------------------ | Branch (1106:17): [True: 2.23k, False: 603] ------------------ 1107| 2.23k| compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line, 1108| 2.23k| "token \"" + prop->name + "\" is not recognized"); 1109| 2.83k| } 1110| 2.83k| } 1111| 18.1k| else if(i->type == ANT_OBJECT) ------------------ | Branch (1111:21): [True: 15.6k, False: 2.51k] ------------------ 1112| 15.6k| { 1113| 15.6k| processNode(compiler, i); 1114| 15.6k| } 1115| 20.9k| } 1116| | 1117| 12.9k| applyTextureAliases(compiler, mMaterial, mTextureAliases); 1118| 12.9k| mTextureAliases.clear(); 1119| 12.9k| } _ZN4Ogre19TechniqueTranslatorC2Ev: 1125| 1| :mTechnique(0) 1126| 1| { 1127| 1| } _ZN4Ogre19TechniqueTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE: 1130| 11.7k| { 1131| 11.7k| ObjectAbstractNode *obj = static_cast(node.get()); 1132| | 1133| | // Create the technique from the material 1134| 11.7k| Ogre::Material *material = Ogre::any_cast(obj->parent->context); 1135| 11.7k| mTechnique = material->createTechnique(); 1136| 11.7k| obj->context = mTechnique; 1137| | 1138| | // Get the name of the technique 1139| 11.7k| if(!obj->name.empty()) ------------------ | Branch (1139:12): [True: 1.84k, False: 9.85k] ------------------ 1140| 1.84k| mTechnique->setName(obj->name); 1141| | 1142| 11.7k| uint32 uival; 1143| 11.7k| String sval; 1144| | 1145| | // Set the properties for the material 1146| 11.7k| for(auto & i : obj->children) ------------------ | Branch (1146:22): [True: 22.7k, False: 11.7k] ------------------ 1147| 22.7k| { 1148| 22.7k| if(i->type == ANT_PROPERTY) ------------------ | Branch (1148:16): [True: 5.17k, False: 17.5k] ------------------ 1149| 5.17k| { 1150| 5.17k| PropertyAbstractNode *prop = static_cast(i.get()); 1151| 5.17k| switch(prop->id) 1152| 5.17k| { 1153| 193| case ID_SCHEME: ------------------ | Branch (1153:17): [True: 193, False: 4.98k] ------------------ 1154| 193| if(getValue(prop, compiler, sval)) ------------------ | Branch (1154:24): [True: 189, False: 4] ------------------ 1155| 189| mTechnique->setSchemeName(sval); 1156| 193| break; 1157| 4| case ID_LOD_INDEX: ------------------ | Branch (1157:17): [True: 4, False: 5.16k] ------------------ 1158| 4| if(getValue(prop, compiler, uival)) ------------------ | Branch (1158:24): [True: 0, False: 4] ------------------ 1159| 0| mTechnique->setLodIndex(static_cast(uival)); 1160| 4| break; 1161| 157| case ID_SHADOW_CASTER_MATERIAL: ------------------ | Branch (1161:17): [True: 157, False: 5.01k] ------------------ 1162| 157| if (getValue(prop, compiler, sval)) ------------------ | Branch (1162:25): [True: 148, False: 9] ------------------ 1163| 148| { 1164| 148| try 1165| 148| { 1166| 148| mTechnique->setShadowCasterMaterial(processResourceName(compiler, ResourceType::MATERIAL, sval)); 1167| 148| } 1168| 148| catch (Exception& e) 1169| 148| { 1170| 0| compiler->addError(*prop, e.getDescription()); 1171| 0| } 1172| 148| } 1173| 157| break; 1174| 157| case ID_SHADOW_RECEIVER_MATERIAL: ------------------ | Branch (1174:17): [True: 36, False: 5.13k] ------------------ 1175| 36| if (getValue(prop, compiler, sval)) ------------------ | Branch (1175:25): [True: 16, False: 20] ------------------ 1176| 16| { 1177| 16| try 1178| 16| { 1179| 16| mTechnique->setShadowReceiverMaterial(processResourceName(compiler, ResourceType::MATERIAL, sval)); 1180| 16| } 1181| 16| catch (Exception& e) 1182| 16| { 1183| 0| compiler->addError(*prop, e.getDescription()); 1184| 0| } 1185| 16| } 1186| 36| break; 1187| 38| case ID_GPU_VENDOR_RULE: ------------------ | Branch (1187:17): [True: 38, False: 5.13k] ------------------ 1188| 38| if(prop->values.size() < 2) ------------------ | Branch (1188:24): [True: 3, False: 35] ------------------ 1189| 3| { 1190| 3| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line, 1191| 3| "gpu_vendor_rule must have 2 arguments"); 1192| 3| } 1193| 35| else if(prop->values.size() > 2) ------------------ | Branch (1193:29): [True: 2, False: 33] ------------------ 1194| 2| { 1195| 2| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 1196| 2| "gpu_vendor_rule must have 2 arguments"); 1197| 2| } 1198| 33| else 1199| 33| { 1200| 33| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0); 1201| 33| AbstractNodeList::const_iterator i1 = getNodeAt(prop->values, 1); 1202| | 1203| 33| Technique::GPUVendorRule rule; 1204| 33| uint32 id0 = getAtomId(*i0); 1205| 33| if (id0 == ID_INCLUDE) ------------------ | Branch (1205:29): [True: 0, False: 33] ------------------ 1206| 0| { 1207| 0| rule.includeOrExclude = Technique::INCLUDE; 1208| 0| } 1209| 33| else if (id0 == ID_EXCLUDE) ------------------ | Branch (1209:34): [True: 0, False: 33] ------------------ 1210| 0| { 1211| 0| rule.includeOrExclude = Technique::EXCLUDE; 1212| 0| } 1213| 33| else 1214| 33| { 1215| 33| compiler->addError(*prop, "gpu_vendor_rule cannot accept \"" + (*i0)->getValue() + "\" as first argument"); 1216| 33| } 1217| | 1218| 33| String vendor; 1219| 33| if(!getString(*i1, &vendor)) ------------------ | Branch (1219:28): [True: 7, False: 26] ------------------ 1220| 7| compiler->addError(*prop, "gpu_vendor_rule cannot accept \"" + (*i1)->getValue() + "\" as second argument"); 1221| | 1222| 33| rule.vendor = RenderSystemCapabilities::vendorFromString(vendor); 1223| | 1224| 33| if (rule.vendor != GPU_UNKNOWN) ------------------ | Branch (1224:29): [True: 0, False: 33] ------------------ 1225| 0| { 1226| 0| mTechnique->addGPUVendorRule(rule); 1227| 0| } 1228| 33| } 1229| 38| break; 1230| 2.14k| case ID_GPU_DEVICE_RULE: ------------------ | Branch (1230:17): [True: 2.14k, False: 3.03k] ------------------ 1231| 2.14k| if(prop->values.size() < 2) ------------------ | Branch (1231:24): [True: 28, False: 2.11k] ------------------ 1232| 28| { 1233| 28| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line, 1234| 28| "gpu_device_rule must have at least 2 arguments"); 1235| 28| } 1236| 2.11k| else if(prop->values.size() > 3) ------------------ | Branch (1236:29): [True: 192, False: 1.92k] ------------------ 1237| 192| { 1238| 192| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 1239| 192| "gpu_device_rule must have at most 3 arguments"); 1240| 192| } 1241| 1.92k| else 1242| 1.92k| { 1243| 1.92k| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0); 1244| 1.92k| AbstractNodeList::const_iterator i1 = getNodeAt(prop->values, 1); 1245| | 1246| 1.92k| Technique::GPUDeviceNameRule rule; 1247| 1.92k| uint32 id0 = getAtomId(*i0); 1248| 1.92k| if (id0 == ID_INCLUDE) ------------------ | Branch (1248:29): [True: 0, False: 1.92k] ------------------ 1249| 0| { 1250| 0| rule.includeOrExclude = Technique::INCLUDE; 1251| 0| } 1252| 1.92k| else if (id0 == ID_EXCLUDE) ------------------ | Branch (1252:34): [True: 0, False: 1.92k] ------------------ 1253| 0| { 1254| 0| rule.includeOrExclude = Technique::EXCLUDE; 1255| 0| } 1256| 1.92k| else 1257| 1.92k| { 1258| 1.92k| compiler->addError(*prop, "gpu_device_rule cannot accept \"" + (*i0)->getValue() + "\" as first argument"); 1259| 1.92k| } 1260| | 1261| 1.92k| if(!getString(*i1, &rule.devicePattern)) ------------------ | Branch (1261:28): [True: 54, False: 1.86k] ------------------ 1262| 54| compiler->addError(*prop, "gpu_device_rule cannot accept \"" + (*i1)->getValue() + "\" as second argument"); 1263| | 1264| 1.92k| if (prop->values.size() == 3) ------------------ | Branch (1264:29): [True: 409, False: 1.51k] ------------------ 1265| 409| { 1266| 409| AbstractNodeList::const_iterator i2 = getNodeAt(prop->values, 2); 1267| 409| if (!getBoolean(*i2, &rule.caseSensitive)) ------------------ | Branch (1267:33): [True: 405, False: 4] ------------------ 1268| 405| compiler->addError(*prop, "gpu_device_rule third argument must be \"true\", \"false\", \"yes\", \"no\", \"on\", or \"off\""); 1269| 409| } 1270| | 1271| 1.92k| mTechnique->addGPUDeviceNameRule(rule); 1272| 1.92k| } 1273| 2.14k| break; 1274| 2.60k| default: ------------------ | Branch (1274:17): [True: 2.60k, False: 2.56k] ------------------ 1275| 2.60k| compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line, 1276| 2.60k| "token \"" + prop->name + "\" is not recognized"); 1277| 5.17k| } 1278| 5.17k| } 1279| 17.5k| else if(i->type == ANT_OBJECT) ------------------ | Branch (1279:21): [True: 14.1k, False: 3.37k] ------------------ 1280| 14.1k| { 1281| 14.1k| processNode(compiler, i); 1282| 14.1k| } 1283| 22.7k| } 1284| 11.7k| } _ZN4Ogre14PassTranslatorC2Ev: 1290| 1| :mPass(0) 1291| 1| { 1292| 1| } _ZN4Ogre14PassTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE: 1295| 11.5k| { 1296| 11.5k| ObjectAbstractNode *obj = static_cast(node.get()); 1297| | 1298| 11.5k| Technique *technique = any_cast(obj->parent->context); 1299| 11.5k| mPass = technique->createPass(); 1300| 11.5k| obj->context = mPass; 1301| | 1302| | // Get the name of the technique 1303| 11.5k| if(!obj->name.empty()) ------------------ | Branch (1303:12): [True: 2.40k, False: 9.19k] ------------------ 1304| 2.40k| mPass->setName(obj->name); 1305| | 1306| 11.5k| Real fval; 1307| 11.5k| bool bval; 1308| 11.5k| uint32 uival; 1309| | 1310| | // Set the properties for the material 1311| 11.5k| for(auto & i : obj->children) ------------------ | Branch (1311:22): [True: 50.5k, False: 11.5k] ------------------ 1312| 50.5k| { 1313| 50.5k| if(i->type == ANT_PROPERTY) ------------------ | Branch (1313:16): [True: 26.7k, False: 23.8k] ------------------ 1314| 26.7k| { 1315| 26.7k| PropertyAbstractNode *prop = static_cast(i.get()); 1316| 26.7k| switch(prop->id) 1317| 26.7k| { 1318| 2.31k| case ID_AMBIENT: ------------------ | Branch (1318:17): [True: 2.31k, False: 24.4k] ------------------ 1319| 2.31k| if(prop->values.empty()) ------------------ | Branch (1319:24): [True: 1, False: 2.30k] ------------------ 1320| 1| { 1321| 1| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line); 1322| 1| } 1323| 2.30k| else if(prop->values.size() > 4) ------------------ | Branch (1323:29): [True: 296, False: 2.01k] ------------------ 1324| 296| { 1325| 296| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 1326| 296| "ambient must have at most 4 parameters"); 1327| 296| } 1328| 2.01k| else 1329| 2.01k| { 1330| 2.01k| if(getAtomId(prop->values.front()) == ID_VERTEXCOLOUR) ------------------ | Branch (1330:28): [True: 7, False: 2.00k] ------------------ 1331| 7| { 1332| 7| mPass->setVertexColourTracking(mPass->getVertexColourTracking() | TVC_AMBIENT); 1333| 7| } 1334| 2.00k| else 1335| 2.00k| { 1336| 2.00k| ColourValue val = ColourValue::White; 1337| 2.00k| if(getColour(prop->values.begin(), prop->values.end(), &val)) ------------------ | Branch (1337:32): [True: 1.89k, False: 108] ------------------ 1338| 1.89k| mPass->setAmbient(val); 1339| 108| else 1340| 108| compiler->addError(*prop, "ambient requires 3 or 4 colour arguments, or a \"vertexcolour\" directive"); 1341| 2.00k| } 1342| 2.01k| } 1343| 2.31k| break; 1344| 2.57k| case ID_DIFFUSE: ------------------ | Branch (1344:17): [True: 2.57k, False: 24.1k] ------------------ 1345| 2.57k| if(prop->values.empty()) ------------------ | Branch (1345:24): [True: 1, False: 2.57k] ------------------ 1346| 1| { 1347| 1| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line); 1348| 1| } 1349| 2.57k| else if(prop->values.size() > 4) ------------------ | Branch (1349:29): [True: 47, False: 2.52k] ------------------ 1350| 47| { 1351| 47| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 1352| 47| "diffuse must have at most 4 arguments"); 1353| 47| } 1354| 2.52k| else 1355| 2.52k| { 1356| 2.52k| if(getAtomId(prop->values.front()) == ID_VERTEXCOLOUR) ------------------ | Branch (1356:28): [True: 437, False: 2.09k] ------------------ 1357| 437| { 1358| 437| mPass->setVertexColourTracking(mPass->getVertexColourTracking() | TVC_DIFFUSE); 1359| 437| } 1360| 2.09k| else 1361| 2.09k| { 1362| 2.09k| ColourValue val = ColourValue::White; 1363| 2.09k| if(getColour(prop->values.begin(), prop->values.end(), &val)) ------------------ | Branch (1363:32): [True: 1.90k, False: 192] ------------------ 1364| 1.90k| mPass->setDiffuse(val); 1365| 192| else 1366| 192| compiler->addError(*prop, "diffuse requires 3 or 4 colour arguments, or a \"vertexcolour\" directive"); 1367| 2.09k| } 1368| 2.52k| } 1369| 2.57k| break; 1370| 681| case ID_SPECULAR: ------------------ | Branch (1370:17): [True: 681, False: 26.0k] ------------------ 1371| 681| if(prop->values.empty()) ------------------ | Branch (1371:24): [True: 5, False: 676] ------------------ 1372| 5| { 1373| 5| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line); 1374| 5| } 1375| 676| else if(prop->values.size() > 5) ------------------ | Branch (1375:29): [True: 12, False: 664] ------------------ 1376| 12| { 1377| 12| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 1378| 12| "specular must have at most 5 arguments"); 1379| 12| } 1380| 664| else 1381| 664| { 1382| 664| if(getAtomId(prop->values.front()) == ID_VERTEXCOLOUR) ------------------ | Branch (1382:28): [True: 5, False: 659] ------------------ 1383| 5| { 1384| 5| mPass->setVertexColourTracking(mPass->getVertexColourTracking() | TVC_SPECULAR); 1385| | 1386| 5| if(prop->values.size() >= 2) ------------------ | Branch (1386:32): [True: 0, False: 5] ------------------ 1387| 0| { 1388| 0| Real val = 0; 1389| 0| if(getReal(prop->values.back(), &val)) ------------------ | Branch (1389:36): [True: 0, False: 0] ------------------ 1390| 0| mPass->setShininess(val); 1391| 0| else 1392| 0| compiler->addError(*prop, "specular does not support \"" + prop->values.back()->getValue() + "\" as its second argument"); 1393| 0| } 1394| 5| } 1395| 659| else 1396| 659| { 1397| 659| if(prop->values.size() < 4) ------------------ | Branch (1397:32): [True: 32, False: 627] ------------------ 1398| 32| { 1399| 32| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line, 1400| 32| "specular expects at least 4 arguments"); 1401| 32| } 1402| 627| else 1403| 627| { 1404| 627| ColourValue val; 1405| 627| if(getColour(prop->values.begin(), prop->values.end(), &val)) ------------------ | Branch (1405:36): [True: 559, False: 68] ------------------ 1406| 559| { 1407| 559| if(prop->values.size() == 4) ------------------ | Branch (1407:40): [True: 385, False: 174] ------------------ 1408| 385| { 1409| 385| mPass->setShininess(val.a); 1410| 385| val.a = 1.0f; 1411| 385| mPass->setSpecular(val); 1412| 385| } 1413| 174| else 1414| 174| { 1415| 174| mPass->setSpecular(val); 1416| | 1417| 174| Real shininess; 1418| 174| if(getReal(*getNodeAt(prop->values, 4), &shininess)) ------------------ | Branch (1418:44): [True: 160, False: 14] ------------------ 1419| 160| mPass->setShininess(shininess); 1420| 14| else 1421| 14| compiler->addError(*prop, "specular fourth argument must be a valid number for shininess attribute"); 1422| 174| } 1423| 559| } 1424| 68| else 1425| 68| { 1426| 68| compiler->addError(*prop, "specular must have first 3 arguments be a valid colour"); 1427| 68| } 1428| 627| } 1429| | 1430| 659| } 1431| 664| } 1432| 681| break; 1433| 252| case ID_EMISSIVE: ------------------ | Branch (1433:17): [True: 252, False: 26.5k] ------------------ 1434| 252| if(prop->values.empty()) ------------------ | Branch (1434:24): [True: 0, False: 252] ------------------ 1435| 0| { 1436| 0| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line); 1437| 0| } 1438| 252| else if(prop->values.size() > 4) ------------------ | Branch (1438:29): [True: 15, False: 237] ------------------ 1439| 15| { 1440| 15| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 1441| 15| "emissive must have at most 4 arguments"); 1442| 15| } 1443| 237| else 1444| 237| { 1445| 237| if(getAtomId(prop->values.front()) == ID_VERTEXCOLOUR) ------------------ | Branch (1445:28): [True: 46, False: 191] ------------------ 1446| 46| { 1447| 46| mPass->setVertexColourTracking(mPass->getVertexColourTracking() | TVC_EMISSIVE); 1448| 46| } 1449| 191| else 1450| 191| { 1451| 191| ColourValue val(0.0f, 0.0f, 0.0f, 1.0f); 1452| 191| if(getColour(prop->values.begin(), prop->values.end(), &val)) ------------------ | Branch (1452:32): [True: 147, False: 44] ------------------ 1453| 147| mPass->setSelfIllumination(val); 1454| 44| else 1455| 44| compiler->addError(*prop, "emissive requires 3 or 4 colour arguments, or a \"vertexcolour\" directive"); 1456| 191| } 1457| 237| } 1458| 252| break; 1459| 3.04k| case ID_SCENE_BLEND: ------------------ | Branch (1459:17): [True: 3.04k, False: 23.7k] ------------------ 1460| 3.04k| if(prop->values.size() == 1) ------------------ | Branch (1460:24): [True: 2.96k, False: 80] ------------------ 1461| 2.96k| { 1462| 2.96k| SceneBlendType enval; 1463| 2.96k| if(getValue(prop->values.front(), enval)) ------------------ | Branch (1463:28): [True: 2.82k, False: 144] ------------------ 1464| 2.82k| { 1465| 2.82k| mPass->setSceneBlending(enval); 1466| 2.82k| } 1467| 144| else 1468| 144| { 1469| 144| compiler->addError(*prop, prop->values.front()->getString()); 1470| 144| } 1471| 2.96k| } 1472| 80| else if(prop->values.size() == 2) ------------------ | Branch (1472:29): [True: 51, False: 29] ------------------ 1473| 51| { 1474| 51| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1); 1475| 51| SceneBlendFactor sbf0, sbf1; 1476| 51| if(getSceneBlendFactor(*i0, &sbf0) && getSceneBlendFactor(*i1, &sbf1)) ------------------ | Branch (1476:28): [True: 0, False: 51] | Branch (1476:63): [True: 0, False: 0] ------------------ 1477| 0| { 1478| 0| mPass->setSceneBlending(sbf0, sbf1); 1479| 0| } 1480| 51| else 1481| 51| { 1482| 51| compiler->addError(*prop, "scene_blend does not support \"" + (*i0)->getValue() + "\" and \"" + (*i1)->getValue() + "\" as arguments"); 1483| 51| } 1484| 51| } 1485| 29| else 1486| 29| { 1487| 29| compiler->addError(*prop, "scene_blend must have 1 or 2 arguments"); 1488| 29| } 1489| 3.04k| break; 1490| 27| case ID_SEPARATE_SCENE_BLEND: ------------------ | Branch (1490:17): [True: 27, False: 26.7k] ------------------ 1491| 27| if(prop->values.size() == 2) ------------------ | Branch (1491:24): [True: 4, False: 23] ------------------ 1492| 4| { 1493| 4| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1); 1494| 4| SceneBlendType sbt0, sbt1; 1495| 4| if (getValue(*i0, sbt0) && getValue(*i1, sbt1)) ------------------ | Branch (1495:29): [True: 0, False: 4] | Branch (1495:52): [True: 0, False: 0] ------------------ 1496| 0| { 1497| 0| mPass->setSeparateSceneBlending(sbt0, sbt1); 1498| 0| } 1499| 4| else 1500| 4| { 1501| 4| compiler->addError(*prop, "one of the arguments to separate_scene_blend is not a valid " 1502| 4| "scene blend factor directive"); 1503| 4| } 1504| 4| } 1505| 23| else if(prop->values.size() == 4) ------------------ | Branch (1505:29): [True: 6, False: 17] ------------------ 1506| 6| { 1507| 6| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1), 1508| 6| i2 = getNodeAt(prop->values, 2), i3 = getNodeAt(prop->values, 3); 1509| 6| SceneBlendFactor sbf0, sbf1, sbf2, sbf3; 1510| 6| if(getSceneBlendFactor(*i0, &sbf0) && getSceneBlendFactor(*i1, &sbf1) && getSceneBlendFactor(*i2, &sbf2) && ------------------ | Branch (1510:28): [True: 0, False: 6] | Branch (1510:63): [True: 0, False: 0] | Branch (1510:98): [True: 0, False: 0] ------------------ 1511| 0| getSceneBlendFactor(*i3, &sbf3)) ------------------ | Branch (1511:29): [True: 0, False: 0] ------------------ 1512| 0| { 1513| 0| mPass->setSeparateSceneBlending(sbf0, sbf1, sbf2, sbf3); 1514| 0| } 1515| 6| else 1516| 6| { 1517| 6| compiler->addError(*prop, "one of the arguments to separate_scene_blend is not a valid " 1518| 6| "scene blend factor"); 1519| 6| } 1520| 6| } 1521| 17| else 1522| 17| { 1523| 17| compiler->addError(*prop, "separate_scene_blend must have 2 or 4 arguments"); 1524| 17| } 1525| 27| break; 1526| 14| case ID_SCENE_BLEND_OP: ------------------ | Branch (1526:17): [True: 14, False: 26.7k] ------------------ 1527| 14| SceneBlendOperation sop; 1528| 14| if(getValue(prop, compiler, sop)) ------------------ | Branch (1528:24): [True: 0, False: 14] ------------------ 1529| 0| mPass->setSceneBlendingOperation(sop); 1530| 14| break; 1531| 26| case ID_SEPARATE_SCENE_BLEND_OP: ------------------ | Branch (1531:17): [True: 26, False: 26.7k] ------------------ 1532| 26| if(prop->values.empty()) ------------------ | Branch (1532:24): [True: 0, False: 26] ------------------ 1533| 0| { 1534| 0| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 1535| 0| } 1536| 26| else if(prop->values.size() != 2) ------------------ | Branch (1536:29): [True: 14, False: 12] ------------------ 1537| 14| { 1538| 14| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 1539| 14| "separate_scene_blend_op must have 2 arguments"); 1540| 14| } 1541| 12| else 1542| 12| { 1543| 12| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1); 1544| 12| SceneBlendOperation op, alphaOp; 1545| 12| if(getValue(*i0, op) && getValue(*i1, alphaOp)) ------------------ | Branch (1545:28): [True: 0, False: 12] | Branch (1545:49): [True: 0, False: 0] ------------------ 1546| 0| { 1547| 0| mPass->setSeparateSceneBlendingOperation(op, alphaOp); 1548| 0| } 1549| 12| else 1550| 12| { 1551| 12| compiler->addError(*prop, prop->values.front()->getValue() + ": unrecognized argument"); 1552| 12| } 1553| 12| } 1554| 26| break; 1555| 945| case ID_DEPTH_CHECK: ------------------ | Branch (1555:17): [True: 945, False: 25.8k] ------------------ 1556| 945| if(getValue(prop, compiler, bval)) ------------------ | Branch (1556:24): [True: 840, False: 105] ------------------ 1557| 840| mPass->setDepthCheckEnabled(bval); 1558| 945| break; 1559| 3.40k| case ID_DEPTH_WRITE: ------------------ | Branch (1559:17): [True: 3.40k, False: 23.3k] ------------------ 1560| 3.40k| if(getValue(prop, compiler, bval)) ------------------ | Branch (1560:24): [True: 3.13k, False: 276] ------------------ 1561| 3.13k| mPass->setDepthWriteEnabled(bval); 1562| 3.40k| break; 1563| 147| case ID_DEPTH_BIAS: ------------------ | Branch (1563:17): [True: 147, False: 26.6k] ------------------ 1564| 147| if(prop->values.empty()) ------------------ | Branch (1564:24): [True: 0, False: 147] ------------------ 1565| 0| { 1566| 0| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 1567| 0| } 1568| 147| else if(prop->values.size() > 2) ------------------ | Branch (1568:29): [True: 3, False: 144] ------------------ 1569| 3| { 1570| 3| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 1571| 3| "depth_bias must have at most 2 arguments"); 1572| 3| } 1573| 144| else 1574| 144| { 1575| 144| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1); 1576| 144| float val0, val1 = 0.0f; 1577| 144| if(getFloat(*i0, &val0)) ------------------ | Branch (1577:28): [True: 26, False: 118] ------------------ 1578| 26| { 1579| 26| if(i1 != prop->values.end()) ------------------ | Branch (1579:32): [True: 20, False: 6] ------------------ 1580| 20| getFloat(*i1, &val1); 1581| 26| mPass->setDepthBias(val0, val1); 1582| 26| } 1583| 118| else 1584| 118| { 1585| 118| compiler->addError(*prop, "depth_bias does not support \"" + (*i0)->getValue() + "\" for argument 1"); 1586| 118| } 1587| 144| } 1588| 147| break; 1589| 161| case ID_DEPTH_FUNC: ------------------ | Branch (1589:17): [True: 161, False: 26.5k] ------------------ 1590| 161| CompareFunction dfunc; 1591| 161| if(getValue(prop, compiler, dfunc)) ------------------ | Branch (1591:24): [True: 111, False: 50] ------------------ 1592| 111| mPass->setDepthFunction(dfunc); 1593| 161| break; 1594| 16| case ID_ITERATION_DEPTH_BIAS: ------------------ | Branch (1594:17): [True: 16, False: 26.7k] ------------------ 1595| 16| if(getValue(prop, compiler, fval)) ------------------ | Branch (1595:24): [True: 3, False: 13] ------------------ 1596| 3| mPass->setIterationDepthBias(fval); 1597| 16| break; 1598| 150| case ID_ALPHA_REJECTION: ------------------ | Branch (1598:17): [True: 150, False: 26.6k] ------------------ 1599| 150| if(prop->values.empty()) ------------------ | Branch (1599:24): [True: 0, False: 150] ------------------ 1600| 0| { 1601| 0| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 1602| 0| } 1603| 150| else if(prop->values.size() > 2) ------------------ | Branch (1603:29): [True: 12, False: 138] ------------------ 1604| 12| { 1605| 12| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 1606| 12| "alpha_rejection must have at most 2 arguments"); 1607| 12| } 1608| 138| else 1609| 138| { 1610| 138| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1); 1611| 138| CompareFunction func; 1612| 138| if(getCompareFunction(*i0, &func)) ------------------ | Branch (1612:28): [True: 104, False: 34] ------------------ 1613| 104| { 1614| 104| if(i1 != prop->values.end()) ------------------ | Branch (1614:32): [True: 101, False: 3] ------------------ 1615| 101| { 1616| 101| uint32 val = 0; 1617| 101| if(getUInt(*i1, &val)) ------------------ | Branch (1617:36): [True: 79, False: 22] ------------------ 1618| 79| mPass->setAlphaRejectSettings(func, static_cast(val)); 1619| 22| else 1620| 22| compiler->addError(*prop, (*i1)->getValue() + " is not a valid integer"); 1621| 101| } 1622| 3| else 1623| 3| mPass->setAlphaRejectFunction(func); 1624| 104| } 1625| 34| else 1626| 34| compiler->addError(*prop, (*i0)->getValue() + " is not a valid CompareFunction"); 1627| 138| } 1628| 150| break; 1629| 5| case ID_ALPHA_TO_COVERAGE: ------------------ | Branch (1629:17): [True: 5, False: 26.7k] ------------------ 1630| 5| if(getValue(prop, compiler, bval)) ------------------ | Branch (1630:24): [True: 0, False: 5] ------------------ 1631| 0| mPass->setAlphaToCoverageEnabled(bval); 1632| 5| break; 1633| 18| case ID_LIGHT_SCISSOR: ------------------ | Branch (1633:17): [True: 18, False: 26.7k] ------------------ 1634| 18| if(getValue(prop, compiler, bval)) ------------------ | Branch (1634:24): [True: 3, False: 15] ------------------ 1635| 3| mPass->setLightScissoringEnabled(bval); 1636| 18| break; 1637| 17| case ID_LIGHT_CLIP_PLANES: ------------------ | Branch (1637:17): [True: 17, False: 26.7k] ------------------ 1638| 17| if(getValue(prop, compiler, bval)) ------------------ | Branch (1638:24): [True: 3, False: 14] ------------------ 1639| 3| mPass->setLightClipPlanesEnabled(bval); 1640| 17| break; 1641| 10| case ID_TRANSPARENT_SORTING: ------------------ | Branch (1641:17): [True: 10, False: 26.7k] ------------------ 1642| 10| if(prop->values.empty()) ------------------ | Branch (1642:24): [True: 0, False: 10] ------------------ 1643| 0| { 1644| 0| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 1645| 0| } 1646| 10| else if(prop->values.size() > 1) ------------------ | Branch (1646:29): [True: 5, False: 5] ------------------ 1647| 5| { 1648| 5| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 1649| 5| "transparent_sorting must have at most 1 argument"); 1650| 5| } 1651| 5| else 1652| 5| { 1653| 5| bool val = true; 1654| 5| if(getBoolean(prop->values.front(), &val)) ------------------ | Branch (1654:28): [True: 0, False: 5] ------------------ 1655| 0| { 1656| 0| mPass->setTransparentSortingEnabled(val); 1657| 0| mPass->setTransparentSortingForced(false); 1658| 0| } 1659| 5| else 1660| 5| { 1661| 5| String val2; 1662| 5| if (prop->values.front()->getString()=="force") ------------------ | Branch (1662:33): [True: 0, False: 5] ------------------ 1663| 0| { 1664| 0| mPass->setTransparentSortingEnabled(true); 1665| 0| mPass->setTransparentSortingForced(true); 1666| 0| } 1667| 5| else 1668| 5| { 1669| 5| compiler->addError(*prop, prop->values.front()->getValue() + " must be boolean or force"); 1670| 5| } 1671| 5| } 1672| 5| } 1673| 10| break; 1674| 39| case ID_ILLUMINATION_STAGE: ------------------ | Branch (1674:17): [True: 39, False: 26.7k] ------------------ 1675| 39| IlluminationStage is; 1676| 39| if(getValue(prop, compiler, is)) ------------------ | Branch (1676:24): [True: 5, False: 34] ------------------ 1677| 5| mPass->setIlluminationStage(is); 1678| 39| break; 1679| 2.49k| case ID_CULL_HARDWARE: ------------------ | Branch (1679:17): [True: 2.49k, False: 24.2k] ------------------ 1680| 2.49k| CullingMode cmode; 1681| 2.49k| if(getValue(prop, compiler, cmode)) ------------------ | Branch (1681:24): [True: 2.34k, False: 152] ------------------ 1682| 2.34k| mPass->setCullingMode(cmode); 1683| 2.49k| break; 1684| 72| case ID_CULL_SOFTWARE: ------------------ | Branch (1684:17): [True: 72, False: 26.6k] ------------------ 1685| 72| ManualCullingMode mmode; 1686| 72| if(getValue(prop, compiler, mmode)) ------------------ | Branch (1686:24): [True: 38, False: 34] ------------------ 1687| 38| mPass->setManualCullingMode(mmode); 1688| 72| compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line, 1689| 72| prop->name + ". Only used by the BSP scene manager."); 1690| 72| break; 1691| 4.56k| case ID_LIGHTING: ------------------ | Branch (1691:17): [True: 4.56k, False: 22.1k] ------------------ 1692| 4.56k| if(getValue(prop, compiler, bval)) ------------------ | Branch (1692:24): [True: 4.45k, False: 110] ------------------ 1693| 4.45k| mPass->setLightingEnabled(bval); 1694| 4.56k| break; 1695| 58| case ID_SHADING: ------------------ | Branch (1695:17): [True: 58, False: 26.7k] ------------------ 1696| 58| ShadeOptions smode; 1697| 58| if(getValue(prop, compiler, smode)) ------------------ | Branch (1697:24): [True: 0, False: 58] ------------------ 1698| 0| mPass->setShadingMode(smode); 1699| 58| break; 1700| 82| case ID_POLYGON_MODE: ------------------ | Branch (1700:17): [True: 82, False: 26.6k] ------------------ 1701| 82| PolygonMode pmode; 1702| 82| if(getValue(prop, compiler, pmode)) ------------------ | Branch (1702:24): [True: 5, False: 77] ------------------ 1703| 5| mPass->setPolygonMode(pmode); 1704| 82| break; 1705| 141| case ID_POLYGON_MODE_OVERRIDEABLE: ------------------ | Branch (1705:17): [True: 141, False: 26.6k] ------------------ 1706| 141| if(getValue(prop, compiler, bval)) ------------------ | Branch (1706:24): [True: 124, False: 17] ------------------ 1707| 124| mPass->setPolygonModeOverrideable(bval); 1708| 141| break; 1709| 140| case ID_FOG_OVERRIDE: ------------------ | Branch (1709:17): [True: 140, False: 26.6k] ------------------ 1710| 140| if(prop->values.empty()) ------------------ | Branch (1710:24): [True: 2, False: 138] ------------------ 1711| 2| { 1712| 2| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 1713| 2| } 1714| 138| else if(prop->values.size() > 8) ------------------ | Branch (1714:29): [True: 6, False: 132] ------------------ 1715| 6| { 1716| 6| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 1717| 6| "fog_override must have at most 8 arguments"); 1718| 6| } 1719| 132| else 1720| 132| { 1721| 132| AbstractNodeList::const_iterator i1 = getNodeAt(prop->values, 1), i2 = getNodeAt(prop->values, 2); 1722| 132| bool val = false; 1723| 132| if(getBoolean(prop->values.front(), &val)) ------------------ | Branch (1723:28): [True: 102, False: 30] ------------------ 1724| 102| { 1725| 102| FogMode mode = FOG_NONE; 1726| 102| ColourValue clr = ColourValue::White; 1727| 102| Real dens = 0.001, start = 0.0f, end = 1.0f; 1728| | 1729| 102| if(i1 != prop->values.end()) ------------------ | Branch (1729:32): [True: 91, False: 11] ------------------ 1730| 91| { 1731| 91| if((*i1)->type == ANT_ATOM) ------------------ | Branch (1731:36): [True: 89, False: 2] ------------------ 1732| 89| { 1733| 89| AtomAbstractNode *atom = (AtomAbstractNode*)(*i1).get(); 1734| 89| switch(atom->id) 1735| 89| { 1736| 57| case ID_NONE: ------------------ | Branch (1736:37): [True: 57, False: 32] ------------------ 1737| 57| mode = FOG_NONE; 1738| 57| break; 1739| 0| case ID_LINEAR: ------------------ | Branch (1739:37): [True: 0, False: 89] ------------------ 1740| 0| mode = FOG_LINEAR; 1741| 0| break; 1742| 0| case ID_EXP: ------------------ | Branch (1742:37): [True: 0, False: 89] ------------------ 1743| 0| mode = FOG_EXP; 1744| 0| break; 1745| 0| case ID_EXP2: ------------------ | Branch (1745:37): [True: 0, False: 89] ------------------ 1746| 0| mode = FOG_EXP2; 1747| 0| break; 1748| 32| default: ------------------ | Branch (1748:37): [True: 32, False: 57] ------------------ 1749| 32| compiler->addError(*prop, (*i1)->getValue() + " is not a valid FogMode"); 1750| 32| break; 1751| 89| } 1752| 89| } 1753| 2| else 1754| 2| { 1755| 2| compiler->addError(*prop, (*i1)->getValue() + " is not a valid FogMode"); 1756| 2| break; 1757| 2| } 1758| 91| } 1759| | 1760| 100| if(i2 != prop->values.end()) ------------------ | Branch (1760:32): [True: 23, False: 77] ------------------ 1761| 23| { 1762| 23| if(!getColour(i2, prop->values.end(), &clr, 3)) ------------------ | Branch (1762:36): [True: 13, False: 10] ------------------ 1763| 13| { 1764| 13| compiler->addError(*prop, (*i2)->getValue() + " is not a valid colour"); 1765| 13| break; 1766| 13| } 1767| | 1768| 10| i2 = getNodeAt(prop->values, 5); 1769| 10| } 1770| | 1771| 87| if(i2 != prop->values.end()) ------------------ | Branch (1771:32): [True: 9, False: 78] ------------------ 1772| 9| { 1773| 9| if(!getReal(*i2, &dens)) ------------------ | Branch (1773:36): [True: 2, False: 7] ------------------ 1774| 2| { 1775| 2| compiler->addError(*prop, (*i2)->getValue() + " is not a valid number"); 1776| 2| break; 1777| 2| } 1778| 7| ++i2; 1779| 7| } 1780| | 1781| 85| if(i2 != prop->values.end()) ------------------ | Branch (1781:32): [True: 5, False: 80] ------------------ 1782| 5| { 1783| 5| if(!getReal(*i2, &start)) ------------------ | Branch (1783:36): [True: 2, False: 3] ------------------ 1784| 2| { 1785| 2| compiler->addError(*prop, (*i2)->getValue() + " is not a valid number"); 1786| 2| return; 1787| 2| } 1788| 3| ++i2; 1789| 3| } 1790| | 1791| 83| if(i2 != prop->values.end()) ------------------ | Branch (1791:32): [True: 3, False: 80] ------------------ 1792| 3| { 1793| 3| if(!getReal(*i2, &end)) ------------------ | Branch (1793:36): [True: 2, False: 1] ------------------ 1794| 2| { 1795| 2| compiler->addError(*prop, (*i2)->getValue() + " is not a valid number"); 1796| 2| return; 1797| 2| } 1798| 1| ++i2; 1799| 1| } 1800| | 1801| 81| mPass->setFog(val, mode, clr, dens, start, end); 1802| 81| } 1803| 30| else 1804| 30| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid boolean"); 1805| 132| } 1806| 119| break; 1807| 119| case ID_COLOUR_WRITE: ------------------ | Branch (1807:17): [True: 25, False: 26.7k] ------------------ 1808| 25| if(prop->values.empty()) ------------------ | Branch (1808:24): [True: 0, False: 25] ------------------ 1809| 0| { 1810| 0| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 1811| 0| } 1812| 25| else if(prop->values.size() == 1) ------------------ | Branch (1812:29): [True: 9, False: 16] ------------------ 1813| 9| { 1814| 9| if(getValue(prop, compiler, bval)) ------------------ | Branch (1814:28): [True: 0, False: 9] ------------------ 1815| 0| mPass->setColourWriteEnabled(bval); 1816| 9| } 1817| 16| else if(prop->values.size() != 4) ------------------ | Branch (1817:29): [True: 12, False: 4] ------------------ 1818| 12| { 1819| 12| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 1820| 12| "colour_write must have exactly 1 or 4 arguments"); 1821| 12| } 1822| 4| else 1823| 4| { 1824| 4| bool colourMask[] = {false ,false ,false, false}; 1825| | 1826| 4| uint8 channelIndex = 0; 1827| 4| for(const AbstractNodePtr& abstractNode : prop->values) ------------------ | Branch (1827:65): [True: 4, False: 0] ------------------ 1828| 4| { 1829| 4| if(!getBoolean(abstractNode, &colourMask[channelIndex++])) ------------------ | Branch (1829:32): [True: 4, False: 0] ------------------ 1830| 4| { 1831| 4| compiler->addError(*prop, abstractNode->getValue() + " is not a valid boolean"); 1832| 4| break; 1833| 4| } 1834| 4| } 1835| | 1836| 4| mPass->setColourWriteEnabled(colourMask[0], colourMask[1], colourMask[2], colourMask[3]); 1837| 4| } 1838| 25| break; 1839| 228| case ID_MAX_LIGHTS: ------------------ | Branch (1839:17): [True: 228, False: 26.5k] ------------------ 1840| 228| if(getValue(prop, compiler, uival)) ------------------ | Branch (1840:24): [True: 217, False: 11] ------------------ 1841| 217| mPass->setMaxSimultaneousLights(Math::uint16Cast(uival)); 1842| 228| break; 1843| 53| case ID_START_LIGHT: ------------------ | Branch (1843:17): [True: 53, False: 26.7k] ------------------ 1844| 53| if(getValue(prop, compiler, uival)) ------------------ | Branch (1844:24): [True: 17, False: 36] ------------------ 1845| 17| mPass->setStartLight(static_cast(uival)); 1846| 53| break; 1847| 0| case ID_LIGHT_MASK: ------------------ | Branch (1847:17): [True: 0, False: 26.7k] ------------------ 1848| 0| if(getValue(prop, compiler, uival)) ------------------ | Branch (1848:24): [True: 0, False: 0] ------------------ 1849| 0| mPass->setLightMask(static_cast(uival)); 1850| 0| break; 1851| 282| case ID_ITERATION: ------------------ | Branch (1851:17): [True: 282, False: 26.4k] ------------------ 1852| 282| { 1853| 282| if(prop->values.empty()) ------------------ | Branch (1853:24): [True: 0, False: 282] ------------------ 1854| 0| { 1855| 0| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 1856| 0| break; 1857| 0| } 1858| | 1859| 282| auto setLightType = [this, prop, compiler](AbstractNodeList::const_iterator it) 1860| 282| { 1861| 282| if(it == prop->values.end()) 1862| 282| { 1863| 282| mPass->setIteratePerLight(true, false); 1864| 282| return; 1865| 282| } 1866| 282| switch(getAtomId(*it)) 1867| 282| { 1868| 282| case ID_POINT: 1869| 282| mPass->setIteratePerLight(true, true, Light::LT_POINT); 1870| 282| break; 1871| 282| case ID_DIRECTIONAL: 1872| 282| mPass->setIteratePerLight(true, true, Light::LT_DIRECTIONAL); 1873| 282| break; 1874| 282| case ID_SPOT: 1875| 282| mPass->setIteratePerLight(true, true, Light::LT_SPOTLIGHT); 1876| 282| break; 1877| 282| default: 1878| 282| compiler->addError(*prop, (*it)->getValue() + " is not a valid light type (point, directional, or spot)"); 1879| 282| } 1880| 282| }; 1881| | 1882| 282| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0); 1883| 282| auto atomid = getAtomId(*i0); 1884| 282| if(atomid == ID_ONCE) ------------------ | Branch (1884:24): [True: 12, False: 270] ------------------ 1885| 12| { 1886| 12| mPass->setIteratePerLight(false); 1887| 12| } 1888| 270| else if(atomid == ID_ONCE_PER_LIGHT) ------------------ | Branch (1888:29): [True: 181, False: 89] ------------------ 1889| 181| { 1890| 181| setLightType(getNodeAt(prop->values, 1)); 1891| 181| } 1892| 89| else if(getValue(*i0, uival)) ------------------ | Branch (1892:29): [True: 61, False: 28] ------------------ 1893| 61| { 1894| 61| mPass->setPassIterationCount(uival); 1895| | 1896| 61| AbstractNodeList::const_iterator i1 = getNodeAt(prop->values, 1); 1897| 61| if(i1 != prop->values.end()) ------------------ | Branch (1897:28): [True: 58, False: 3] ------------------ 1898| 58| { 1899| 58| atomid = getAtomId(*i1); 1900| 58| if(atomid == ID_PER_LIGHT) ------------------ | Branch (1900:32): [True: 0, False: 58] ------------------ 1901| 0| { 1902| 0| setLightType(getNodeAt(prop->values, 2)); 1903| 0| } 1904| 58| else if(atomid == ID_PER_N_LIGHTS) ------------------ | Branch (1904:37): [True: 51, False: 7] ------------------ 1905| 51| { 1906| 51| AbstractNodeList::const_iterator i2 = getNodeAt(prop->values, 2); 1907| 51| if(i2 != prop->values.end() && getValue(*i2, uival)) ------------------ | Branch (1907:36): [True: 49, False: 2] | Branch (1907:36): [True: 42, False: 9] | Branch (1907:64): [True: 42, False: 7] ------------------ 1908| 42| { 1909| 42| mPass->setLightCountPerIteration(static_cast(uival)); 1910| 42| setLightType(getNodeAt(prop->values, 3)); 1911| 42| } 1912| 9| else 1913| 9| { 1914| 9| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line, 1915| 9| "per_n_lights requires a light count"); 1916| 9| } 1917| 51| } 1918| 58| } 1919| 61| } 1920| 28| else 1921| 28| { 1922| 28| compiler->addError(*prop); 1923| 28| } 1924| 282| } 1925| 0| break; 1926| 0| case ID_LINE_WIDTH: ------------------ | Branch (1926:17): [True: 0, False: 26.7k] ------------------ 1927| 0| if(getValue(prop, compiler, fval)) ------------------ | Branch (1927:24): [True: 0, False: 0] ------------------ 1928| 0| mPass->setLineWidth(fval); 1929| 0| break; 1930| 96| case ID_POINT_SIZE: ------------------ | Branch (1930:17): [True: 96, False: 26.6k] ------------------ 1931| 96| if(getValue(prop, compiler, fval)) ------------------ | Branch (1931:24): [True: 76, False: 20] ------------------ 1932| 76| mPass->setPointSize(fval); 1933| 96| break; 1934| 94| case ID_POINT_SPRITES: ------------------ | Branch (1934:17): [True: 94, False: 26.6k] ------------------ 1935| 94| if(getValue(prop, compiler, bval)) ------------------ | Branch (1935:24): [True: 81, False: 13] ------------------ 1936| 81| mPass->setPointSpritesEnabled(bval); 1937| 94| break; 1938| 103| case ID_POINT_SIZE_ATTENUATION: ------------------ | Branch (1938:17): [True: 103, False: 26.6k] ------------------ 1939| 103| if(prop->values.empty()) ------------------ | Branch (1939:24): [True: 2, False: 101] ------------------ 1940| 2| { 1941| 2| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 1942| 2| } 1943| 101| else if(prop->values.size() > 4) ------------------ | Branch (1943:29): [True: 6, False: 95] ------------------ 1944| 6| { 1945| 6| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 1946| 6| "point_size_attenuation must have at most 4 arguments"); 1947| 6| } 1948| 95| else 1949| 95| { 1950| 95| bool val = false; 1951| 95| if(getBoolean(prop->values.front(), &val)) ------------------ | Branch (1951:28): [True: 76, False: 19] ------------------ 1952| 76| { 1953| 76| if(val) ------------------ | Branch (1953:32): [True: 76, False: 0] ------------------ 1954| 76| { 1955| 76| if (prop->values.size() > 1) ------------------ | Branch (1955:37): [True: 4, False: 72] ------------------ 1956| 4| { 1957| 4| std::vector data; 1958| 4| if(prop->values.size() != 4 || !getVector(++prop->values.begin(), prop->values.end(), data, 3)) ------------------ | Branch (1958:40): [True: 2, False: 2] | Branch (1958:40): [True: 3, False: 1] | Branch (1958:68): [True: 1, False: 1] ------------------ 1959| 3| { 1960| 3| compiler->addError(*prop); 1961| 3| return; 1962| 3| } 1963| 1| mPass->setPointAttenuation(true, data[0], data[1], data[2]); 1964| 1| } 1965| 72| else 1966| 72| { 1967| 72| mPass->setPointAttenuation(true); 1968| 72| } 1969| 76| } 1970| 0| else 1971| 0| { 1972| 0| mPass->setPointAttenuation(false); 1973| 0| } 1974| 76| } 1975| 19| else 1976| 19| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid boolean"); 1977| 95| } 1978| 100| break; 1979| 100| case ID_POINT_SIZE_MIN: ------------------ | Branch (1979:17): [True: 21, False: 26.7k] ------------------ 1980| 21| if(getValue(prop, compiler, fval)) ------------------ | Branch (1980:24): [True: 6, False: 15] ------------------ 1981| 6| mPass->setPointMinSize(fval); 1982| 21| break; 1983| 14| case ID_POINT_SIZE_MAX: ------------------ | Branch (1983:17): [True: 14, False: 26.7k] ------------------ 1984| 14| if(getValue(prop, compiler, fval)) ------------------ | Branch (1984:24): [True: 3, False: 11] ------------------ 1985| 3| mPass->setPointMaxSize(fval); 1986| 14| break; 1987| 4.44k| default: ------------------ | Branch (1987:17): [True: 4.44k, False: 22.3k] ------------------ 1988| 4.44k| compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line, 1989| 4.44k| "token \"" + prop->name + "\" is not recognized"); 1990| 26.7k| } 1991| 26.7k| } 1992| 23.8k| else if(i->type == ANT_OBJECT) ------------------ | Branch (1992:21): [True: 21.0k, False: 2.78k] ------------------ 1993| 21.0k| { 1994| 21.0k| ObjectAbstractNode *child = static_cast(i.get()); 1995| 21.0k| switch(child->id) 1996| 21.0k| { 1997| 864| case ID_FRAGMENT_PROGRAM_REF: ------------------ | Branch (1997:17): [True: 864, False: 20.1k] ------------------ 1998| 1.63k| case ID_VERTEX_PROGRAM_REF: ------------------ | Branch (1998:17): [True: 769, False: 20.2k] ------------------ 1999| 1.69k| case ID_GEOMETRY_PROGRAM_REF: ------------------ | Branch (1999:17): [True: 57, False: 20.9k] ------------------ 2000| 3.33k| case ID_TESSELLATION_HULL_PROGRAM_REF: ------------------ | Branch (2000:17): [True: 1.64k, False: 19.3k] ------------------ 2001| 4.24k| case ID_TESSELLATION_DOMAIN_PROGRAM_REF: ------------------ | Branch (2001:17): [True: 910, False: 20.1k] ------------------ 2002| 4.25k| case ID_COMPUTE_PROGRAM_REF: ------------------ | Branch (2002:17): [True: 15, False: 21.0k] ------------------ 2003| 4.25k| case ID_MESH_PROGRAM_REF: ------------------ | Branch (2003:17): [True: 1, False: 21.0k] ------------------ 2004| 4.25k| case ID_TASK_PROGRAM_REF: ------------------ | Branch (2004:17): [True: 0, False: 21.0k] ------------------ 2005| 4.25k| translateProgramRef(getProgramType(child->id), compiler, child); 2006| 4.25k| break; 2007| 6| case ID_SHADOW_CASTER_VERTEX_PROGRAM_REF: ------------------ | Branch (2007:17): [True: 6, False: 21.0k] ------------------ 2008| 6| translateShadowCasterProgramRef(GPT_VERTEX_PROGRAM, compiler, child); 2009| 6| break; 2010| 14| case ID_SHADOW_CASTER_FRAGMENT_PROGRAM_REF: ------------------ | Branch (2010:17): [True: 14, False: 21.0k] ------------------ 2011| 14| translateShadowCasterProgramRef(GPT_FRAGMENT_PROGRAM, compiler, child); 2012| 14| break; 2013| 10| case ID_SHADOW_RECEIVER_VERTEX_PROGRAM_REF: ------------------ | Branch (2013:17): [True: 10, False: 21.0k] ------------------ 2014| 10| translateShadowReceiverProgramRef(GPT_VERTEX_PROGRAM, compiler, child); 2015| 10| break; 2016| 9| case ID_SHADOW_RECEIVER_FRAGMENT_PROGRAM_REF: ------------------ | Branch (2016:17): [True: 9, False: 21.0k] ------------------ 2017| 9| translateShadowReceiverProgramRef(GPT_FRAGMENT_PROGRAM, compiler, child); 2018| 9| break; 2019| 16.2k| default: ------------------ | Branch (2019:17): [True: 16.2k, False: 4.82k] ------------------ 2020| 16.2k| processNode(compiler, i); 2021| 16.2k| break; 2022| 252| case ID_FRAGMENT_PROGRAM: ------------------ | Branch (2022:17): [True: 252, False: 20.7k] ------------------ 2023| 408| case ID_VERTEX_PROGRAM: ------------------ | Branch (2023:17): [True: 156, False: 20.8k] ------------------ 2024| 443| case ID_GEOMETRY_PROGRAM: ------------------ | Branch (2024:17): [True: 35, False: 20.9k] ------------------ 2025| 476| case ID_TESSELLATION_HULL_PROGRAM: ------------------ | Branch (2025:17): [True: 33, False: 20.9k] ------------------ 2026| 511| case ID_TESSELLATION_DOMAIN_PROGRAM: ------------------ | Branch (2026:17): [True: 35, False: 20.9k] ------------------ 2027| 520| case ID_COMPUTE_PROGRAM: ------------------ | Branch (2027:17): [True: 9, False: 21.0k] ------------------ 2028| 526| case ID_MESH_PROGRAM: ------------------ | Branch (2028:17): [True: 6, False: 21.0k] ------------------ 2029| 526| case ID_TASK_PROGRAM: ------------------ | Branch (2029:17): [True: 0, False: 21.0k] ------------------ 2030| 526| { 2031| | // auto assign inline defined programs 2032| 526| processNode(compiler, i); 2033| 526| GpuProgramType type = getProgramType(child->id); 2034| 526| mPass->setGpuProgram(type, GpuProgramUsage::_getProgramByName(child->name, mPass->getResourceGroup(), type)); 2035| 526| } 2036| 21.0k| } 2037| 21.0k| } 2038| 50.5k| } 2039| 11.5k| } _ZN4Ogre14PassTranslator19translateProgramRefENS_14GpuProgramTypeEPNS_14ScriptCompilerEPNS_18ObjectAbstractNodeE: 2066| 4.25k| { 2067| 4.25k| auto program = getProgram(compiler, node); 2068| 4.25k| if(!program) return; ------------------ | Branch (2068:12): [True: 1.76k, False: 2.49k] ------------------ 2069| 2.49k| auto pass = any_cast(node->parent->context); 2070| | 2071| 2.49k| pass->setGpuProgram(type, program); 2072| 2.49k| if(program->isSupported()) ------------------ | Branch (2072:12): [True: 0, False: 2.49k] ------------------ 2073| 0| { 2074| 0| GpuProgramParametersSharedPtr params = pass->getGpuProgramParameters(type); 2075| 0| GpuProgramTranslator::translateProgramParameters(compiler, params, node); 2076| 0| } 2077| 2.49k| } _ZN4Ogre14PassTranslator31translateShadowCasterProgramRefENS_14GpuProgramTypeEPNS_14ScriptCompilerEPNS_18ObjectAbstractNodeE: 2080| 20| { 2081| 20| auto program = getProgram(compiler, node); 2082| 20| if(!program) return; ------------------ | Branch (2082:12): [True: 20, False: 0] ------------------ 2083| 0| auto pass = any_cast(node->parent->context); 2084| | 2085| 0| compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, node->file, node->line, 2086| 0| node->cls + ". Use shadow_caster_material instead"); 2087| | 2088| 0| auto caster_mat = pass->getParent()->getShadowCasterMaterial(); 2089| 0| if(!caster_mat) ------------------ | Branch (2089:12): [True: 0, False: 0] ------------------ 2090| 0| { 2091| 0| auto src_mat = pass->getParent()->getParent(); 2092| | // only first pass of this will be used. The caster material is technique specific. 2093| 0| caster_mat = src_mat->clone( 2094| 0| StringUtil::format("%s/%p/CasterFallback", src_mat->getName().c_str(), pass->getParent())); 2095| 0| pass->getParent()->setShadowCasterMaterial(caster_mat); 2096| 0| } 2097| 0| auto caster_pass = caster_mat->getTechnique(0)->getPass(0); 2098| | 2099| 0| caster_pass->setGpuProgram(type, program); 2100| 0| if(program->isSupported()) ------------------ | Branch (2100:12): [True: 0, False: 0] ------------------ 2101| 0| { 2102| 0| GpuProgramParametersSharedPtr params = caster_pass->getGpuProgramParameters(type); 2103| 0| GpuProgramTranslator::translateProgramParameters(compiler, params, node); 2104| 0| } 2105| 0| } _ZN4Ogre14PassTranslator33translateShadowReceiverProgramRefENS_14GpuProgramTypeEPNS_14ScriptCompilerEPNS_18ObjectAbstractNodeE: 2108| 19| { 2109| 19| auto program = getProgram(compiler, node); 2110| 19| if(!program) return; ------------------ | Branch (2110:12): [True: 19, False: 0] ------------------ 2111| 0| auto pass = any_cast(node->parent->context); 2112| | 2113| 0| compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, node->file, node->line, 2114| 0| node->cls + ". Use shadow_receiver_material instead"); 2115| | 2116| 0| auto receiver_mat = pass->getParent()->getShadowReceiverMaterial(); 2117| 0| if(!receiver_mat) ------------------ | Branch (2117:12): [True: 0, False: 0] ------------------ 2118| 0| { 2119| 0| auto src_mat = pass->getParent()->getParent(); 2120| | // only first pass of this will be used 2121| 0| receiver_mat = src_mat->clone(src_mat->getName()+"/ReceiverFallback"); 2122| 0| pass->getParent()->setShadowReceiverMaterial(receiver_mat); 2123| 0| } 2124| 0| auto receiver_pass = receiver_mat->getTechnique(0)->getPass(0); 2125| | 2126| 0| receiver_pass->setGpuProgram(type, program); 2127| 0| if(program->isSupported()) ------------------ | Branch (2127:12): [True: 0, False: 0] ------------------ 2128| 0| { 2129| 0| GpuProgramParametersSharedPtr params = receiver_pass->getGpuProgramParameters(type); 2130| 0| GpuProgramTranslator::translateProgramParameters(compiler, params, node); 2131| 0| } 2132| 0| } _ZN4Ogre21TextureUnitTranslatorC2Ev: 2137| 1| :mUnit(0) 2138| 1| { 2139| 1| } _ZN4Ogre17SamplerTranslator21translateSamplerParamEPNS_14ScriptCompilerERKNSt3__110shared_ptrINS_7SamplerEEEPNS_20PropertyAbstractNodeE: 2142| 6.91k| { 2143| 6.91k| bool bval; 2144| 6.91k| Real fval; 2145| 6.91k| uint32 uival; 2146| | 2147| 6.91k| switch(prop->id) ------------------ | Branch (2147:16): [True: 6.91k, False: 0] ------------------ 2148| 6.91k| { 2149| 3.62k| case ID_TEX_ADDRESS_MODE: ------------------ | Branch (2149:9): [True: 3.62k, False: 3.29k] ------------------ 2150| 3.62k| { 2151| 3.62k| if(prop->values.empty()) ------------------ | Branch (2151:20): [True: 3, False: 3.61k] ------------------ 2152| 3| { 2153| 3| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 2154| 3| } 2155| 3.61k| else 2156| 3.61k| { 2157| 3.61k| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), 2158| 3.61k| i1 = getNodeAt(prop->values, 1), 2159| 3.61k| i2 = getNodeAt(prop->values, 2); 2160| 3.61k| Sampler::UVWAddressingMode mode; 2161| | 2162| 3.61k| if(!getValue(*i0, mode.u)) ------------------ | Branch (2162:24): [True: 121, False: 3.49k] ------------------ 2163| 121| { 2164| 121| compiler->addError(*prop, (*i0)->getValue() + " not supported as first argument (must be \"wrap\", \"clamp\", \"mirror\", or \"border\")"); 2165| 121| return; 2166| 121| } 2167| 3.49k| mode.v = mode.u; 2168| 3.49k| mode.w = mode.u; 2169| | 2170| 3.49k| if(i1 != prop->values.end()) ------------------ | Branch (2170:24): [True: 14, False: 3.48k] ------------------ 2171| 14| { 2172| 14| if(!getValue(*i1, mode.v)) ------------------ | Branch (2172:28): [True: 13, False: 1] ------------------ 2173| 13| { 2174| 13| compiler->addError(*prop, (*i1)->getValue() + " not supported as second argument (must be \"wrap\", \"clamp\", \"mirror\", or \"border\")"); 2175| 13| } 2176| 14| } 2177| | 2178| 3.49k| if(i2 != prop->values.end()) ------------------ | Branch (2178:24): [True: 9, False: 3.48k] ------------------ 2179| 9| { 2180| 9| if(!getValue(*i2, mode.w)) ------------------ | Branch (2180:28): [True: 8, False: 1] ------------------ 2181| 8| { 2182| 8| compiler->addError(*prop, (*i2)->getValue() + " not supported as third argument (must be \"wrap\", \"clamp\", \"mirror\", or \"border\")"); 2183| 8| } 2184| 9| } 2185| | 2186| 3.49k| sampler->setAddressingMode(mode); 2187| 3.49k| } 2188| 3.62k| } 2189| 3.49k| break; 2190| 3.49k| case ID_TEX_BORDER_COLOUR: ------------------ | Branch (2190:9): [True: 89, False: 6.82k] ------------------ 2191| 89| if(prop->values.empty()) ------------------ | Branch (2191:16): [True: 0, False: 89] ------------------ 2192| 0| { 2193| 0| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line); 2194| 0| } 2195| 89| else 2196| 89| { 2197| 89| ColourValue val; 2198| 89| if(getColour(prop->values.begin(), prop->values.end(), &val)) ------------------ | Branch (2198:20): [True: 26, False: 63] ------------------ 2199| 26| sampler->setBorderColour(val); 2200| 63| else 2201| 63| compiler->addError(*prop, "tex_border_colour only accepts a colour argument"); 2202| 89| } 2203| 89| break; 2204| 3.04k| case ID_FILTERING: ------------------ | Branch (2204:9): [True: 3.04k, False: 3.87k] ------------------ 2205| 3.04k| if(prop->values.empty()) ------------------ | Branch (2205:16): [True: 1, False: 3.04k] ------------------ 2206| 1| { 2207| 1| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 2208| 1| } 2209| 3.04k| else if(prop->values.size() == 1) ------------------ | Branch (2209:21): [True: 2.63k, False: 406] ------------------ 2210| 2.63k| { 2211| 2.63k| switch(getAtomId(prop->values.front())) 2212| 2.63k| { 2213| 2.26k| case ID_NONE: ------------------ | Branch (2213:17): [True: 2.26k, False: 368] ------------------ 2214| 2.26k| sampler->setFiltering(TFO_NONE); 2215| 2.26k| break; 2216| 13| case ID_BILINEAR: ------------------ | Branch (2216:17): [True: 13, False: 2.62k] ------------------ 2217| 13| sampler->setFiltering(TFO_BILINEAR); 2218| 13| break; 2219| 163| case ID_TRILINEAR: ------------------ | Branch (2219:17): [True: 163, False: 2.47k] ------------------ 2220| 163| sampler->setFiltering(TFO_TRILINEAR); 2221| 163| break; 2222| 3| case ID_ANISOTROPIC: ------------------ | Branch (2222:17): [True: 3, False: 2.63k] ------------------ 2223| 3| sampler->setFiltering(TFO_ANISOTROPIC); 2224| 3| break; 2225| 189| default: ------------------ | Branch (2225:17): [True: 189, False: 2.44k] ------------------ 2226| 189| compiler->addError(*prop, prop->values.front()->getValue() + " not supported as first argument (must be \"none\", \"bilinear\", \"trilinear\", or \"anisotropic\")"); 2227| 2.63k| } 2228| 2.63k| } 2229| 406| else if(prop->values.size() == 3) ------------------ | Branch (2229:21): [True: 381, False: 25] ------------------ 2230| 381| { 2231| 381| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), 2232| 381| i1 = getNodeAt(prop->values, 1), 2233| 381| i2 = getNodeAt(prop->values, 2); 2234| 381| FilterOptions tmin, tmax, tmip; 2235| 381| if (getValue(*i0, tmin) && getValue(*i1, tmax) && getValue(*i2, tmip)) ------------------ | Branch (2235:21): [True: 308, False: 73] | Branch (2235:44): [True: 284, False: 24] | Branch (2235:67): [True: 277, False: 7] ------------------ 2236| 277| { 2237| 277| sampler->setFiltering(tmin, tmax, tmip); 2238| 277| } 2239| 104| else 2240| 104| { 2241| 104| compiler->addError(*prop); 2242| 104| } 2243| 381| } 2244| 25| else 2245| 25| { 2246| 25| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 2247| 25| "filtering must have either 1 or 3 arguments"); 2248| 25| } 2249| 3.04k| break; 2250| 3.04k| case ID_CMPTEST: ------------------ | Branch (2250:9): [True: 119, False: 6.79k] ------------------ 2251| 119| if(getValue(prop, compiler, bval)) ------------------ | Branch (2251:16): [True: 3, False: 116] ------------------ 2252| 3| sampler->setCompareEnabled(bval); 2253| 119| break; 2254| 0| case ID_CMPFUNC: ------------------ | Branch (2254:9): [True: 0, False: 6.91k] ------------------ 2255| 0| compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, 2256| 0| prop->line, 2257| 0| "compare_func. Use comp_func."); 2258| 0| OGRE_FALLTHROUGH; 2259| 24| case ID_COMP_FUNC: ------------------ | Branch (2259:9): [True: 24, False: 6.89k] ------------------ 2260| 24| CompareFunction func; 2261| 24| if(getValue(prop, compiler, func)) ------------------ | Branch (2261:16): [True: 3, False: 21] ------------------ 2262| 3| sampler->setCompareFunction(func); 2263| 24| break; 2264| 14| case ID_MAX_ANISOTROPY: ------------------ | Branch (2264:9): [True: 14, False: 6.90k] ------------------ 2265| 14| if(getValue(prop, compiler, uival)) ------------------ | Branch (2265:16): [True: 4, False: 10] ------------------ 2266| 4| sampler->setAnisotropy(uival); 2267| 14| break; 2268| 9| case ID_MIPMAP_BIAS: ------------------ | Branch (2268:9): [True: 9, False: 6.90k] ------------------ 2269| 9| if(getValue(prop, compiler, fval)) ------------------ | Branch (2269:16): [True: 1, False: 8] ------------------ 2270| 1| sampler->setMipmapBias(fval); 2271| 9| break; 2272| 6.91k| } 2273| 6.91k| } _ZN4Ogre17SamplerTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE: 2275| 281| { 2276| 281| ObjectAbstractNode *obj = static_cast(node.get()); 2277| | 2278| 281| if(obj->name.empty()) ------------------ | Branch (2278:12): [True: 75, False: 206] ------------------ 2279| 75| { 2280| 75| compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line); 2281| 75| return; 2282| 75| } 2283| | 2284| 206| SamplerPtr sampler = TextureManager::getSingleton().createSampler(obj->name); 2285| | 2286| | // Set the properties for the material 2287| 206| for(auto & i : obj->children) ------------------ | Branch (2287:22): [True: 855, False: 206] ------------------ 2288| 855| { 2289| 855| if(i->type == ANT_PROPERTY) ------------------ | Branch (2289:16): [True: 738, False: 117] ------------------ 2290| 738| { 2291| 738| PropertyAbstractNode *prop = static_cast(i.get()); 2292| 738| switch(prop->id) 2293| 738| { 2294| 22| case ID_TEX_ADDRESS_MODE: ------------------ | Branch (2294:17): [True: 22, False: 716] ------------------ 2295| 31| case ID_TEX_BORDER_COLOUR: ------------------ | Branch (2295:17): [True: 9, False: 729] ------------------ 2296| 70| case ID_FILTERING: ------------------ | Branch (2296:17): [True: 39, False: 699] ------------------ 2297| 183| case ID_CMPTEST: ------------------ | Branch (2297:17): [True: 113, False: 625] ------------------ 2298| 186| case ID_COMP_FUNC: ------------------ | Branch (2298:17): [True: 3, False: 735] ------------------ 2299| 190| case ID_MAX_ANISOTROPY: ------------------ | Branch (2299:17): [True: 4, False: 734] ------------------ 2300| 191| case ID_MIPMAP_BIAS: ------------------ | Branch (2300:17): [True: 1, False: 737] ------------------ 2301| 191| translateSamplerParam(compiler, sampler, prop); 2302| 191| break; 2303| 547| default: ------------------ | Branch (2303:17): [True: 547, False: 191] ------------------ 2304| 547| compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line, 2305| 547| "token \"" + prop->name + "\" is not recognized"); 2306| 738| } 2307| 738| } 2308| 117| else if(i->type == ANT_OBJECT) ------------------ | Branch (2308:21): [True: 53, False: 64] ------------------ 2309| 53| { 2310| 53| processNode(compiler, i); 2311| 53| } 2312| 855| } 2313| 206| } _ZN4Ogre21TextureUnitTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE: 2316| 12.7k| { 2317| 12.7k| ObjectAbstractNode *obj = static_cast(node.get()); 2318| | 2319| 12.7k| Pass *pass = any_cast(obj->parent->context); 2320| 12.7k| mUnit = pass->createTextureUnitState(); 2321| 12.7k| obj->context = mUnit; 2322| | 2323| | // Get the name of the technique 2324| 12.7k| if(!obj->name.empty()) ------------------ | Branch (2324:12): [True: 2.79k, False: 9.96k] ------------------ 2325| 2.79k| mUnit->setName(obj->name); 2326| | 2327| 12.7k| Real fval; 2328| 12.7k| uint32 uival; 2329| 12.7k| String sval; 2330| | 2331| | // Set the properties for the material 2332| 12.7k| for(auto & i : obj->children) ------------------ | Branch (2332:22): [True: 31.8k, False: 12.7k] ------------------ 2333| 31.8k| { 2334| 31.8k| if(i->type == ANT_PROPERTY) ------------------ | Branch (2334:16): [True: 28.7k, False: 3.10k] ------------------ 2335| 28.7k| { 2336| 28.7k| PropertyAbstractNode *prop = static_cast(i.get()); 2337| 28.7k| switch(prop->id) 2338| 28.7k| { 2339| 3.59k| case ID_TEX_ADDRESS_MODE: ------------------ | Branch (2339:17): [True: 3.59k, False: 25.1k] ------------------ 2340| 3.67k| case ID_TEX_BORDER_COLOUR: ------------------ | Branch (2340:17): [True: 80, False: 28.6k] ------------------ 2341| 6.68k| case ID_FILTERING: ------------------ | Branch (2341:17): [True: 3.00k, False: 25.7k] ------------------ 2342| 6.68k| case ID_CMPTEST: ------------------ | Branch (2342:17): [True: 6, False: 28.7k] ------------------ 2343| 6.68k| case ID_CMPFUNC: ------------------ | Branch (2343:17): [True: 0, False: 28.7k] ------------------ 2344| 6.70k| case ID_COMP_FUNC: ------------------ | Branch (2344:17): [True: 21, False: 28.7k] ------------------ 2345| 6.71k| case ID_MAX_ANISOTROPY: ------------------ | Branch (2345:17): [True: 10, False: 28.7k] ------------------ 2346| 6.72k| case ID_MIPMAP_BIAS: ------------------ | Branch (2346:17): [True: 8, False: 28.7k] ------------------ 2347| 6.72k| SamplerTranslator::translateSamplerParam(compiler, mUnit->_getLocalSampler(), prop); 2348| 6.72k| break; 2349| 446| case ID_SAMPLER_REF: ------------------ | Branch (2349:17): [True: 446, False: 28.2k] ------------------ 2350| 446| if(getValue(prop, compiler, sval)) ------------------ | Branch (2350:24): [True: 439, False: 7] ------------------ 2351| 439| { 2352| 439| auto sampler = TextureManager::getSingleton().getSampler(sval); 2353| 439| if(sampler) ------------------ | Branch (2353:28): [True: 375, False: 64] ------------------ 2354| 375| mUnit->setSampler(sampler); 2355| 64| else 2356| 64| compiler->addError(ScriptCompiler::CE_REFERENCETOANONEXISTINGOBJECT, 2357| 64| prop->file, prop->line, sval); 2358| 439| } 2359| 446| break; 2360| 12| case ID_UNORDERED_ACCESS_MIP: ------------------ | Branch (2360:17): [True: 12, False: 28.7k] ------------------ 2361| 12| if(getValue(prop, compiler, uival)) ------------------ | Branch (2361:24): [True: 5, False: 7] ------------------ 2362| 5| mUnit->setUnorderedAccessMipLevel(uival); 2363| 12| break; 2364| 28| case ID_TEXTURE_ALIAS: ------------------ | Branch (2364:17): [True: 28, False: 28.7k] ------------------ 2365| 28| compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line, 2366| 28| "texture_alias. Use 'texture $variable'"); 2367| 28| if(getValue(prop, compiler, sval)) ------------------ | Branch (2367:24): [True: 14, False: 14] ------------------ 2368| 14| mUnit->setName(sval); 2369| 28| break; 2370| 9.37k| case ID_TEXTURE: ------------------ | Branch (2370:17): [True: 9.37k, False: 19.3k] ------------------ 2371| 9.37k| if(prop->values.empty()) ------------------ | Branch (2371:24): [True: 145, False: 9.23k] ------------------ 2372| 145| { 2373| 145| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 2374| 145| } 2375| 9.23k| else if(prop->values.size() > 5) ------------------ | Branch (2375:29): [True: 245, False: 8.98k] ------------------ 2376| 245| { 2377| 245| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 2378| 245| "texture must have at most 5 arguments"); 2379| 245| } 2380| 8.98k| else 2381| 8.98k| { 2382| 8.98k| AbstractNodeList::const_iterator j = prop->values.begin(); 2383| 8.98k| String val; 2384| 8.98k| if(getString(*j, &val)) ------------------ | Branch (2384:28): [True: 8.93k, False: 54] ------------------ 2385| 8.93k| { 2386| 8.93k| TextureType texType = TEX_TYPE_2D; 2387| 8.93k| bool isAlpha = false; 2388| 8.93k| bool sRGBRead = false; 2389| 8.93k| PixelFormat format = PF_UNKNOWN; 2390| 8.93k| int mipmaps = TextureManager::getSingleton().getDefaultNumMipmaps(); // MIP_DEFAULT 2391| | 2392| 8.93k| ++j; 2393| 11.1k| while(j != prop->values.end()) ------------------ | Branch (2393:35): [True: 2.24k, False: 8.93k] ------------------ 2394| 2.24k| { 2395| 2.24k| if((*j)->type == ANT_ATOM) ------------------ | Branch (2395:36): [True: 2.22k, False: 16] ------------------ 2396| 2.22k| { 2397| 2.22k| AtomAbstractNode *atom = (AtomAbstractNode*)(*j).get(); 2398| 2.22k| switch(atom->id) 2399| 2.22k| { 2400| 56| case ID_1D: ------------------ | Branch (2400:37): [True: 56, False: 2.17k] ------------------ 2401| 56| texType = TEX_TYPE_1D; 2402| 56| break; 2403| 1| case ID_2D: ------------------ | Branch (2403:37): [True: 1, False: 2.22k] ------------------ 2404| 1| texType = TEX_TYPE_2D; 2405| 1| break; 2406| 8| case ID_3D: ------------------ | Branch (2406:37): [True: 8, False: 2.21k] ------------------ 2407| 8| texType = TEX_TYPE_3D; 2408| 8| break; 2409| 1.16k| case ID_CUBIC: ------------------ | Branch (2409:37): [True: 1.16k, False: 1.06k] ------------------ 2410| 1.16k| texType = TEX_TYPE_CUBE_MAP; 2411| 1.16k| break; 2412| 0| case ID_2DARRAY: ------------------ | Branch (2412:37): [True: 0, False: 2.22k] ------------------ 2413| 0| texType = TEX_TYPE_2D_ARRAY; 2414| 0| break; 2415| 0| case ID_UNLIMITED: ------------------ | Branch (2415:37): [True: 0, False: 2.22k] ------------------ 2416| 0| mipmaps = MIP_UNLIMITED; 2417| 0| break; 2418| 1| case ID_ALPHA: ------------------ | Branch (2418:37): [True: 1, False: 2.22k] ------------------ 2419| 1| isAlpha = true; 2420| 1| break; 2421| 21| case ID_GAMMA: ------------------ | Branch (2421:37): [True: 21, False: 2.20k] ------------------ 2422| 21| sRGBRead = true; 2423| 21| break; 2424| 977| default: ------------------ | Branch (2424:37): [True: 977, False: 1.24k] ------------------ 2425| 977| if(!StringConverter::parse(atom->value, mipmaps)) ------------------ | Branch (2425:44): [True: 783, False: 194] ------------------ 2426| 783| { 2427| 783| format = PixelUtil::getFormatFromName(atom->value, true); 2428| | 2429| 783| if (format == PF_UNKNOWN) ------------------ | Branch (2429:49): [True: 650, False: 133] ------------------ 2430| 650| compiler->addError(*prop, atom->value); 2431| 783| } 2432| 2.22k| } 2433| 2.22k| } 2434| 16| else 2435| 16| { 2436| 16| compiler->addError(*prop, (*j)->getValue() + " is not a supported argument to the texture property"); 2437| 16| } 2438| 2.24k| ++j; 2439| 2.24k| } 2440| | 2441| 8.93k| String name = processResourceName(compiler, ResourceType::TEXTURE, val); 2442| | 2443| 8.93k| if(isAlpha) ------------------ | Branch (2443:32): [True: 1, False: 8.93k] ------------------ 2444| 1| { 2445| | // format = PF_A8; should only be done, if src is luminance, which we dont know here 2446| 1| compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, 2447| 1| prop->line, "alpha. Use PF_A8 instead"); 2448| 1| } 2449| | 2450| 8.93k| if(const auto& tex = TextureManager::getSingleton().getByName(name, mUnit->getParent()->getResourceGroup())) ------------------ | Branch (2450:44): [True: 2.90k, False: 6.03k] ------------------ 2451| 2.90k| { 2452| | // the texture is shared with another texture unit, report any discrepancies 2453| 2.90k| if (tex->getDesiredFormat() != format || tex->getNumMipmaps() != uint(mipmaps) || ------------------ | Branch (2453:37): [True: 38, False: 2.86k] | Branch (2453:74): [True: 34, False: 2.83k] ------------------ 2454| 2.83k| tex->isHardwareGammaEnabled() != sRGBRead || tex->getTextureType() != texType) ------------------ | Branch (2454:37): [True: 1, False: 2.82k] | Branch (2454:82): [True: 29, False: 2.80k] ------------------ 2455| 102| { 2456| 102| compiler->addError(*prop, "overriding previous declarations of texture '" + name + 2457| 102| "' with different parameters"); 2458| 102| } 2459| 2.90k| } 2460| | 2461| 8.93k| mUnit->setTextureName(name, texType); 2462| 8.93k| mUnit->setDesiredFormat(format); 2463| 8.93k| OGRE_IGNORE_DEPRECATED_BEGIN 2464| 8.93k| mUnit->setIsAlpha(isAlpha); 2465| 8.93k| OGRE_IGNORE_DEPRECATED_END 2466| 8.93k| mUnit->setNumMipmaps(mipmaps); 2467| 8.93k| mUnit->setHardwareGammaEnabled(sRGBRead); 2468| 8.93k| } 2469| 54| else 2470| 54| compiler->addError(*prop, (*j)->getValue() + " is not a valid texture name"); 2471| 8.98k| } 2472| 9.37k| break; 2473| 9.37k| case ID_ANIM_TEXTURE: ------------------ | Branch (2473:17): [True: 774, False: 27.9k] ------------------ 2474| 774| if(prop->values.size() < 3) ------------------ | Branch (2474:24): [True: 58, False: 716] ------------------ 2475| 58| { 2476| 58| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 2477| 58| } 2478| 716| else 2479| 716| { 2480| 716| AbstractNodeList::const_iterator i1 = getNodeAt(prop->values, 1); 2481| 716| uint32 nframes = 0; 2482| 716| if(getValue(*i1, nframes)) ------------------ | Branch (2482:28): [True: 609, False: 107] ------------------ 2483| 609| { 2484| | // Short form 2485| 609| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i2 = getNodeAt(prop->values, 2); 2486| 609| String val0; 2487| 609| Real val2; 2488| 609| if(nframes && getValue(*i0, val0) && getValue(*i2, val2)) ------------------ | Branch (2488:32): [True: 541, False: 68] | Branch (2488:43): [True: 541, False: 0] | Branch (2488:66): [True: 534, False: 7] ------------------ 2489| 534| { 2490| 534| mUnit->setAnimatedTextureName(processResourceName(compiler, ResourceType::TEXTURE, val0), nframes, val2); 2491| 534| } 2492| 75| else 2493| 75| { 2494| 75| compiler->addError(*prop, "anim_texture short form requires a texture name, a frame " 2495| 75| "count > 0, and animation duration"); 2496| 75| } 2497| 609| } 2498| 107| else 2499| 107| { 2500| | // Long form has n number of frames 2501| 107| Real duration = 0; 2502| 107| AbstractNodeList::const_iterator in = getNodeAt(prop->values, static_cast(prop->values.size()) - 1); 2503| 107| if(getReal(*in, &duration)) ------------------ | Branch (2503:32): [True: 70, False: 37] ------------------ 2504| 70| { 2505| 70| std::vector names; 2506| | 2507| 70| AbstractNodeList::iterator j = prop->values.begin(); 2508| 429| while(j != in) ------------------ | Branch (2508:39): [True: 359, False: 70] ------------------ 2509| 359| { 2510| 359| if((*j)->type == ANT_ATOM) ------------------ | Branch (2510:40): [True: 349, False: 10] ------------------ 2511| 349| names.push_back(((AtomAbstractNode*)(*j).get())->value); 2512| 10| else 2513| 10| compiler->addError(*prop, (*j)->getValue() + " is not supported as a texture name"); 2514| 359| ++j; 2515| 359| } 2516| | 2517| 70| processResourceNames(compiler, ResourceType::TEXTURE, names); 2518| 70| mUnit->setAnimatedTextureName(names, duration); 2519| 70| } 2520| 37| else 2521| 37| { 2522| 37| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line, 2523| 37| (*in)->getValue() + " is not supported for the duration argument"); 2524| 37| } 2525| 107| } 2526| 716| } 2527| 774| break; 2528| 36| case ID_CUBIC_TEXTURE: ------------------ | Branch (2528:17): [True: 36, False: 28.7k] ------------------ 2529| 36| if(prop->values.empty()) ------------------ | Branch (2529:24): [True: 0, False: 36] ------------------ 2530| 0| { 2531| 0| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 2532| 0| } 2533| 36| else if(prop->values.size() == 2) ------------------ | Branch (2533:29): [True: 8, False: 28] ------------------ 2534| 8| { 2535| 8| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), 2536| 8| i1 = getNodeAt(prop->values, 1); 2537| 8| if((*i0)->type == ANT_ATOM && (*i1)->type == ANT_ATOM) ------------------ | Branch (2537:28): [True: 8, False: 0] | Branch (2537:55): [True: 7, False: 1] ------------------ 2538| 7| { 2539| 7| AtomAbstractNode *atom0 = (AtomAbstractNode*)(*i0).get(); 2540| | 2541| 7| mUnit->setTextureName(processResourceName(compiler, ResourceType::TEXTURE, atom0->value), TEX_TYPE_CUBE_MAP); 2542| | 2543| 7| compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line, 2544| 7| "'cubic_texture ..'. Use 'texture .. cubic' instead."); 2545| 7| } 2546| 1| else 2547| 1| { 2548| 1| compiler->addError(*prop); 2549| 1| } 2550| 8| } 2551| 28| else if(prop->values.size() == 7) ------------------ | Branch (2551:29): [True: 18, False: 10] ------------------ 2552| 18| { 2553| 18| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), 2554| 18| i1 = getNodeAt(prop->values, 1), 2555| 18| i2 = getNodeAt(prop->values, 2), 2556| 18| i3 = getNodeAt(prop->values, 3), 2557| 18| i4 = getNodeAt(prop->values, 4), 2558| 18| i5 = getNodeAt(prop->values, 5), 2559| 18| i6 = getNodeAt(prop->values, 6); 2560| 18| if((*i0)->type == ANT_ATOM && (*i1)->type == ANT_ATOM && (*i2)->type == ANT_ATOM && (*i3)->type == ANT_ATOM && ------------------ | Branch (2560:28): [True: 18, False: 0] | Branch (2560:55): [True: 18, False: 0] | Branch (2560:82): [True: 18, False: 0] | Branch (2560:109): [True: 18, False: 0] ------------------ 2561| 18| (*i4)->type == ANT_ATOM && (*i5)->type == ANT_ATOM && (*i6)->type == ANT_ATOM) ------------------ | Branch (2561:28): [True: 18, False: 0] | Branch (2561:55): [True: 18, False: 0] | Branch (2561:82): [True: 17, False: 1] ------------------ 2562| 17| { 2563| 17| AtomAbstractNode *atom0 = (AtomAbstractNode*)(*i0).get(), *atom1 = (AtomAbstractNode*)(*i1).get(), 2564| 17| *atom2 = (AtomAbstractNode*)(*i2).get(), *atom3 = (AtomAbstractNode*)(*i3).get(), 2565| 17| *atom4 = (AtomAbstractNode*)(*i4).get(), *atom5 = (AtomAbstractNode*)(*i5).get(), 2566| 17| *atom6 = (AtomAbstractNode*)(*i6).get(); 2567| 17| std::vector names(6); 2568| | // backward compatible order 2569| 17| names[4] = atom0->value; 2570| 17| names[5] = atom1->value; 2571| 17| names[1] = atom2->value; 2572| 17| names[0] = atom3->value; 2573| 17| names[2] = atom4->value; 2574| 17| names[3] = atom5->value; 2575| | 2576| 17| processResourceNames(compiler, ResourceType::TEXTURE, names); 2577| | 2578| 17| if(atom6->id != ID_COMBINED_UVW) ------------------ | Branch (2578:32): [True: 17, False: 0] ------------------ 2579| 17| { 2580| 17| compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line, 2581| 17| "separateUV is no longer supported."); 2582| 17| } 2583| 17| mUnit->setLayerArrayNames(TEX_TYPE_CUBE_MAP, names); 2584| 17| } 2585| | 2586| 18| } 2587| 10| else 2588| 10| { 2589| 10| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 2590| 10| "cubic_texture must have at most 7 arguments"); 2591| 10| } 2592| 36| break; 2593| 279| case ID_TEX_COORD_SET: ------------------ | Branch (2593:17): [True: 279, False: 28.4k] ------------------ 2594| 279| if(getValue(prop, compiler, uival)) ------------------ | Branch (2594:24): [True: 262, False: 17] ------------------ 2595| 262| mUnit->setTextureCoordSet(uival); 2596| 279| break; 2597| | 2598| 104| case ID_COLOUR_OP: ------------------ | Branch (2598:17): [True: 104, False: 28.6k] ------------------ 2599| 104| LayerBlendOperation cop; 2600| 104| if(getValue(prop, compiler, cop)) ------------------ | Branch (2600:24): [True: 34, False: 70] ------------------ 2601| 34| mUnit->setColourOperation(cop); 2602| 104| break; 2603| 457| case ID_COLOUR_OP_EX: ------------------ | Branch (2603:17): [True: 457, False: 28.2k] ------------------ 2604| 457| if(prop->values.size() < 3) ------------------ | Branch (2604:24): [True: 11, False: 446] ------------------ 2605| 11| { 2606| 11| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line, 2607| 11| "colour_op_ex must have at least 3 arguments"); 2608| 11| } 2609| 446| else if(prop->values.size() > 10) ------------------ | Branch (2609:29): [True: 1, False: 445] ------------------ 2610| 1| { 2611| 1| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 2612| 1| "colour_op_ex must have at most 10 arguments"); 2613| 1| } 2614| 445| else 2615| 445| { 2616| 445| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), 2617| 445| i1 = getNodeAt(prop->values, 1), 2618| 445| i2 = getNodeAt(prop->values, 2); 2619| 445| LayerBlendOperationEx op; 2620| 445| LayerBlendSource source1, source2; 2621| 445| if (getValue(*i0, op) && getValue(*i1, source1) && getValue(*i2, source2)) ------------------ | Branch (2621:29): [True: 436, False: 9] | Branch (2621:50): [True: 407, False: 29] | Branch (2621:76): [True: 364, False: 43] ------------------ 2622| 364| { 2623| 364| ColourValue arg1 = ColourValue::White, arg2 = ColourValue::White; 2624| 364| Real manualBlend = 0.0f; 2625| | 2626| 364| if(op == LBX_BLEND_MANUAL) ------------------ | Branch (2626:32): [True: 0, False: 364] ------------------ 2627| 0| { 2628| 0| AbstractNodeList::const_iterator i3 = getNodeAt(prop->values, 3); 2629| 0| if(i3 != prop->values.end()) ------------------ | Branch (2629:36): [True: 0, False: 0] ------------------ 2630| 0| { 2631| 0| if(!getReal(*i3, &manualBlend)) ------------------ | Branch (2631:40): [True: 0, False: 0] ------------------ 2632| 0| compiler->addError(*prop, (*i3)->getValue() + " is not a valid number argument"); 2633| 0| } 2634| 0| else 2635| 0| { 2636| 0| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line, 2637| 0| "fourth argument expected when blend_manual is used"); 2638| 0| } 2639| 0| } 2640| | 2641| 364| AbstractNodeList::const_iterator j = getNodeAt(prop->values, 3); 2642| 364| if(op == LBX_BLEND_MANUAL) ------------------ | Branch (2642:32): [True: 0, False: 364] ------------------ 2643| 0| ++j; 2644| 364| if(source1 == LBS_MANUAL) ------------------ | Branch (2644:32): [True: 33, False: 331] ------------------ 2645| 33| { 2646| 33| if(j != prop->values.end()) ------------------ | Branch (2646:36): [True: 30, False: 3] ------------------ 2647| 30| { 2648| 30| if(!getColour(j, prop->values.end(), &arg1, 3)) ------------------ | Branch (2648:40): [True: 2, False: 28] ------------------ 2649| 2| compiler->addError(*prop, "valid colour expected when src_manual is used"); 2650| 30| } 2651| 3| else 2652| 3| { 2653| 3| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line, 2654| 3| "valid colour expected when src_manual is used"); 2655| 3| } 2656| 33| } 2657| 364| if(source2 == LBS_MANUAL) ------------------ | Branch (2657:32): [True: 98, False: 266] ------------------ 2658| 98| { 2659| 98| if(j != prop->values.end()) ------------------ | Branch (2659:36): [True: 97, False: 1] ------------------ 2660| 97| { 2661| 97| if(!getColour(j, prop->values.end(), &arg2, 3)) ------------------ | Branch (2661:40): [True: 7, False: 90] ------------------ 2662| 7| compiler->addError(*prop, "valid colour expected when src_manual is used"); 2663| 97| } 2664| 1| else 2665| 1| { 2666| 1| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line, 2667| 1| "valid colour expected when src_manual is used"); 2668| 1| } 2669| 98| } 2670| | 2671| 364| mUnit->setColourOperationEx(op, source1, source2, arg1, arg2, manualBlend); 2672| 364| } 2673| 81| else 2674| 81| { 2675| 81| compiler->addError(*prop); 2676| 81| } 2677| 445| } 2678| 457| break; 2679| 354| case ID_COLOUR_OP_MULTIPASS_FALLBACK: ------------------ | Branch (2679:17): [True: 354, False: 28.3k] ------------------ 2680| 354| if(prop->values.empty()) ------------------ | Branch (2680:24): [True: 1, False: 353] ------------------ 2681| 1| { 2682| 1| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 2683| 1| } 2684| 353| else if(prop->values.size() > 2) ------------------ | Branch (2684:29): [True: 72, False: 281] ------------------ 2685| 72| { 2686| 72| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 2687| 72| "colour_op_multiplass_fallback must have at most 2 arguments"); 2688| 72| } 2689| 281| else if(prop->values.size() == 1) ------------------ | Branch (2689:29): [True: 14, False: 267] ------------------ 2690| 14| { 2691| 14| switch(getAtomId(prop->values.front())) 2692| 14| { 2693| 0| case ID_ADD: ------------------ | Branch (2693:25): [True: 0, False: 14] ------------------ 2694| 0| mUnit->setColourOpMultipassFallback(SBF_ONE, SBF_ONE); 2695| 0| break; 2696| 0| case ID_MODULATE: ------------------ | Branch (2696:25): [True: 0, False: 14] ------------------ 2697| 0| mUnit->setColourOpMultipassFallback(SBF_DEST_COLOUR, SBF_ZERO); 2698| 0| break; 2699| 1| case ID_COLOUR_BLEND: ------------------ | Branch (2699:25): [True: 1, False: 13] ------------------ 2700| 1| mUnit->setColourOpMultipassFallback(SBF_SOURCE_COLOUR, SBF_ONE_MINUS_SOURCE_COLOUR); 2701| 1| break; 2702| 0| case ID_ALPHA_BLEND: ------------------ | Branch (2702:25): [True: 0, False: 14] ------------------ 2703| 0| mUnit->setColourOpMultipassFallback(SBF_SOURCE_ALPHA, SBF_ONE_MINUS_SOURCE_ALPHA); 2704| 0| break; 2705| 0| case ID_REPLACE: ------------------ | Branch (2705:25): [True: 0, False: 14] ------------------ 2706| 0| mUnit->setColourOpMultipassFallback(SBF_ONE, SBF_ZERO); 2707| 0| break; 2708| 13| default: ------------------ | Branch (2708:25): [True: 13, False: 1] ------------------ 2709| 13| compiler->addError(*prop, "argument must be a valid scene blend type (add, modulate, colour_blend, alpha_blend, or replace)"); 2710| 14| } 2711| 14| } 2712| 267| else 2713| 267| { 2714| 267| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1); 2715| 267| SceneBlendFactor sbf0, sbf1; 2716| 267| if(getSceneBlendFactor(*i0, &sbf0) && getSceneBlendFactor(*i1, &sbf1)) ------------------ | Branch (2716:28): [True: 237, False: 30] | Branch (2716:63): [True: 213, False: 24] ------------------ 2717| 213| mUnit->setColourOpMultipassFallback(sbf0, sbf1); 2718| 54| else 2719| 54| compiler->addError(*prop, "arguments must be valid scene blend factors"); 2720| 267| } 2721| 354| break; 2722| 354| case ID_ALPHA_OP_EX: ------------------ | Branch (2722:17): [True: 107, False: 28.6k] ------------------ 2723| 107| if(prop->values.size() < 3) ------------------ | Branch (2723:24): [True: 16, False: 91] ------------------ 2724| 16| { 2725| 16| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line, 2726| 16| "alpha_op_ex must have at least 3 arguments"); 2727| 16| } 2728| 91| else if(prop->values.size() > 6) ------------------ | Branch (2728:29): [True: 3, False: 88] ------------------ 2729| 3| { 2730| 3| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 2731| 3| "alpha_op_ex must have at most 6 arguments"); 2732| 3| } 2733| 88| else 2734| 88| { 2735| 88| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), 2736| 88| i1 = getNodeAt(prop->values, 1), 2737| 88| i2 = getNodeAt(prop->values, 2); 2738| 88| LayerBlendOperationEx op; 2739| 88| LayerBlendSource source1, source2; 2740| 88| if (getValue(*i0, op) && getValue(*i1, source1) && getValue(*i2, source2)) ------------------ | Branch (2740:29): [True: 38, False: 50] | Branch (2740:50): [True: 34, False: 4] | Branch (2740:76): [True: 28, False: 6] ------------------ 2741| 28| { 2742| 28| Real arg1 = 0.0f, arg2 = 0.0f; 2743| 28| Real manualBlend = 0.0f; 2744| | 2745| 28| if(op == LBX_BLEND_MANUAL) ------------------ | Branch (2745:32): [True: 0, False: 28] ------------------ 2746| 0| { 2747| 0| AbstractNodeList::const_iterator i3 = getNodeAt(prop->values, 3); 2748| 0| if(i3 != prop->values.end()) ------------------ | Branch (2748:36): [True: 0, False: 0] ------------------ 2749| 0| { 2750| 0| if(!getReal(*i3, &manualBlend)) ------------------ | Branch (2750:40): [True: 0, False: 0] ------------------ 2751| 0| compiler->addError(*prop, "valid number expected when blend_manual is used"); 2752| 0| } 2753| 0| else 2754| 0| { 2755| 0| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line, 2756| 0| "valid number expected when blend_manual is used"); 2757| 0| } 2758| 0| } 2759| | 2760| 28| AbstractNodeList::const_iterator j = getNodeAt(prop->values, 3); 2761| 28| if(op == LBX_BLEND_MANUAL) ------------------ | Branch (2761:32): [True: 0, False: 28] ------------------ 2762| 0| ++j; 2763| 28| if(source1 == LBS_MANUAL) ------------------ | Branch (2763:32): [True: 27, False: 1] ------------------ 2764| 27| { 2765| 27| if(j != prop->values.end()) ------------------ | Branch (2765:36): [True: 26, False: 1] ------------------ 2766| 26| { 2767| 26| if(!getReal(*j, &arg1)) ------------------ | Branch (2767:40): [True: 6, False: 20] ------------------ 2768| 6| compiler->addError(*prop, "valid colour expected when src_manual is used"); 2769| 20| else 2770| 20| ++j; 2771| 26| } 2772| 1| else 2773| 1| { 2774| 1| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line, 2775| 1| "valid colour expected when src_manual is used"); 2776| 1| } 2777| 27| } 2778| 28| if(source2 == LBS_MANUAL) ------------------ | Branch (2778:32): [True: 0, False: 28] ------------------ 2779| 0| { 2780| 0| if(j != prop->values.end()) ------------------ | Branch (2780:36): [True: 0, False: 0] ------------------ 2781| 0| { 2782| 0| if(!getReal(*j, &arg2)) ------------------ | Branch (2782:40): [True: 0, False: 0] ------------------ 2783| 0| compiler->addError(*prop, "valid colour expected when src_manual is used"); 2784| 0| } 2785| 0| else 2786| 0| { 2787| 0| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line, 2788| 0| "valid colour expected when src_manual is used"); 2789| 0| } 2790| 0| } 2791| | 2792| 28| mUnit->setAlphaOperation(op, source1, source2, arg1, arg2, manualBlend); 2793| 28| } 2794| 60| else 2795| 60| { 2796| 60| compiler->addError(*prop); 2797| 60| } 2798| 88| } 2799| 107| break; 2800| 1.02k| case ID_ENV_MAP: ------------------ | Branch (2800:17): [True: 1.02k, False: 27.7k] ------------------ 2801| 1.02k| if(prop->values.empty()) ------------------ | Branch (2801:24): [True: 15, False: 1.01k] ------------------ 2802| 15| { 2803| 15| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 2804| 15| } 2805| 1.01k| else if(prop->values.size() > 1) ------------------ | Branch (2805:29): [True: 23, False: 990] ------------------ 2806| 23| { 2807| 23| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 2808| 23| "env_map must have at most 1 argument"); 2809| 23| } 2810| 990| else 2811| 990| { 2812| 990| switch(getAtomId(prop->values.front())) 2813| 990| { 2814| 1| case ScriptCompiler::ID_OFF: ------------------ | Branch (2814:25): [True: 1, False: 989] ------------------ 2815| 1| mUnit->setEnvironmentMap(false); 2816| 1| break; 2817| 629| case ID_SPHERICAL: ------------------ | Branch (2817:25): [True: 629, False: 361] ------------------ 2818| 629| mUnit->setEnvironmentMap(true, TextureUnitState::ENV_CURVED); 2819| 629| break; 2820| 0| case ID_PLANAR: ------------------ | Branch (2820:25): [True: 0, False: 990] ------------------ 2821| 0| mUnit->setEnvironmentMap(true, TextureUnitState::ENV_PLANAR); 2822| 0| break; 2823| 306| case ID_CUBIC_REFLECTION: ------------------ | Branch (2823:25): [True: 306, False: 684] ------------------ 2824| 306| mUnit->setEnvironmentMap(true, TextureUnitState::ENV_REFLECTION); 2825| 306| break; 2826| 0| case ID_CUBIC_NORMAL: ------------------ | Branch (2826:25): [True: 0, False: 990] ------------------ 2827| 0| mUnit->setEnvironmentMap(true, TextureUnitState::ENV_NORMAL); 2828| 0| break; 2829| 54| default: ------------------ | Branch (2829:25): [True: 54, False: 936] ------------------ 2830| 54| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid argument (must be \"off\", \"spherical\", \"planar\", \"cubic_reflection\", or \"cubic_normal\")"); 2831| 990| } 2832| 990| } 2833| 1.02k| break; 2834| 1.02k| case ID_SCROLL: ------------------ | Branch (2834:17): [True: 269, False: 28.4k] ------------------ 2835| 269| { 2836| 269| std::vector v; 2837| 269| if(prop->values.size() == 2 && getVector(prop->values.begin(), prop->values.end(), v, 2)) ------------------ | Branch (2837:28): [True: 236, False: 33] | Branch (2837:28): [True: 221, False: 48] | Branch (2837:56): [True: 221, False: 15] ------------------ 2838| 221| mUnit->setTextureScroll(v[0], v[1]); 2839| 48| else 2840| 48| compiler->addError(*prop, "scroll requires exactly 2 numeric arguments"); 2841| 269| } 2842| 269| break; 2843| 1.23k| case ID_SCROLL_ANIM: ------------------ | Branch (2843:17): [True: 1.23k, False: 27.5k] ------------------ 2844| 1.23k| { 2845| 1.23k| std::vector v; 2846| 1.23k| if(prop->values.size() == 2 && getVector(prop->values.begin(), prop->values.end(), v, 2)) ------------------ | Branch (2846:28): [True: 1.12k, False: 110] | Branch (2846:28): [True: 1.07k, False: 155] | Branch (2846:56): [True: 1.07k, False: 45] ------------------ 2847| 1.07k| mUnit->setScrollAnimation(v[0], v[1]); 2848| 155| else 2849| 155| compiler->addError(*prop, "scroll_anim requires exactly 2 numeric arguments"); 2850| 1.23k| } 2851| 1.23k| break; 2852| 15| case ID_ROTATE: ------------------ | Branch (2852:17): [True: 15, False: 28.7k] ------------------ 2853| 15| if(getValue(prop, compiler, fval)) ------------------ | Branch (2853:24): [True: 2, False: 13] ------------------ 2854| 2| mUnit->setTextureRotate(Degree(fval)); 2855| 15| break; 2856| 352| case ID_ROTATE_ANIM: ------------------ | Branch (2856:17): [True: 352, False: 28.3k] ------------------ 2857| 352| if(getValue(prop, compiler, fval)) ------------------ | Branch (2857:24): [True: 314, False: 38] ------------------ 2858| 314| mUnit->setRotateAnimation(fval); 2859| 352| break; 2860| 386| case ID_SCALE: ------------------ | Branch (2860:17): [True: 386, False: 28.3k] ------------------ 2861| 386| { 2862| 386| std::vector v; 2863| 386| if(prop->values.size() == 2 && getVector(prop->values.begin(), prop->values.end(), v, 2)) ------------------ | Branch (2863:28): [True: 372, False: 14] | Branch (2863:28): [True: 364, False: 22] | Branch (2863:56): [True: 364, False: 8] ------------------ 2864| 364| mUnit->setTextureScale(v[0], v[1]); 2865| 22| else 2866| 22| compiler->addError(*prop, "scale requires exactly 2 numeric arguments"); 2867| 386| } 2868| 386| break; 2869| 672| case ID_WAVE_XFORM: ------------------ | Branch (2869:17): [True: 672, False: 28.0k] ------------------ 2870| 672| if(prop->values.size() != 6) ------------------ | Branch (2870:24): [True: 44, False: 628] ------------------ 2871| 44| { 2872| 44| compiler->addError(*prop, "wave_xform requires exactly 6 arguments"); 2873| 44| } 2874| 628| else 2875| 628| { 2876| 628| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1), 2877| 628| i2 = getNodeAt(prop->values, 2), i3 = getNodeAt(prop->values, 3), 2878| 628| i4 = getNodeAt(prop->values, 4), i5 = getNodeAt(prop->values, 5); 2879| 628| if((*i0)->type == ANT_ATOM && (*i1)->type == ANT_ATOM && (*i2)->type == ANT_ATOM && ------------------ | Branch (2879:28): [True: 628, False: 0] | Branch (2879:55): [True: 628, False: 0] | Branch (2879:82): [True: 628, False: 0] ------------------ 2880| 628| (*i3)->type == ANT_ATOM && (*i4)->type == ANT_ATOM && (*i5)->type == ANT_ATOM) ------------------ | Branch (2880:28): [True: 628, False: 0] | Branch (2880:55): [True: 627, False: 1] | Branch (2880:82): [True: 624, False: 3] ------------------ 2881| 624| { 2882| 624| AtomAbstractNode *atom0 = (AtomAbstractNode*)(*i0).get(), *atom1 = (AtomAbstractNode*)(*i1).get(); 2883| 624| TextureUnitState::TextureTransformType type = TextureUnitState::TT_ROTATE; 2884| 624| WaveformType wave = WFT_SINE; 2885| 624| Real base = 0.0f, freq = 0.0f, phase = 0.0f, amp = 0.0f; 2886| | 2887| 624| switch(atom0->id) 2888| 624| { 2889| 0| case ID_SCROLL_X: ------------------ | Branch (2889:29): [True: 0, False: 624] ------------------ 2890| 0| type = TextureUnitState::TT_TRANSLATE_U; 2891| 0| break; 2892| 243| case ID_SCROLL_Y: ------------------ | Branch (2892:29): [True: 243, False: 381] ------------------ 2893| 243| type = TextureUnitState::TT_TRANSLATE_V; 2894| 243| break; 2895| 179| case ID_SCALE_X: ------------------ | Branch (2895:29): [True: 179, False: 445] ------------------ 2896| 179| type = TextureUnitState::TT_SCALE_U; 2897| 179| break; 2898| 182| case ID_SCALE_Y: ------------------ | Branch (2898:29): [True: 182, False: 442] ------------------ 2899| 182| type = TextureUnitState::TT_SCALE_V; 2900| 182| break; 2901| 0| case ID_ROTATE: ------------------ | Branch (2901:29): [True: 0, False: 624] ------------------ 2902| 0| type = TextureUnitState::TT_ROTATE; 2903| 0| break; 2904| 20| default: ------------------ | Branch (2904:29): [True: 20, False: 604] ------------------ 2905| 20| compiler->addError(*prop, atom0->value + " is not a valid transform type (must be \"scroll_x\", \"scroll_y\", \"scale_x\", \"scale_y\", or \"rotate\")"); 2906| 624| } 2907| | 2908| 624| switch(atom1->id) 2909| 624| { 2910| 576| case ID_SINE: ------------------ | Branch (2910:29): [True: 576, False: 48] ------------------ 2911| 576| wave = WFT_SINE; 2912| 576| break; 2913| 0| case ID_TRIANGLE: ------------------ | Branch (2913:29): [True: 0, False: 624] ------------------ 2914| 0| wave = WFT_TRIANGLE; 2915| 0| break; 2916| 0| case ID_SQUARE: ------------------ | Branch (2916:29): [True: 0, False: 624] ------------------ 2917| 0| wave = WFT_SQUARE; 2918| 0| break; 2919| 0| case ID_SAWTOOTH: ------------------ | Branch (2919:29): [True: 0, False: 624] ------------------ 2920| 0| wave = WFT_SAWTOOTH; 2921| 0| break; 2922| 0| case ID_INVERSE_SAWTOOTH: ------------------ | Branch (2922:29): [True: 0, False: 624] ------------------ 2923| 0| wave = WFT_INVERSE_SAWTOOTH; 2924| 0| break; 2925| 48| default: ------------------ | Branch (2925:29): [True: 48, False: 576] ------------------ 2926| 48| compiler->addError(*prop, atom1->value + " is not a valid waveform type (must be \"sine\", \"triangle\", \"square\", \"sawtooth\", or \"inverse_sawtooth\")"); 2927| 624| } 2928| | 2929| 624| if(!getReal(*i2, &base) || !getReal(*i3, &freq) || !getReal(*i4, &phase) || !getReal(*i5, &)) ------------------ | Branch (2929:32): [True: 17, False: 607] | Branch (2929:56): [True: 10, False: 597] | Branch (2929:80): [True: 15, False: 582] | Branch (2929:105): [True: 5, False: 577] ------------------ 2930| 47| compiler->addError(*prop, "arguments 3, 4, 5, and 6 must be valid numbers; received " + (*i2)->getValue() + ", " + (*i3)->getValue() + ", " + (*i4)->getValue() + ", " + (*i5)->getValue()); 2931| | 2932| 624| mUnit->setTransformAnimation(type, wave, base, freq, phase, amp); 2933| 624| } 2934| 4| else 2935| 4| { 2936| 4| compiler->addError(*prop); 2937| 4| } 2938| 628| } 2939| 672| break; 2940| 672| case ID_TRANSFORM: ------------------ | Branch (2940:17): [True: 35, False: 28.7k] ------------------ 2941| 35| { 2942| 35| Matrix4 m; 2943| 35| if(getMatrix4(prop->values.begin(), prop->values.end(), &m)) ------------------ | Branch (2943:28): [True: 0, False: 35] ------------------ 2944| 0| mUnit->setTextureTransform(m); 2945| 35| else 2946| 35| compiler->addError(*prop); 2947| 35| } 2948| 35| break; 2949| 3.04k| case ID_CONTENT_TYPE: ------------------ | Branch (2949:17): [True: 3.04k, False: 25.6k] ------------------ 2950| 3.04k| if(prop->values.empty()) ------------------ | Branch (2950:24): [True: 1, False: 3.04k] ------------------ 2951| 1| { 2952| 1| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line); 2953| 1| } 2954| 3.04k| else if(prop->values.size() > 4) ------------------ | Branch (2954:29): [True: 25, False: 3.01k] ------------------ 2955| 25| { 2956| 25| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line, 2957| 25| "content_type must have at most 4 arguments"); 2958| 25| } 2959| 3.01k| else 2960| 3.01k| { 2961| 3.01k| switch(getAtomId(prop->values.front())) 2962| 3.01k| { 2963| 0| case ID_NAMED: ------------------ | Branch (2963:25): [True: 0, False: 3.01k] ------------------ 2964| 0| mUnit->setContentType(TextureUnitState::CONTENT_NAMED); 2965| 0| break; 2966| 2.06k| case ID_SHADOW: ------------------ | Branch (2966:25): [True: 2.06k, False: 946] ------------------ 2967| 2.06k| mUnit->setContentType(TextureUnitState::CONTENT_SHADOW); 2968| 2.06k| break; 2969| 851| case ID_COMPOSITOR: ------------------ | Branch (2969:25): [True: 851, False: 2.16k] ------------------ 2970| 851| mUnit->setContentType(TextureUnitState::CONTENT_COMPOSITOR); 2971| 851| if (prop->values.size() >= 3) ------------------ | Branch (2971:33): [True: 794, False: 57] ------------------ 2972| 794| { 2973| 794| String compositorName; 2974| 794| getString(*getNodeAt(prop->values, 1), &compositorName); 2975| 794| String textureName; 2976| 794| getString(*getNodeAt(prop->values, 2), &textureName); 2977| | 2978| 794| if (prop->values.size() == 4) ------------------ | Branch (2978:37): [True: 519, False: 275] ------------------ 2979| 519| { 2980| 519| uint32 mrtIndex; 2981| 519| getUInt(*getNodeAt(prop->values, 3), (uint32*)&mrtIndex); 2982| 519| mUnit->setCompositorReference(compositorName, textureName, mrtIndex); 2983| 519| } 2984| 275| else 2985| 275| { 2986| 275| mUnit->setCompositorReference(compositorName, textureName); 2987| 275| } 2988| 794| } 2989| 57| else 2990| 57| { 2991| 57| compiler->addError(*prop, "content_type compositor must have an additional 2 or 3 parameters"); 2992| 57| } 2993| | 2994| 851| break; 2995| 95| default: ------------------ | Branch (2995:25): [True: 95, False: 2.92k] ------------------ 2996| 95| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid content type (must be \"named\" or \"shadow\" or \"compositor\")"); 2997| 3.01k| } 2998| 3.01k| } 2999| 3.04k| break; 3000| 3.04k| default: ------------------ | Branch (3000:17): [True: 3.00k, False: 25.7k] ------------------ 3001| 3.00k| compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line, 3002| 3.00k| "token \"" + prop->name + "\" is not recognized"); 3003| 28.7k| } 3004| 28.7k| } 3005| 3.10k| else if(i->type == ANT_OBJECT) ------------------ | Branch (3005:21): [True: 1.43k, False: 1.66k] ------------------ 3006| 1.43k| { 3007| 1.43k| processNode(compiler, i); 3008| 1.43k| } 3009| 31.8k| } 3010| 12.7k| } _ZN4Ogre23TextureSourceTranslatorC2Ev: 3016| 1| { 3017| 1| } _ZN4Ogre23TextureSourceTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE: 3020| 18| { 3021| 18| ObjectAbstractNode *obj = static_cast(node.get()); 3022| | 3023| | // It has to have one value identifying the texture source name 3024| 18| if(obj->values.empty()) ------------------ | Branch (3024:12): [True: 1, False: 17] ------------------ 3025| 1| { 3026| 1| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, node->file, node->line, 3027| 1| "texture_source requires a type value"); 3028| 1| return; 3029| 1| } 3030| | 3031| | // Set the value of the source 3032| 17| ExternalTextureSourceManager::getSingleton().setCurrentPlugIn(obj->values.front()->getValue()); 3033| | 3034| 17| if (!ExternalTextureSourceManager::getSingleton().getCurrentPlugIn()) ------------------ | Branch (3034:13): [True: 17, False: 0] ------------------ 3035| 17| { 3036| 17| compiler->addError(ScriptCompiler::CE_REFERENCETOANONEXISTINGOBJECT, node->file, node->line, 3037| 17| obj->values.front()->getValue()); 3038| 17| return; 3039| 17| } 3040| | 3041| | // Set up the technique, pass, and texunit levels 3042| 0| TextureUnitState *texunit = any_cast(obj->parent->context); 3043| 0| Pass *pass = texunit->getParent(); 3044| 0| Technique *technique = pass->getParent(); 3045| 0| Material *material = technique->getParent(); 3046| | 3047| 0| unsigned short techniqueIndex = 0, passIndex = 0, texUnitIndex = 0; 3048| 0| for(unsigned short i = 0; i < material->getNumTechniques(); i++) ------------------ | Branch (3048:35): [True: 0, False: 0] ------------------ 3049| 0| { 3050| 0| if(material->getTechnique(i) == technique) ------------------ | Branch (3050:16): [True: 0, False: 0] ------------------ 3051| 0| { 3052| 0| techniqueIndex = i; 3053| 0| break; 3054| 0| } 3055| 0| } 3056| 0| for(unsigned short i = 0; i < technique->getNumPasses(); i++) ------------------ | Branch (3056:35): [True: 0, False: 0] ------------------ 3057| 0| { 3058| 0| if(technique->getPass(i) == pass) ------------------ | Branch (3058:16): [True: 0, False: 0] ------------------ 3059| 0| { 3060| 0| passIndex = i; 3061| 0| break; 3062| 0| } 3063| 0| } 3064| 0| for(unsigned short i = 0; i < pass->getNumTextureUnitStates(); i++) ------------------ | Branch (3064:35): [True: 0, False: 0] ------------------ 3065| 0| { 3066| 0| if(pass->getTextureUnitState(i) == texunit) ------------------ | Branch (3066:16): [True: 0, False: 0] ------------------ 3067| 0| { 3068| 0| texUnitIndex = i; 3069| 0| break; 3070| 0| } 3071| 0| } 3072| | 3073| 0| String tps; 3074| 0| tps = StringConverter::toString(techniqueIndex) + " " 3075| 0| + StringConverter::toString(passIndex) + " " 3076| 0| + StringConverter::toString(texUnitIndex); 3077| | 3078| 0| ExternalTextureSourceManager::getSingleton().getCurrentPlugIn()->setParameter( "set_T_P_S", tps ); 3079| | 3080| 0| for(auto & i : obj->children) ------------------ | Branch (3080:22): [True: 0, False: 0] ------------------ 3081| 0| { 3082| 0| if(i->type == ANT_PROPERTY) ------------------ | Branch (3082:16): [True: 0, False: 0] ------------------ 3083| 0| { 3084| 0| auto prop = i->getProperty(); 3085| | // Glob the property values all together 3086| 0| String str = StringConverter::toString(prop.values); 3087| 0| ExternalTextureSourceManager::getSingleton().getCurrentPlugIn()->setParameter(prop.name, str); 3088| 0| } 3089| 0| else if(i->type == ANT_OBJECT) ------------------ | Branch (3089:21): [True: 0, False: 0] ------------------ 3090| 0| { 3091| 0| processNode(compiler, i); 3092| 0| } 3093| 0| } 3094| | 3095| 0| ExternalTextureSourceManager::getSingleton().getCurrentPlugIn()->createDefinedTexture(material->getName(), material->getGroup()); 3096| 0| } _ZN4Ogre20GpuProgramTranslatorC2Ev: 3102| 1| { 3103| 1| } _ZN4Ogre20GpuProgramTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE: 3106| 4.83k| { 3107| 4.83k| ObjectAbstractNode *obj = static_cast(node.get()); 3108| | 3109| | // Must have a name 3110| 4.83k| if(obj->name.empty()) ------------------ | Branch (3110:12): [True: 25, False: 4.80k] ------------------ 3111| 25| { 3112| 25| compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line, 3113| 25| "gpu program object must have names"); 3114| 25| return; 3115| 25| } 3116| | 3117| | // Must have a language type 3118| 4.80k| if(obj->values.empty()) ------------------ | Branch (3118:12): [True: 647, False: 4.16k] ------------------ 3119| 647| { 3120| 647| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, obj->file, obj->line, 3121| 647| "gpu program object require language declarations"); 3122| 647| return; 3123| 647| } 3124| | 3125| | // Get the language 3126| 4.16k| String language; 3127| 4.16k| for(const auto& lnode : obj->values) ------------------ | Branch (3127:31): [True: 7.71k, False: 3.30k] ------------------ 3128| 7.71k| { 3129| 7.71k| if(!getString(lnode, &language)) ------------------ | Branch (3129:16): [True: 0, False: 7.71k] ------------------ 3130| 0| { 3131| 0| compiler->addError(*obj); 3132| 0| return; 3133| 0| } 3134| | 3135| 7.71k| if (language == "asm") ------------------ | Branch (3135:17): [True: 1, False: 7.71k] ------------------ 3136| 1| { 3137| 1| compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, obj->file, obj->line, "asm. Use syntax code."); 3138| 1| break; // always supported 3139| 1| } 3140| 7.71k| if (GpuProgramManager::getSingleton().isLanguageSupported(language)) ------------------ | Branch (3140:17): [True: 860, False: 6.85k] ------------------ 3141| 860| break; 3142| 7.71k| } 3143| | 3144| 4.16k| translateGpuProgram(compiler, obj, language); 3145| 4.16k| } _ZN4Ogre20GpuProgramTranslator19translateGpuProgramEPNS_14ScriptCompilerEPNS_18ObjectAbstractNodeENSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 3148| 4.16k| { 3149| 4.16k| String syntax; 3150| 4.16k| std::vector delegates; 3151| 4.16k| std::vector > customParameters; 3152| 4.16k| String source, profiles, target; 3153| 4.16k| AbstractNodePtr params; 3154| 4.16k| for(auto & i : obj->children) ------------------ | Branch (3154:22): [True: 17.0k, False: 4.07k] ------------------ 3155| 17.0k| { 3156| 17.0k| if(i->type == ANT_PROPERTY) ------------------ | Branch (3156:16): [True: 13.7k, False: 3.29k] ------------------ 3157| 13.7k| { 3158| 13.7k| PropertyAbstractNode *prop = (PropertyAbstractNode*)i.get(); 3159| 13.7k| if(prop->id == ID_SOURCE) ------------------ | Branch (3159:20): [True: 3.18k, False: 10.5k] ------------------ 3160| 3.18k| { 3161| 3.18k| if(!getValue(prop, compiler, source)) ------------------ | Branch (3161:24): [True: 48, False: 3.13k] ------------------ 3162| 48| return; 3163| 3.18k| } 3164| 10.5k| else if(prop->name == "delegate") ------------------ | Branch (3164:25): [True: 3.24k, False: 7.27k] ------------------ 3165| 3.24k| { 3166| 3.24k| String value; 3167| 3.24k| if(!getValue(prop, compiler, value)) ------------------ | Branch (3167:24): [True: 40, False: 3.20k] ------------------ 3168| 40| return; 3169| | 3170| 3.20k| String name = processResourceName(compiler, ResourceType::GPU_PROGRAM, value); 3171| | 3172| 3.20k| if (name == obj->name) ------------------ | Branch (3172:25): [True: 97, False: 3.11k] ------------------ 3173| 97| { 3174| 97| compiler->addError(*prop, "cannot be a delegate of itself"); 3175| 97| continue; 3176| 97| } 3177| | 3178| 3.11k| delegates.push_back(name); 3179| 3.11k| } 3180| 7.27k| else 3181| 7.27k| { 3182| 7.27k| StringVector values; 3183| 7.27k| _getVector(prop->values.begin(), prop->values.end(), values, prop->values.size()); 3184| | 3185| 7.27k| if(prop->name == "attach") ------------------ | Branch (3185:24): [True: 38, False: 7.24k] ------------------ 3186| 38| { 3187| 38| compiler->addError(*prop, "attach. Use the #include directive instead", 3188| 38| ScriptCompiler::CE_DEPRECATEDSYMBOL); 3189| | 3190| 38| processResourceNames(compiler, ResourceType::GPU_PROGRAM, values); 3191| 38| } 3192| | 3193| 7.27k| String value = StringConverter::toString(values); 3194| | 3195| 7.27k| if(prop->name == "profiles") ------------------ | Branch (3195:24): [True: 525, False: 6.75k] ------------------ 3196| 525| profiles = value; 3197| 6.75k| else if(prop->name == "target") ------------------ | Branch (3197:29): [True: 1.16k, False: 5.58k] ------------------ 3198| 1.16k| target = value; 3199| 5.58k| else if(prop->id == ID_SYNTAX && language == "asm") ------------------ | Branch (3199:29): [True: 212, False: 5.37k] | Branch (3199:54): [True: 0, False: 212] ------------------ 3200| 0| syntax = value; 3201| 5.58k| else 3202| 5.58k| customParameters.push_back(std::make_pair(prop, value)); 3203| 7.27k| } 3204| 13.7k| } 3205| 3.29k| else if(i->type == ANT_OBJECT) ------------------ | Branch (3205:21): [True: 2.42k, False: 876] ------------------ 3206| 2.42k| { 3207| 2.42k| if(((ObjectAbstractNode*)i.get())->id == ID_DEFAULT_PARAMS) ------------------ | Branch (3207:20): [True: 1.21k, False: 1.20k] ------------------ 3208| 1.21k| params = i; 3209| 1.20k| else 3210| 1.20k| processNode(compiler, i); 3211| 2.42k| } 3212| 17.0k| } 3213| | 3214| | // Allocate the program 3215| 4.07k| GpuProgramType gpt = getProgramType(obj->id); 3216| 4.07k| GpuProgram *prog = 0; 3217| | 3218| 4.07k| if(language == "asm") ------------------ | Branch (3218:12): [True: 1, False: 4.07k] ------------------ 3219| 1| language = syntax; 3220| 4.07k| CreateGpuProgramScriptCompilerEvent evt(obj->file, obj->name, compiler->getResourceGroup(), source, 3221| 4.07k| language, gpt); 3222| 4.07k| bool processed = compiler->_fireEvent(&evt, &prog); 3223| | 3224| 4.07k| if(!processed) ------------------ | Branch (3224:12): [True: 4.01k, False: 55] ------------------ 3225| 4.01k| { 3226| 4.01k| prog = GpuProgramManager::getSingleton().create(obj->name, compiler->getResourceGroup(), gpt, language).get(); 3227| | 3228| 4.01k| if (source.empty() && language != "unified") ------------------ | Branch (3228:17): [True: 1.36k, False: 2.65k] | Branch (3228:35): [True: 603, False: 765] ------------------ 3229| 603| { 3230| 603| compiler->addError(*obj, "No 'source' provided for GPU program"); 3231| 603| return; 3232| 603| } 3233| | 3234| 3.41k| if(prog && !source.empty()) // prog=0 if duplicate definition resolved by "use previous" ------------------ | Branch (3234:16): [True: 3.30k, False: 114] | Branch (3234:24): [True: 2.53k, False: 765] ------------------ 3235| 2.53k| prog->setSourceFile(source); 3236| 3.41k| } 3237| | 3238| 3.47k| if(!prog) ------------------ | Branch (3238:12): [True: 0, False: 3.47k] ------------------ 3239| 0| { 3240| 0| compiler->addError(ScriptCompiler::CE_OBJECTALLOCATIONERROR, obj->file, obj->line, obj->name); 3241| 0| return; 3242| 0| } 3243| | 3244| 3.47k| obj->context = prog; 3245| | 3246| 3.47k| prog->setMorphAnimationIncluded(false); 3247| 3.47k| prog->setPoseAnimationIncluded(0); 3248| 3.47k| prog->setSkeletalAnimationIncluded(false); 3249| 3.47k| prog->setVertexTextureFetchRequired(false); 3250| 3.47k| prog->_notifyOrigin(obj->file); 3251| | 3252| | // special case for Cg 3253| 3.47k| if(!profiles.empty()) ------------------ | Branch (3253:12): [True: 355, False: 3.11k] ------------------ 3254| 355| prog->setParameter("profiles", profiles); 3255| | 3256| | // special case for HLSL 3257| 3.47k| if(!target.empty()) ------------------ | Branch (3257:12): [True: 1.05k, False: 2.41k] ------------------ 3258| 1.05k| prog->setParameter("target", target); 3259| | 3260| | // special case for unified 3261| 3.47k| for(const auto& d : delegates) ------------------ | Branch (3261:27): [True: 2.87k, False: 3.47k] ------------------ 3262| 2.87k| prog->setParameter("delegate", d); 3263| | 3264| | // Set the custom parameters 3265| 3.47k| for(const auto& p : customParameters) ------------------ | Branch (3265:27): [True: 3.75k, False: 3.47k] ------------------ 3266| 3.75k| { 3267| 3.75k| if(prog->isSupported() && !prog->setParameter(p.first->name, p.second)) ------------------ | Branch (3267:16): [True: 0, False: 3.75k] | Branch (3267:39): [True: 0, False: 0] ------------------ 3268| 0| { 3269| 0| compiler->addError(*p.first, p.first->name); 3270| 0| } 3271| 3.75k| } 3272| | 3273| | // Set up default parameters 3274| 3.47k| if(prog->isSupported() && params) ------------------ | Branch (3274:12): [True: 0, False: 3.47k] | Branch (3274:35): [True: 0, False: 0] ------------------ 3275| 0| { 3276| 0| GpuProgramParametersSharedPtr ptr = prog->getDefaultParameters(); 3277| | 3278| 0| if(prog->hasCompileError()) ------------------ | Branch (3278:16): [True: 0, False: 0] ------------------ 3279| 0| return; 3280| | 3281| 0| GpuProgramTranslator::translateProgramParameters(compiler, ptr, static_cast(params.get())); 3282| 0| } 3283| 3.47k| } _ZN4Ogre22SharedParamsTranslatorC2Ev: 3769| 1| { 3770| 1| } _ZN4Ogre22SharedParamsTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE: 3774| 154| { 3775| 154| ObjectAbstractNode *obj = static_cast(node.get()); 3776| | 3777| | // Must have a name 3778| 154| if (obj->name.empty()) ------------------ | Branch (3778:13): [True: 25, False: 129] ------------------ 3779| 25| { 3780| 25| compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line); 3781| 25| return; 3782| 25| } 3783| | 3784| 129| GpuSharedParameters* sharedParams = 0; 3785| 129| CreateGpuSharedParametersScriptCompilerEvent evt(obj->file, obj->name, compiler->getResourceGroup()); 3786| 129| bool processed = compiler->_fireEvent(&evt, (void*)&sharedParams); 3787| | 3788| 129| if (!processed) ------------------ | Branch (3788:13): [True: 129, False: 0] ------------------ 3789| 129| { 3790| 129| sharedParams = GpuProgramManager::getSingleton().createSharedParameters(obj->name).get(); 3791| 129| } 3792| | 3793| 129| if (!sharedParams) ------------------ | Branch (3793:13): [True: 0, False: 129] ------------------ 3794| 0| { 3795| 0| compiler->addError(ScriptCompiler::CE_OBJECTALLOCATIONERROR, obj->file, obj->line, obj->name); 3796| 0| return; 3797| 0| } 3798| | 3799| 129| for (auto & i : obj->children) ------------------ | Branch (3799:23): [True: 525, False: 129] ------------------ 3800| 525| { 3801| 525| if (i->type != ANT_PROPERTY) ------------------ | Branch (3801:17): [True: 45, False: 480] ------------------ 3802| 45| continue; 3803| | 3804| 480| PropertyAbstractNode *prop = static_cast(i.get()); 3805| 480| if (prop->id != ID_SHARED_PARAM_NAMED && prop->id != ID_PARAM_NAMED) ------------------ | Branch (3805:17): [True: 480, False: 0] | Branch (3805:54): [True: 383, False: 97] ------------------ 3806| 383| { 3807| 383| compiler->addError(*prop, prop->name); 3808| 383| continue; 3809| 383| } 3810| | 3811| 97| if(prop->id == ID_SHARED_PARAM_NAMED) ------------------ | Branch (3811:16): [True: 0, False: 97] ------------------ 3812| 0| { 3813| 0| compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line, 3814| 0| "shared_param_named is deprecated. Use param_named instead"); 3815| 0| } 3816| | 3817| 97| if (prop->values.size() < 2) ------------------ | Branch (3817:17): [True: 6, False: 91] ------------------ 3818| 6| { 3819| 6| compiler->addError(*prop, prop->name + " - expected 2 or more arguments"); 3820| 6| continue; 3821| 6| } 3822| | 3823| 91| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1); 3824| | 3825| 91| String pName; 3826| 91| GpuConstantType constType; 3827| | 3828| 91| if (!getValue(*i0, pName) || !getConstantType(i1, &constType)) ------------------ | Branch (3828:17): [True: 2, False: 89] | Branch (3828:42): [True: 39, False: 50] ------------------ 3829| 41| { 3830| 41| compiler->addError(*prop, "name and parameter type expected"); 3831| 41| continue; 3832| 41| } 3833| | 3834| 50| AbstractNodeList::const_iterator arrayStart = getNodeAt(prop->values, 2), arrayEnd = prop->values.end(); 3835| 50| uint32 arraySz = 1; 3836| | 3837| 50| if (arrayStart != arrayEnd) ------------------ | Branch (3837:17): [True: 49, False: 1] ------------------ 3838| 49| { 3839| 49| String value; 3840| 49| getValue(*arrayStart, value); 3841| | 3842| 49| if (value.front() == '[' && value.back() == ']') ------------------ | Branch (3842:21): [True: 4, False: 45] | Branch (3842:45): [True: 4, False: 0] ------------------ 3843| 4| { 3844| 4| arraySz = StringConverter::parseInt(value.substr(1, value.size() - 2), 0); 3845| 4| if(!arraySz) ------------------ | Branch (3845:24): [True: 0, False: 4] ------------------ 3846| 0| { 3847| 0| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line, 3848| 0| "invalid array size"); 3849| 0| continue; 3850| 0| } 3851| 4| arrayStart++; 3852| 4| } 3853| 49| } 3854| | 3855| | // Look up the auto constant - if the next token is a known auto constant name, 3856| | // the parameter is driven automatically instead of by literal values 3857| 50| const GpuProgramParameters::AutoConstantDefinition* autoDef = NULL; 3858| 50| if (arrayStart != arrayEnd && (*arrayStart)->type == ANT_ATOM) ------------------ | Branch (3858:17): [True: 49, False: 1] | Branch (3858:43): [True: 49, False: 0] ------------------ 3859| 49| { 3860| 49| String acName = static_cast(arrayStart->get())->value; 3861| 49| StringUtil::toLowerCase(acName); 3862| 49| autoDef = GpuProgramParameters::getAutoConstantDefinition(acName); 3863| 49| } 3864| | 3865| | // define constant entry 3866| 50| try 3867| 50| { 3868| 50| sharedParams->addConstantDefinition(pName, constType, arraySz); 3869| | 3870| 50| if(autoDef) ------------------ | Branch (3870:20): [True: 2, False: 48] ------------------ 3871| 2| { 3872| 2| sharedParams->setAutoConstant(pName, autoDef->acType); 3873| 2| arrayStart++; 3874| 2| } 3875| 50| } 3876| 50| catch(Exception& e) 3877| 50| { 3878| 2| compiler->addError(*prop, e.getDescription()); 3879| 2| continue; 3880| 2| } 3881| | 3882| 48| if (autoDef && arrayStart != arrayEnd) ------------------ | Branch (3882:17): [True: 2, False: 46] | Branch (3882:28): [True: 0, False: 2] ------------------ 3883| 0| { 3884| 0| compiler->addError(*prop, "unexpected extra parameters after auto constant name"); 3885| 0| } 3886| | 3887| | // amount of individual numbers to read 3888| 48| arraySz *= GpuConstantDefinition::getElementSize(constType, false); 3889| | 3890| 48| switch (GpuConstantDefinition::getBaseType(constType)) 3891| 48| { 3892| 9| case BCT_FLOAT: ------------------ | Branch (3892:13): [True: 9, False: 39] ------------------ 3893| 9| { 3894| 9| std::vector values; 3895| 9| if(_getVector(arrayStart, arrayEnd, values, arraySz)) ------------------ | Branch (3895:20): [True: 8, False: 1] ------------------ 3896| 8| sharedParams->setNamedConstant(pName, &values[0], arraySz); 3897| 1| else 3898| 1| compiler->addError(*prop); 3899| 9| break; 3900| 0| } 3901| 14| case BCT_INT: ------------------ | Branch (3901:13): [True: 14, False: 34] ------------------ 3902| 14| { 3903| 14| std::vector values; 3904| 14| if(_getVector(arrayStart, arrayEnd, values, arraySz)) ------------------ | Branch (3904:20): [True: 13, False: 1] ------------------ 3905| 13| sharedParams->setNamedConstant(pName, &values[0], arraySz); 3906| 1| else 3907| 1| compiler->addError(*prop); 3908| 14| break; 3909| 0| } 3910| 0| case BCT_DOUBLE: ------------------ | Branch (3910:13): [True: 0, False: 48] ------------------ 3911| 0| { 3912| 0| std::vector values; 3913| 0| if(_getVector(arrayStart, arrayEnd, values, arraySz)) ------------------ | Branch (3913:20): [True: 0, False: 0] ------------------ 3914| 0| sharedParams->setNamedConstant(pName, &values[0], arraySz); 3915| 0| else 3916| 0| compiler->addError(*prop); 3917| 0| break; 3918| 0| } 3919| 25| case BCT_UINT: ------------------ | Branch (3919:13): [True: 25, False: 23] ------------------ 3920| 25| { 3921| 25| std::vector values; 3922| 25| if(_getVector(arrayStart, arrayEnd, values, arraySz)) ------------------ | Branch (3922:20): [True: 7, False: 18] ------------------ 3923| 7| { 3924| 7| sharedParams->setNamedConstant(pName, &values[0], arraySz); 3925| 7| } 3926| 18| else 3927| 18| compiler->addError(*prop); 3928| 25| break; 3929| 0| } 3930| 0| case BCT_BOOL: ------------------ | Branch (3930:13): [True: 0, False: 48] ------------------ 3931| 0| { 3932| 0| compiler->addError(ScriptCompiler::CE_DEPRECATEDSYMBOL, prop->file, prop->line, 3933| 0| "bool. Use uint instead"); 3934| 0| std::vector tmp; 3935| 0| if(_getVector(arrayStart, arrayEnd, tmp, arraySz)) ------------------ | Branch (3935:20): [True: 0, False: 0] ------------------ 3936| 0| { 3937| 0| std::vector values(tmp.begin(), tmp.end()); 3938| 0| sharedParams->setNamedConstant(pName, &values[0], arraySz); 3939| 0| } 3940| 0| else 3941| 0| compiler->addError(*prop); 3942| 0| break; 3943| 0| } 3944| 0| default: ------------------ | Branch (3944:13): [True: 0, False: 48] ------------------ 3945| 0| compiler->addError(*prop, "invalid parameter type"); 3946| 0| break; 3947| 48| } 3948| 48| } 3949| 129| } _ZN4Ogre24ParticleSystemTranslatorC2Ev: 3955| 1| :mSystem(0) 3956| 1| { 3957| 1| } _ZN4Ogre24ParticleSystemTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE: 3960| 16| { 3961| 16| ObjectAbstractNode *obj = static_cast(node.get()); 3962| | // Find the name 3963| 16| if(obj->name.empty()) ------------------ | Branch (3963:12): [True: 6, False: 10] ------------------ 3964| 6| { 3965| 6| compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line); 3966| 6| return; 3967| 6| } 3968| | 3969| | // Allocate the particle system 3970| 10| CreateParticleSystemScriptCompilerEvent evt(obj->file, obj->name, compiler->getResourceGroup()); 3971| 10| bool processed = compiler->_fireEvent(&evt, (void*)&mSystem); 3972| | 3973| 10| if(!processed) ------------------ | Branch (3973:12): [True: 10, False: 0] ------------------ 3974| 10| { 3975| 10| mSystem = ParticleSystemManager::getSingleton().createTemplate(obj->name, compiler->getResourceGroup()); 3976| 10| } 3977| | 3978| 10| if(!mSystem) ------------------ | Branch (3978:12): [True: 0, False: 10] ------------------ 3979| 0| { 3980| 0| compiler->addError(ScriptCompiler::CE_OBJECTALLOCATIONERROR, obj->file, obj->line, obj->name); 3981| 0| return; 3982| 0| } 3983| | 3984| 10| mSystem->_notifyOrigin(obj->file); 3985| | 3986| 10| mSystem->removeAllEmitters(); 3987| 10| mSystem->removeAllAffectors(); 3988| | 3989| 10| obj->context = mSystem; 3990| | 3991| 10| for(auto & i : obj->children) ------------------ | Branch (3991:22): [True: 0, False: 10] ------------------ 3992| 0| { 3993| 0| if(i->type == ANT_PROPERTY) ------------------ | Branch (3993:16): [True: 0, False: 0] ------------------ 3994| 0| { 3995| 0| auto prop = i->getProperty(); 3996| 0| if(prop.values.empty()) ------------------ | Branch (3996:20): [True: 0, False: 0] ------------------ 3997| 0| { 3998| 0| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, i->file, i->line); 3999| 0| return; 4000| 0| } 4001| | 4002| 0| String value; 4003| 0| if(static_cast(i.get())->id == ID_MATERIAL) ------------------ | Branch (4003:20): [True: 0, False: 0] ------------------ 4004| 0| { 4005| 0| value = processResourceName(compiler, ResourceType::MATERIAL, prop.values.front()); 4006| 0| } 4007| 0| else 4008| 0| { 4009| 0| value = StringConverter::toString(prop.values); 4010| 0| } 4011| | 4012| 0| if(!mSystem->setParameter(prop.name, value)) ------------------ | Branch (4012:20): [True: 0, False: 0] ------------------ 4013| 0| { 4014| 0| if(auto renderer = mSystem->getRenderer()) ------------------ | Branch (4014:29): [True: 0, False: 0] ------------------ 4015| 0| { 4016| 0| if(!renderer->setParameter(prop.name, value)) ------------------ | Branch (4016:28): [True: 0, False: 0] ------------------ 4017| 0| compiler->addError(*i); 4018| 0| } 4019| 0| } 4020| 0| } 4021| 0| else 4022| 0| { 4023| 0| processNode(compiler, i); 4024| 0| } 4025| 0| } 4026| 10| } _ZN4Ogre25ParticleEmitterTranslatorC2Ev: 4032| 1| :mEmitter(0) 4033| 1| { 4034| 1| } _ZN4Ogre26ParticleAffectorTranslatorC2Ev: 4080| 1| :mAffector(0) 4081| 1| { 4082| 1| } _ZN4Ogre20CompositorTranslatorC2Ev: 4127| 1| :mCompositor(0) 4128| 1| { 4129| 1| } _ZN4Ogre20CompositorTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE: 4132| 2.20k| { 4133| 2.20k| ObjectAbstractNode *obj = static_cast(node.get()); 4134| 2.20k| if(obj->name.empty()) ------------------ | Branch (4134:12): [True: 9, False: 2.19k] ------------------ 4135| 9| { 4136| 9| compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line); 4137| 9| return; 4138| 9| } 4139| | 4140| | // Create the compositor 4141| 2.19k| CreateCompositorScriptCompilerEvent evt(obj->file, obj->name, compiler->getResourceGroup()); 4142| 2.19k| bool processed = compiler->_fireEvent(&evt, (void*)&mCompositor); 4143| | 4144| 2.19k| if(!processed) ------------------ | Branch (4144:12): [True: 2.19k, False: 0] ------------------ 4145| 2.19k| { 4146| 2.19k| mCompositor = CompositorManager::getSingleton().create(obj->name, compiler->getResourceGroup()).get(); 4147| 2.19k| } 4148| | 4149| 2.19k| if(!mCompositor) ------------------ | Branch (4149:12): [True: 0, False: 2.19k] ------------------ 4150| 0| { 4151| 0| compiler->addError(ScriptCompiler::CE_OBJECTALLOCATIONERROR, obj->file, obj->line, obj->name); 4152| 0| return; 4153| 0| } 4154| | 4155| | // Prepare the compositor 4156| 2.19k| mCompositor->removeAllTechniques(); 4157| 2.19k| mCompositor->_notifyOrigin(obj->file); 4158| 2.19k| obj->context = mCompositor; 4159| | 4160| 2.19k| for(auto & i : obj->children) ------------------ | Branch (4160:22): [True: 3.60k, False: 2.19k] ------------------ 4161| 3.60k| { 4162| 3.60k| if(i->type == ANT_OBJECT) ------------------ | Branch (4162:16): [True: 2.91k, False: 696] ------------------ 4163| 2.91k| { 4164| 2.91k| processNode(compiler, i); 4165| 2.91k| } 4166| 696| else 4167| 696| { 4168| 696| compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, i->file, i->line, 4169| 696| "token not recognized"); 4170| 696| } 4171| 3.60k| } 4172| 2.19k| } _ZN4Ogre30CompositionTechniqueTranslatorC2Ev: 4178| 1| :mTechnique(0) 4179| 1| { 4180| 1| } _ZN4Ogre30CompositionTechniqueTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE: 4183| 2.03k| { 4184| 2.03k| ObjectAbstractNode *obj = static_cast(node.get()); 4185| | 4186| 2.03k| Compositor *compositor = any_cast(obj->parent->context); 4187| 2.03k| mTechnique = compositor->createTechnique(); 4188| 2.03k| obj->context = mTechnique; 4189| | 4190| 2.03k| String sval; 4191| 2.03k| uint32 uival; 4192| | 4193| 2.03k| for(auto & i : obj->children) ------------------ | Branch (4193:22): [True: 10.6k, False: 1.82k] ------------------ 4194| 10.6k| { 4195| 10.6k| if(i->type == ANT_OBJECT) ------------------ | Branch (4195:16): [True: 5.04k, False: 5.63k] ------------------ 4196| 5.04k| { 4197| 5.04k| processNode(compiler, i); 4198| 5.04k| } 4199| 5.63k| else if(i->type == ANT_PROPERTY) ------------------ | Branch (4199:21): [True: 4.71k, False: 918] ------------------ 4200| 4.71k| { 4201| 4.71k| PropertyAbstractNode *prop = static_cast(i.get()); 4202| 4.71k| switch(prop->id) 4203| 4.71k| { 4204| 3.25k| case ID_TEXTURE: ------------------ | Branch (4204:17): [True: 3.25k, False: 1.46k] ------------------ 4205| 3.25k| { 4206| 3.25k| if (prop->values.size() < 4) ------------------ | Branch (4206:29): [True: 57, False: 3.19k] ------------------ 4207| 57| { 4208| 57| compiler->addError(*prop, "texture must have at least 4 arguments"); 4209| 57| continue; 4210| 57| } 4211| | 4212| | // Save the first atom, should be name 4213| 3.19k| AbstractNodeList::const_iterator it = getNodeAt(prop->values, 0); 4214| 3.19k| const String& name = (*it)->getString(); 4215| | 4216| 3.19k| if(name.empty()) ------------------ | Branch (4216:28): [True: 0, False: 3.19k] ------------------ 4217| 0| { 4218| 0| compiler->addError(*prop, "texture name cannot be empty"); 4219| 0| continue; 4220| 0| } 4221| | 4222| 3.19k| uint32 width = 0, height = 0; 4223| 3.19k| uint32 depth = 1; 4224| 3.19k| float widthFactor = 1.0f, heightFactor = 1.0f; 4225| 3.19k| bool widthSet = false, heightSet = false, formatSet = false; 4226| 3.19k| bool pooled = false; 4227| 3.19k| bool hwGammaWrite = false; 4228| 3.19k| uint32 fsaa = 1; 4229| 3.19k| auto type = TEX_TYPE_2D; 4230| 3.19k| uint16 depthBufferId = RBP_DEFAULT; 4231| 3.19k| CompositionTechnique::TextureScope scope = CompositionTechnique::TS_LOCAL; 4232| 3.19k| Ogre::PixelFormatList formats; 4233| | 4234| 3.19k| size_t atomIndex = 1; 4235| 14.6k| while (atomIndex < prop->values.size()) ------------------ | Branch (4235:32): [True: 11.6k, False: 3.00k] ------------------ 4236| 11.6k| { 4237| 11.6k| it = getNodeAt(prop->values, static_cast(atomIndex++)); 4238| 11.6k| if((*it)->type != ANT_ATOM) ------------------ | Branch (4238:32): [True: 0, False: 11.6k] ------------------ 4239| 0| { 4240| 0| compiler->addError(*prop); 4241| 0| return; 4242| 0| } 4243| 11.6k| AtomAbstractNode *atom = (AtomAbstractNode*)(*it).get(); 4244| | 4245| 11.6k| switch(atom->id) 4246| 11.6k| { 4247| 1.99k| case ID_TARGET_WIDTH: ------------------ | Branch (4247:29): [True: 1.99k, False: 9.62k] ------------------ 4248| 1.99k| width = 0; 4249| 1.99k| widthSet = true; 4250| 1.99k| break; 4251| 1.86k| case ID_TARGET_HEIGHT: ------------------ | Branch (4251:29): [True: 1.86k, False: 9.75k] ------------------ 4252| 1.86k| height = 0; 4253| 1.86k| heightSet = true; 4254| 1.86k| break; 4255| 432| case ID_TARGET_WIDTH_SCALED: ------------------ | Branch (4255:29): [True: 432, False: 11.1k] ------------------ 4256| 842| case ID_TARGET_HEIGHT_SCALED: ------------------ | Branch (4256:29): [True: 410, False: 11.2k] ------------------ 4257| 842| { 4258| 842| bool *pSetFlag; 4259| 842| uint32 *pSize; 4260| 842| float *pFactor; 4261| | 4262| 842| if (atom->id == ID_TARGET_WIDTH_SCALED) ------------------ | Branch (4262:41): [True: 432, False: 410] ------------------ 4263| 432| { 4264| 432| pSetFlag = &widthSet; 4265| 432| pSize = &width; 4266| 432| pFactor = &widthFactor; 4267| 432| } 4268| 410| else 4269| 410| { 4270| 410| pSetFlag = &heightSet; 4271| 410| pSize = &height; 4272| 410| pFactor = &heightFactor; 4273| 410| } 4274| | // advance to next to get scaling 4275| 842| it = getNodeAt(prop->values, static_cast(atomIndex++)); 4276| 842| if(prop->values.end() == it || !getValue(*it, *pFactor)) ------------------ | Branch (4276:40): [True: 0, False: 842] | Branch (4276:40): [True: 5, False: 837] | Branch (4276:68): [True: 5, False: 837] ------------------ 4277| 5| { 4278| 5| compiler->addError(*prop); 4279| 5| return; 4280| 5| } 4281| | 4282| 837| *pSize = 0; 4283| 837| *pSetFlag = true; 4284| 837| } 4285| 0| break; 4286| 0| case ID_POOLED: ------------------ | Branch (4286:29): [True: 0, False: 11.6k] ------------------ 4287| 0| pooled = true; 4288| 0| break; 4289| 128| case ID_CUBIC: ------------------ | Branch (4289:29): [True: 128, False: 11.4k] ------------------ 4290| 128| type = TEX_TYPE_CUBE_MAP; 4291| 128| break; 4292| 0| case ID_2DARRAY: ------------------ | Branch (4292:29): [True: 0, False: 11.6k] ------------------ 4293| 0| type = TEX_TYPE_2D_ARRAY; 4294| 0| break; 4295| 0| case ID_2DMS: ------------------ | Branch (4295:29): [True: 0, False: 11.6k] ------------------ 4296| 0| type = TEX_TYPE_2D_MULTISAMPLE; 4297| 0| break; 4298| 0| case ID_SCOPE_LOCAL: ------------------ | Branch (4298:29): [True: 0, False: 11.6k] ------------------ 4299| 0| scope = CompositionTechnique::TS_LOCAL; 4300| 0| break; 4301| 214| case ID_SCOPE_CHAIN: ------------------ | Branch (4301:29): [True: 214, False: 11.4k] ------------------ 4302| 214| scope = CompositionTechnique::TS_CHAIN; 4303| 214| break; 4304| 0| case ID_SCOPE_GLOBAL: ------------------ | Branch (4304:29): [True: 0, False: 11.6k] ------------------ 4305| 0| scope = CompositionTechnique::TS_GLOBAL; 4306| 0| break; 4307| 0| case ID_GAMMA: ------------------ | Branch (4307:29): [True: 0, False: 11.6k] ------------------ 4308| 0| hwGammaWrite = true; 4309| 0| break; 4310| 145| case ID_NO_FSAA: ------------------ | Branch (4310:29): [True: 145, False: 11.4k] ------------------ 4311| 145| fsaa = 0; 4312| 145| break; 4313| 3| case ID_FSAA: ------------------ | Branch (4313:29): [True: 3, False: 11.6k] ------------------ 4314| | // advance to next to get the value 4315| 3| it = getNodeAt(prop->values, atomIndex++); 4316| 3| if(prop->values.end() == it || !getValue(*it, fsaa)) ------------------ | Branch (4316:36): [True: 0, False: 3] | Branch (4316:36): [True: 3, False: 0] | Branch (4316:64): [True: 3, False: 0] ------------------ 4317| 3| { 4318| 3| compiler->addError(*prop); 4319| 3| return; 4320| 3| } 4321| 0| break; 4322| 145| case ID_DEPTH_POOL: ------------------ | Branch (4322:29): [True: 145, False: 11.4k] ------------------ 4323| 145| { 4324| | // advance to next to get the ID 4325| 145| it = getNodeAt(prop->values, static_cast(atomIndex++)); 4326| 145| if(prop->values.end() == it || !getValue(*it, uival)) ------------------ | Branch (4326:40): [True: 1, False: 144] | Branch (4326:40): [True: 6, False: 139] | Branch (4326:68): [True: 5, False: 139] ------------------ 4327| 6| { 4328| 6| compiler->addError(*prop); 4329| 6| return; 4330| 6| } 4331| 139| depthBufferId = Math::uint16Cast(uival); 4332| 139| } 4333| 0| break; 4334| 6.28k| default: ------------------ | Branch (4334:29): [True: 6.28k, False: 5.33k] ------------------ 4335| 6.28k| if (StringConverter::parse(atom->value, uival)) ------------------ | Branch (4335:37): [True: 1.68k, False: 4.59k] ------------------ 4336| 1.68k| { 4337| 1.68k| if (atomIndex == 2) ------------------ | Branch (4337:41): [True: 840, False: 849] ------------------ 4338| 840| { 4339| 840| width = uival; 4340| 840| widthSet = true; 4341| 840| } 4342| 849| else if (atomIndex == 3) ------------------ | Branch (4342:46): [True: 840, False: 9] ------------------ 4343| 840| { 4344| 840| height = uival; 4345| 840| heightSet = true; 4346| 840| } 4347| 9| else if (atomIndex == 4) ------------------ | Branch (4347:46): [True: 8, False: 1] ------------------ 4348| 8| { 4349| 8| depth = uival; 4350| 8| } 4351| 1| else 4352| 1| { 4353| 1| compiler->addError(*prop); 4354| 1| return; 4355| 1| } 4356| 1.68k| } 4357| 4.59k| else 4358| 4.59k| { 4359| | // pixel format? 4360| 4.59k| PixelFormat format = PixelUtil::getFormatFromName(atom->value, true); 4361| 4.59k| if (format == PF_UNKNOWN) ------------------ | Branch (4361:41): [True: 172, False: 4.42k] ------------------ 4362| 172| { 4363| 172| compiler->addError(*prop, atom->value); 4364| 172| return; 4365| 172| } 4366| 4.42k| formats.push_back(format); 4367| 4.42k| formatSet = true; 4368| 4.42k| } 4369| | 4370| 11.6k| } 4371| 11.6k| } 4372| 3.00k| if (!widthSet || !heightSet || !formatSet) ------------------ | Branch (4372:29): [True: 3, False: 3.00k] | Branch (4372:42): [True: 2, False: 3.00k] | Branch (4372:56): [True: 4, False: 2.99k] ------------------ 4373| 9| { 4374| 9| compiler->addError(*prop, "texture definition must specify width, height, and format"); 4375| 9| return; 4376| 9| } 4377| | 4378| 2.99k| if(depth != 1 && type != TEX_TYPE_2D_ARRAY) ------------------ | Branch (4378:28): [True: 4, False: 2.99k] | Branch (4378:42): [True: 4, False: 0] ------------------ 4379| 4| { 4380| 4| compiler->addError(*prop, "depth only supported for 2d_array textures"); 4381| 4| return; 4382| 4| } 4383| | 4384| | // No errors, create 4385| 2.99k| try { 4386| 2.99k| CompositionTechnique::TextureDefinition *def = mTechnique->createTextureDefinition(name); 4387| 2.99k| def->width = width; 4388| 2.99k| def->height = height; 4389| 2.99k| def->depth = depth; 4390| 2.99k| def->type = type; 4391| 2.99k| def->widthFactor = widthFactor; 4392| 2.99k| def->heightFactor = heightFactor; 4393| 2.99k| def->formatList = formats; 4394| 2.99k| def->fsaa = fsaa; 4395| 2.99k| def->hwGammaWrite = hwGammaWrite; 4396| 2.99k| def->depthBufferId = depthBufferId; 4397| 2.99k| def->pooled = pooled; 4398| 2.99k| def->scope = scope; 4399| 2.99k| } 4400| 2.99k| catch (Exception &e) 4401| 2.99k| { 4402| 387| compiler->addError(*prop, e.getDescription()); 4403| 387| } 4404| 2.99k| } 4405| 2.99k| break; 4406| 318| case ID_TEXTURE_REF: ------------------ | Branch (4406:17): [True: 318, False: 4.39k] ------------------ 4407| 318| if(prop->values.empty()) ------------------ | Branch (4407:24): [True: 0, False: 318] ------------------ 4408| 0| { 4409| 0| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 4410| 0| } 4411| 318| else if(prop->values.size() != 3) ------------------ | Branch (4411:29): [True: 24, False: 294] ------------------ 4412| 24| { 4413| 24| compiler->addError(*prop, "texture_ref only supports 3 argument"); 4414| 24| } 4415| 294| else 4416| 294| { 4417| 294| String texName, refCompName, refTexName; 4418| | 4419| 294| AbstractNodeList::const_iterator it = getNodeAt(prop->values, 0); 4420| 294| if(!getString(*it, &texName)) ------------------ | Branch (4420:28): [True: 0, False: 294] ------------------ 4421| 0| compiler->addError(*prop, "texture_ref must have 3 string arguments"); 4422| | 4423| 294| it = getNodeAt(prop->values, 1); 4424| 294| if(!getString(*it, &refCompName)) ------------------ | Branch (4424:28): [True: 1, False: 293] ------------------ 4425| 1| compiler->addError(*prop, "texture_ref must have 3 string arguments"); 4426| | 4427| 294| it = getNodeAt(prop->values, 2); 4428| 294| if(!getString(*it, &refTexName)) ------------------ | Branch (4428:28): [True: 4, False: 290] ------------------ 4429| 4| compiler->addError(*prop, "texture_ref must have 3 string arguments"); 4430| | 4431| 294| CompositionTechnique::TextureDefinition* refTexDef = 4432| 294| mTechnique->createTextureDefinition(texName); 4433| | 4434| 294| refTexDef->refCompName = refCompName; 4435| 294| refTexDef->refTexName = refTexName; 4436| 294| } 4437| 318| break; 4438| 11| case ID_SCHEME: ------------------ | Branch (4438:17): [True: 11, False: 4.70k] ------------------ 4439| 11| if(getValue(prop, compiler, sval)) ------------------ | Branch (4439:24): [True: 4, False: 7] ------------------ 4440| 4| mTechnique->setSchemeName(sval); 4441| 11| break; 4442| 252| case ID_COMPOSITOR_LOGIC: ------------------ | Branch (4442:17): [True: 252, False: 4.46k] ------------------ 4443| 252| if(getValue(prop, compiler, sval)) ------------------ | Branch (4443:24): [True: 244, False: 8] ------------------ 4444| 244| mTechnique->setCompositorLogicName(sval); 4445| 252| break; 4446| 880| default: ------------------ | Branch (4446:17): [True: 880, False: 3.83k] ------------------ 4447| 880| compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line, 4448| 880| "token \"" + prop->name + "\" is not recognized"); 4449| 4.71k| } 4450| 4.71k| } 4451| 10.6k| } 4452| 2.03k| } _ZN4Ogre31CompositionTargetPassTranslatorC2Ev: 4458| 1| :mTarget(0) 4459| 1| { 4460| 1| } _ZN4Ogre31CompositionTargetPassTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE: 4463| 4.41k| { 4464| 4.41k| ObjectAbstractNode *obj = static_cast(node.get()); 4465| | 4466| 4.41k| CompositionTechnique *technique = any_cast(obj->parent->context); 4467| 4.41k| if(obj->id == ID_TARGET) ------------------ | Branch (4467:12): [True: 3.12k, False: 1.29k] ------------------ 4468| 3.12k| { 4469| 3.12k| mTarget = technique->createTargetPass(); 4470| 3.12k| if(obj->name.empty()) ------------------ | Branch (4470:16): [True: 6, False: 3.12k] ------------------ 4471| 6| { 4472| 6| compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, obj->file, obj->line); 4473| 6| return; 4474| 6| } 4475| 3.12k| mTarget->setOutputName(obj->name); 4476| | 4477| 3.12k| if(!obj->values.empty()) ------------------ | Branch (4477:16): [True: 798, False: 2.32k] ------------------ 4478| 798| { 4479| 798| int val; 4480| 798| if(getInt(obj->values.front(), &val)) ------------------ | Branch (4480:20): [True: 776, False: 22] ------------------ 4481| 776| mTarget->setOutputSlice(val); 4482| 798| } 4483| 3.12k| } 4484| 1.29k| else if(obj->id == ID_TARGET_OUTPUT) ------------------ | Branch (4484:17): [True: 1.27k, False: 13] ------------------ 4485| 1.27k| { 4486| 1.27k| mTarget = technique->getOutputTargetPass(); 4487| 1.27k| if (!mTarget->getPasses().empty() || mTarget->getInputMode() != CompositionTargetPass::IM_NONE) ------------------ | Branch (4487:17): [True: 86, False: 1.19k] | Branch (4487:50): [True: 25, False: 1.16k] ------------------ 4488| 111| { 4489| 111| compiler->addError(*obj, "target_output can only be used once per technique"); 4490| 111| } 4491| 1.27k| } 4492| 4.41k| obj->context = mTarget; 4493| | 4494| 4.41k| bool bval; 4495| 4.41k| Real fval; 4496| 4.41k| uint32 uival; 4497| 4.41k| String sval; 4498| | 4499| 4.41k| for(auto & i : obj->children) ------------------ | Branch (4499:22): [True: 13.2k, False: 4.41k] ------------------ 4500| 13.2k| { 4501| 13.2k| if(i->type == ANT_OBJECT) ------------------ | Branch (4501:16): [True: 4.39k, False: 8.90k] ------------------ 4502| 4.39k| { 4503| 4.39k| processNode(compiler, i); 4504| 4.39k| } 4505| 8.90k| else if(i->type == ANT_PROPERTY) ------------------ | Branch (4505:21): [True: 8.05k, False: 848] ------------------ 4506| 8.05k| { 4507| 8.05k| PropertyAbstractNode *prop = static_cast(i.get()); 4508| 8.05k| switch(prop->id) 4509| 8.05k| { 4510| 5.84k| case ID_INPUT: ------------------ | Branch (4510:17): [True: 5.84k, False: 2.21k] ------------------ 4511| 5.84k| CompositionTargetPass::InputMode im; 4512| 5.84k| if(getValue(prop, compiler, im)) ------------------ | Branch (4512:24): [True: 5.52k, False: 324] ------------------ 4513| 5.52k| mTarget->setInputMode(im); 4514| 5.84k| break; 4515| 3| case ID_ONLY_INITIAL: ------------------ | Branch (4515:17): [True: 3, False: 8.05k] ------------------ 4516| 3| if(getValue(prop, compiler, bval)) ------------------ | Branch (4516:24): [True: 0, False: 3] ------------------ 4517| 0| mTarget->setOnlyInitial(bval); 4518| 3| break; 4519| 653| case ID_VISIBILITY_MASK: ------------------ | Branch (4519:17): [True: 653, False: 7.40k] ------------------ 4520| 653| if(getValue(prop, compiler, uival)) ------------------ | Branch (4520:24): [True: 609, False: 44] ------------------ 4521| 609| mTarget->setVisibilityMask(uival); 4522| 653| break; 4523| 6| case ID_LOD_BIAS: ------------------ | Branch (4523:17): [True: 6, False: 8.05k] ------------------ 4524| 6| if(getValue(prop, compiler, fval)) ------------------ | Branch (4524:24): [True: 1, False: 5] ------------------ 4525| 1| mTarget->setLodBias(fval); 4526| 6| break; 4527| 222| case ID_MATERIAL_SCHEME: ------------------ | Branch (4527:17): [True: 222, False: 7.83k] ------------------ 4528| 222| if(getValue(prop, compiler, sval)) ------------------ | Branch (4528:24): [True: 202, False: 20] ------------------ 4529| 202| mTarget->setMaterialScheme(sval); 4530| 222| break; 4531| 74| case ID_SHADOWS_ENABLED: ------------------ | Branch (4531:17): [True: 74, False: 7.98k] ------------------ 4532| 74| if(getValue(prop, compiler, bval)) ------------------ | Branch (4532:24): [True: 66, False: 8] ------------------ 4533| 66| mTarget->setShadowsEnabled(bval); 4534| 74| break; 4535| 1.25k| default: ------------------ | Branch (4535:17): [True: 1.25k, False: 6.80k] ------------------ 4536| 1.25k| compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line, 4537| 1.25k| "token \"" + prop->name + "\" is not recognized"); 4538| 8.05k| } 4539| 8.05k| } 4540| 13.2k| } 4541| 4.41k| } _ZN4Ogre25CompositionPassTranslatorC2Ev: 4547| 1| :mPass(0) 4548| 1| { 4549| 1| } _ZN4Ogre25CompositionPassTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEE: 4552| 3.62k| { 4553| 3.62k| ObjectAbstractNode *obj = static_cast(node.get()); 4554| | 4555| | // The name is the type of the pass 4556| 3.62k| if(obj->values.empty() || obj->values.front()->type != ANT_ATOM) ------------------ | Branch (4556:12): [True: 58, False: 3.56k] | Branch (4556:35): [True: 0, False: 3.56k] ------------------ 4557| 58| { 4558| 58| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, obj->file, obj->line, "pass type missing"); 4559| 58| return; 4560| 58| } 4561| | 4562| 3.56k| AtomAbstractNode* atom = static_cast(obj->values.front().get()); 4563| | 4564| 3.56k| CompositionPass::PassType ptype; 4565| 3.56k| switch(atom->id) 4566| 3.56k| { 4567| 1.04k| case ID_CLEAR: ------------------ | Branch (4567:13): [True: 1.04k, False: 2.52k] ------------------ 4568| 1.04k| ptype = CompositionPass::PT_CLEAR; 4569| 1.04k| break; 4570| 1| case ID_STENCIL: ------------------ | Branch (4570:13): [True: 1, False: 3.56k] ------------------ 4571| 1| ptype = CompositionPass::PT_STENCIL; 4572| 1| break; 4573| 1.61k| case ID_RENDER_QUAD: ------------------ | Branch (4573:13): [True: 1.61k, False: 1.95k] ------------------ 4574| 1.61k| ptype = CompositionPass::PT_RENDERQUAD; 4575| 1.61k| break; 4576| 763| case ID_RENDER_SCENE: ------------------ | Branch (4576:13): [True: 763, False: 2.80k] ------------------ 4577| 763| ptype = CompositionPass::PT_RENDERSCENE; 4578| 763| break; 4579| 53| case ID_COMPUTE: ------------------ | Branch (4579:13): [True: 53, False: 3.51k] ------------------ 4580| 53| ptype = CompositionPass::PT_COMPUTE; 4581| 53| break; 4582| 18| case ID_RENDER_CUSTOM: ------------------ | Branch (4582:13): [True: 18, False: 3.54k] ------------------ 4583| 18| ptype = CompositionPass::PT_RENDERCUSTOM; 4584| 18| break; 4585| 78| default: ------------------ | Branch (4585:13): [True: 78, False: 3.48k] ------------------ 4586| 78| compiler->addError(*obj, atom->value); 4587| 78| return; 4588| 3.56k| } 4589| | 4590| 3.48k| CompositionTargetPass *target = any_cast(obj->parent->context); 4591| 3.48k| mPass = target->createPass(ptype); 4592| 3.48k| obj->context = mPass; 4593| | 4594| 3.48k| if(mPass->getType() == CompositionPass::PT_RENDERCUSTOM) ------------------ | Branch (4594:12): [True: 18, False: 3.46k] ------------------ 4595| 18| { 4596| 18| String customType; 4597| | //This is the ugly one liner for safe access to the second parameter. 4598| 18| if (obj->values.size() < 2 || !getString(*(++(obj->values.begin())), &customType)) ------------------ | Branch (4598:17): [True: 1, False: 17] | Branch (4598:17): [True: 1, False: 17] | Branch (4598:43): [True: 0, False: 17] ------------------ 4599| 1| { 4600| 1| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, obj->file, obj->line); 4601| 1| return; 4602| 1| } 4603| 17| mPass->setCustomType(customType); 4604| 17| } 4605| | 4606| 3.48k| Real fval; 4607| 3.48k| bool bval; 4608| 3.48k| uint32 uival; 4609| 3.48k| String sval; 4610| 3.48k| StencilOperation sop; 4611| | 4612| 3.48k| for(auto & i : obj->children) ------------------ | Branch (4612:22): [True: 8.08k, False: 3.30k] ------------------ 4613| 8.08k| { 4614| 8.08k| if(i->type == ANT_OBJECT) ------------------ | Branch (4614:16): [True: 390, False: 7.69k] ------------------ 4615| 390| { 4616| 390| processNode(compiler, i); 4617| 390| } 4618| 7.69k| else if(i->type == ANT_PROPERTY) ------------------ | Branch (4618:21): [True: 6.99k, False: 704] ------------------ 4619| 6.99k| { 4620| 6.99k| PropertyAbstractNode *prop = static_cast(i.get()); 4621| 6.99k| switch(prop->id) 4622| 6.99k| { 4623| 1| case ID_CHECK: ------------------ | Branch (4623:17): [True: 1, False: 6.99k] ------------------ 4624| 1| if(getValue(prop, compiler, bval)) ------------------ | Branch (4624:24): [True: 0, False: 1] ------------------ 4625| 0| mPass->setStencilCheck(bval); 4626| 1| break; 4627| 4| case ID_COMP_FUNC: ------------------ | Branch (4627:17): [True: 4, False: 6.98k] ------------------ 4628| 4| CompareFunction func; 4629| 4| if(getValue(prop, compiler, func)) ------------------ | Branch (4629:24): [True: 1, False: 3] ------------------ 4630| 1| mPass->setStencilFunc(func); 4631| 4| break; 4632| 1| case ID_REF_VALUE: ------------------ | Branch (4632:17): [True: 1, False: 6.99k] ------------------ 4633| 1| if(getValue(prop, compiler, uival)) ------------------ | Branch (4633:24): [True: 0, False: 1] ------------------ 4634| 0| mPass->setStencilRefValue(uival); 4635| 1| break; 4636| 6| case ID_MASK: ------------------ | Branch (4636:17): [True: 6, False: 6.98k] ------------------ 4637| 6| if(getValue(prop, compiler, uival)) ------------------ | Branch (4637:24): [True: 2, False: 4] ------------------ 4638| 2| mPass->setStencilMask(uival); 4639| 6| break; 4640| 4| case ID_FAIL_OP: ------------------ | Branch (4640:17): [True: 4, False: 6.98k] ------------------ 4641| 4| if(getValue(prop, compiler, sop)) ------------------ | Branch (4641:24): [True: 0, False: 4] ------------------ 4642| 0| mPass->setStencilFailOp(sop); 4643| 4| break; 4644| 12| case ID_DEPTH_FAIL_OP: ------------------ | Branch (4644:17): [True: 12, False: 6.97k] ------------------ 4645| 12| if(getValue(prop, compiler, sop)) ------------------ | Branch (4645:24): [True: 0, False: 12] ------------------ 4646| 0| mPass->setStencilDepthFailOp(sop); 4647| 12| break; 4648| 25| case ID_PASS_OP: ------------------ | Branch (4648:17): [True: 25, False: 6.96k] ------------------ 4649| 25| if(getValue(prop, compiler, sop)) ------------------ | Branch (4649:24): [True: 0, False: 25] ------------------ 4650| 0| mPass->setStencilPassOp(sop); 4651| 25| break; 4652| 14| case ID_TWO_SIDED: ------------------ | Branch (4652:17): [True: 14, False: 6.97k] ------------------ 4653| 14| if(getValue(prop, compiler, bval)) ------------------ | Branch (4653:24): [True: 0, False: 14] ------------------ 4654| 0| mPass->setStencilTwoSidedOperation(bval); 4655| 14| break; 4656| 91| case ID_BUFFERS: ------------------ | Branch (4656:17): [True: 91, False: 6.90k] ------------------ 4657| 91| { 4658| 91| uint32 buffers = 0; 4659| 91| for(const auto& v : prop->values) ------------------ | Branch (4659:43): [True: 172, False: 91] ------------------ 4660| 172| { 4661| 172| switch(getAtomId(v)) 4662| 172| { 4663| 89| case ID_COLOUR: ------------------ | Branch (4663:29): [True: 89, False: 83] ------------------ 4664| 89| buffers |= FBT_COLOUR; 4665| 89| break; 4666| 25| case ID_DEPTH: ------------------ | Branch (4666:29): [True: 25, False: 147] ------------------ 4667| 25| buffers |= FBT_DEPTH; 4668| 25| break; 4669| 20| case ID_STENCIL: ------------------ | Branch (4669:29): [True: 20, False: 152] ------------------ 4670| 20| buffers |= FBT_STENCIL; 4671| 20| break; 4672| 38| default: ------------------ | Branch (4672:29): [True: 38, False: 134] ------------------ 4673| 38| compiler->addError(*prop); 4674| 172| } 4675| 172| } 4676| 91| mPass->setClearBuffers(buffers); 4677| 91| } 4678| 0| break; 4679| 31| case ID_COLOUR_VALUE: ------------------ | Branch (4679:17): [True: 31, False: 6.96k] ------------------ 4680| 31| { 4681| 31| if(prop->values.empty()) ------------------ | Branch (4681:28): [True: 1, False: 30] ------------------ 4682| 1| { 4683| 1| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line); 4684| 1| return; 4685| 1| } 4686| 30| ColourValue val; 4687| 30| if (getAtomId(prop->values.front()) == ID_AUTO) ------------------ | Branch (4687:29): [True: 0, False: 30] ------------------ 4688| 0| mPass->setAutomaticColour(true); 4689| 30| else if(getColour(prop->values.begin(), prop->values.end(), &val)) ------------------ | Branch (4689:33): [True: 16, False: 14] ------------------ 4690| 16| mPass->setClearColour(val); 4691| 14| else 4692| 14| compiler->addError(*prop); 4693| 30| } 4694| 0| break; 4695| 41| case ID_DEPTH_VALUE: ------------------ | Branch (4695:17): [True: 41, False: 6.95k] ------------------ 4696| 41| if(getValue(prop, compiler, fval)) ------------------ | Branch (4696:24): [True: 19, False: 22] ------------------ 4697| 19| mPass->setClearDepth(fval); 4698| 41| break; 4699| 14| case ID_STENCIL_VALUE: ------------------ | Branch (4699:17): [True: 14, False: 6.97k] ------------------ 4700| 14| if(getValue(prop, compiler, uival)) ------------------ | Branch (4700:24): [True: 0, False: 14] ------------------ 4701| 0| mPass->setClearStencil(uival); 4702| 14| break; 4703| 1.87k| case ID_MATERIAL: ------------------ | Branch (4703:17): [True: 1.87k, False: 5.12k] ------------------ 4704| 1.87k| if(getValue(prop, compiler, sval)) ------------------ | Branch (4704:24): [True: 1.81k, False: 54] ------------------ 4705| 1.81k| { 4706| 1.81k| String name = processResourceName(compiler, ResourceType::MATERIAL, sval); 4707| 1.81k| auto mat = MaterialManager::getSingleton().getByName(name, compiler->getResourceGroup()); 4708| 1.81k| if (mat) ------------------ | Branch (4708:29): [True: 125, False: 1.69k] ------------------ 4709| 125| mPass->setMaterial(mat); 4710| 1.69k| else 4711| 1.69k| compiler->addError(ScriptCompiler::CE_REFERENCETOANONEXISTINGOBJECT, prop->file, 4712| 1.69k| prop->line, name); 4713| 1.81k| } 4714| 1.87k| break; 4715| 2.57k| case ID_INPUT: ------------------ | Branch (4715:17): [True: 2.57k, False: 4.41k] ------------------ 4716| 2.57k| if(prop->values.size() < 2) ------------------ | Branch (4716:24): [True: 15, False: 2.56k] ------------------ 4717| 15| { 4718| 15| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 4719| 15| return; 4720| 15| } 4721| 2.56k| else if (prop->values.size() > 3) ------------------ | Branch (4721:30): [True: 40, False: 2.52k] ------------------ 4722| 40| { 4723| 40| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line); 4724| 40| return; 4725| 40| } 4726| 2.52k| else 4727| 2.52k| { 4728| 2.52k| AbstractNodeList::const_iterator i0 = getNodeAt(prop->values, 0), i1 = getNodeAt(prop->values, 1), i2 = getNodeAt(prop->values, 2); 4729| 2.52k| uint32 id; 4730| 2.52k| String name; 4731| 2.52k| if(getUInt(*i0, &id) && getString(*i1, &name)) ------------------ | Branch (4731:28): [True: 2.48k, False: 31] | Branch (4731:49): [True: 2.48k, False: 1] ------------------ 4732| 2.48k| { 4733| 2.48k| uint32 index = 0; 4734| 2.48k| if(i2 != prop->values.end()) ------------------ | Branch (4734:32): [True: 1.21k, False: 1.27k] ------------------ 4735| 1.21k| { 4736| 1.21k| if(!getUInt(*i2, &index)) ------------------ | Branch (4736:36): [True: 10, False: 1.20k] ------------------ 4737| 10| { 4738| 10| compiler->addError(ScriptCompiler::CE_NUMBEREXPECTED, prop->file, prop->line); 4739| 10| return; 4740| 10| } 4741| 1.21k| } 4742| | 4743| 2.47k| if(id >= OGRE_MAX_TEXTURE_LAYERS) ------------------ | Branch (4743:32): [True: 47, False: 2.43k] ------------------ 4744| 47| { 4745| 47| compiler->addError(*prop, "input id must be less than " + 4746| 47| std::to_string(OGRE_MAX_TEXTURE_LAYERS)); 4747| 47| return; 4748| 47| } 4749| | 4750| 2.43k| mPass->setInput(id, name, index); 4751| 2.43k| } 4752| 32| else 4753| 32| { 4754| 32| compiler->addError(*prop); 4755| 32| } 4756| 2.52k| } 4757| 2.46k| break; 4758| 2.46k| case ID_IDENTIFIER: ------------------ | Branch (4758:17): [True: 693, False: 6.29k] ------------------ 4759| 693| if(getValue(prop, compiler, uival)) ------------------ | Branch (4759:24): [True: 678, False: 15] ------------------ 4760| 678| mPass->setIdentifier(uival); 4761| 693| break; 4762| 57| case ID_FIRST_RENDER_QUEUE: ------------------ | Branch (4762:17): [True: 57, False: 6.93k] ------------------ 4763| 57| if(getValue(prop, compiler, uival)) ------------------ | Branch (4763:24): [True: 54, False: 3] ------------------ 4764| 54| mPass->setFirstRenderQueue(static_cast(uival)); 4765| 57| break; 4766| 98| case ID_LAST_RENDER_QUEUE: ------------------ | Branch (4766:17): [True: 98, False: 6.89k] ------------------ 4767| 98| if(getValue(prop, compiler, uival)) ------------------ | Branch (4767:24): [True: 89, False: 9] ------------------ 4768| 89| mPass->setLastRenderQueue(static_cast(uival)); 4769| 98| break; 4770| 26| case ID_MATERIAL_SCHEME: ------------------ | Branch (4770:17): [True: 26, False: 6.96k] ------------------ 4771| 26| if(getValue(prop, compiler, sval)) ------------------ | Branch (4771:24): [True: 22, False: 4] ------------------ 4772| 22| mPass->setMaterialScheme(sval); 4773| 26| break; 4774| 76| case ID_THREAD_GROUPS: ------------------ | Branch (4774:17): [True: 76, False: 6.91k] ------------------ 4775| 76| { 4776| 76| std::vector g; 4777| 76| if(_getVector(prop->values.begin(), prop->values.end(), g, 3)) ------------------ | Branch (4777:24): [True: 49, False: 27] ------------------ 4778| 49| mPass->setThreadGroups({g[0], g[1], g[2]}); 4779| 76| break; 4780| 2.57k| } 4781| 360| case ID_QUAD_NORMALS: ------------------ | Branch (4781:17): [True: 360, False: 6.63k] ------------------ 4782| 360| if(prop->values.empty()) ------------------ | Branch (4782:24): [True: 4, False: 356] ------------------ 4783| 4| { 4784| 4| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 4785| 4| return; 4786| 4| } 4787| 356| else if (prop->values.size() > 1) ------------------ | Branch (4787:30): [True: 6, False: 350] ------------------ 4788| 6| { 4789| 6| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line); 4790| 6| return; 4791| 6| } 4792| 350| else 4793| 350| { 4794| 350| uint32 quadNormalsId = getAtomId(prop->values.front()); 4795| 350| if(quadNormalsId == ID_CAMERA_FAR_CORNERS_VIEW_SPACE) ------------------ | Branch (4795:28): [True: 290, False: 60] ------------------ 4796| 290| mPass->setQuadFarCorners(true, true); 4797| 60| else if(quadNormalsId == ID_CAMERA_FAR_CORNERS_WORLD_SPACE) ------------------ | Branch (4797:33): [True: 0, False: 60] ------------------ 4798| 0| mPass->setQuadFarCorners(true, false); 4799| 60| else 4800| 60| compiler->addError(*prop); 4801| 350| } 4802| 350| break; 4803| 433| case ID_CAMERA: ------------------ | Branch (4803:17): [True: 433, False: 6.55k] ------------------ 4804| 433| if(prop->values.empty()) ------------------ | Branch (4804:24): [True: 0, False: 433] ------------------ 4805| 0| { 4806| 0| compiler->addError(ScriptCompiler::CE_STRINGEXPECTED, prop->file, prop->line); 4807| 0| return; 4808| 0| } 4809| 433| else if (prop->values.size() > 2) ------------------ | Branch (4809:30): [True: 55, False: 378] ------------------ 4810| 55| { 4811| 55| compiler->addError(ScriptCompiler::CE_FEWERPARAMETERSEXPECTED, prop->file, prop->line); 4812| 55| return; 4813| 55| } 4814| 378| else 4815| 378| { 4816| 378| if (!getValue(prop->values.front(), sval)) ------------------ | Branch (4816:29): [True: 1, False: 377] ------------------ 4817| 1| return; 4818| 377| mPass->setCameraName(sval); 4819| 377| if (getAtomId(prop->values.back()) == ID_ALIGN_TO_FACE) ------------------ | Branch (4819:29): [True: 308, False: 69] ------------------ 4820| 308| { 4821| 308| mPass->setAlignCameraToFace(true); 4822| 308| } 4823| 377| } 4824| 377| break; 4825| 558| default: ------------------ | Branch (4825:17): [True: 558, False: 6.43k] ------------------ 4826| 558| compiler->addError(ScriptCompiler::CE_UNEXPECTEDTOKEN, prop->file, prop->line, 4827| 558| "token \"" + prop->name + "\" is not recognized"); 4828| 6.99k| } 4829| 6.99k| } 4830| 8.08k| } 4831| 3.48k| } _ZN4Ogre30BuiltinScriptTranslatorManagerC2Ev: 4837| 1| { 4838| 1| } _ZN4Ogre30BuiltinScriptTranslatorManager13getTranslatorERKNS_9SharedPtrINS_12AbstractNodeEEE: 4841| 107k| { 4842| 107k| ScriptTranslator *translator = 0; 4843| | 4844| 107k| if(node->type == ANT_OBJECT) ------------------ | Branch (4844:12): [True: 84.5k, False: 23.0k] ------------------ 4845| 84.5k| { 4846| 84.5k| ObjectAbstractNode *obj = static_cast(node.get()); 4847| 84.5k| ObjectAbstractNode *parent = obj->parent && obj->parent->type == ANT_OBJECT ? static_cast(obj->parent) : 0; ------------------ | Branch (4847:42): [True: 61.9k, False: 22.6k] | Branch (4847:57): [True: 61.9k, False: 0] ------------------ 4848| 84.5k| if(obj->id == ID_MATERIAL) ------------------ | Branch (4848:16): [True: 12.9k, False: 71.6k] ------------------ 4849| 12.9k| translator = &mMaterialTranslator; 4850| 71.6k| else if(obj->id == ID_TECHNIQUE && parent && parent->id == ID_MATERIAL) ------------------ | Branch (4850:21): [True: 14.2k, False: 57.3k] | Branch (4850:48): [True: 13.9k, False: 265] | Branch (4850:58): [True: 11.7k, False: 2.26k] ------------------ 4851| 11.7k| translator = &mTechniqueTranslator; 4852| 59.9k| else if(obj->id == ID_PASS && parent && parent->id == ID_TECHNIQUE) ------------------ | Branch (4852:21): [True: 15.8k, False: 44.0k] | Branch (4852:43): [True: 15.6k, False: 213] | Branch (4852:53): [True: 11.5k, False: 4.04k] ------------------ 4853| 11.5k| translator = &mPassTranslator; 4854| 48.3k| else if(obj->id == ID_TEXTURE_UNIT && parent && parent->id == ID_PASS) ------------------ | Branch (4854:21): [True: 14.3k, False: 33.9k] | Branch (4854:51): [True: 14.0k, False: 335] | Branch (4854:61): [True: 12.7k, False: 1.30k] ------------------ 4855| 12.7k| translator = &mTextureUnitTranslator; 4856| 35.5k| else if(obj->id == ID_TEXTURE_SOURCE && parent && parent->id == ID_TEXTURE_UNIT) ------------------ | Branch (4856:21): [True: 72, False: 35.4k] | Branch (4856:53): [True: 47, False: 25] | Branch (4856:63): [True: 18, False: 29] ------------------ 4857| 18| translator = &mTextureSourceTranslator; 4858| 35.5k| else if(obj->id == ID_FRAGMENT_PROGRAM || ------------------ | Branch (4858:21): [True: 2.50k, False: 33.0k] ------------------ 4859| 33.0k| obj->id == ID_VERTEX_PROGRAM || ------------------ | Branch (4859:21): [True: 1.23k, False: 31.7k] ------------------ 4860| 31.7k| obj->id == ID_GEOMETRY_PROGRAM || ------------------ | Branch (4860:21): [True: 809, False: 30.9k] ------------------ 4861| 30.9k| obj->id == ID_TESSELLATION_HULL_PROGRAM || ------------------ | Branch (4861:21): [True: 75, False: 30.9k] ------------------ 4862| 30.9k| obj->id == ID_TESSELLATION_DOMAIN_PROGRAM || ------------------ | Branch (4862:21): [True: 86, False: 30.8k] ------------------ 4863| 30.8k| obj->id == ID_COMPUTE_PROGRAM || ------------------ | Branch (4863:21): [True: 102, False: 30.7k] ------------------ 4864| 30.7k| obj->id == ID_MESH_PROGRAM || ------------------ | Branch (4864:21): [True: 19, False: 30.6k] ------------------ 4865| 30.6k| obj->id == ID_TASK_PROGRAM) ------------------ | Branch (4865:21): [True: 0, False: 30.6k] ------------------ 4866| 4.83k| translator = &mGpuProgramTranslator; 4867| 30.6k| else if(obj->id == ID_SHARED_PARAMS) ------------------ | Branch (4867:21): [True: 154, False: 30.5k] ------------------ 4868| 154| translator = &mSharedParamsTranslator; 4869| 30.5k| else if(obj->id == ID_PARTICLE_SYSTEM) ------------------ | Branch (4869:21): [True: 16, False: 30.5k] ------------------ 4870| 16| translator = &mParticleSystemTranslator; 4871| 30.5k| else if(obj->id == ID_EMITTER && parent && parent->id == ID_PARTICLE_SYSTEM) ------------------ | Branch (4871:21): [True: 83, False: 30.4k] | Branch (4871:46): [True: 46, False: 37] | Branch (4871:56): [True: 0, False: 46] ------------------ 4872| 0| translator = &mParticleEmitterTranslator; 4873| 30.5k| else if(obj->id == ID_AFFECTOR && parent && parent->id == ID_PARTICLE_SYSTEM) ------------------ | Branch (4873:21): [True: 72, False: 30.4k] | Branch (4873:47): [True: 38, False: 34] | Branch (4873:57): [True: 0, False: 38] ------------------ 4874| 0| translator = &mParticleAffectorTranslator; 4875| 30.5k| else if(obj->id == ID_COMPOSITOR) ------------------ | Branch (4875:21): [True: 2.20k, False: 28.3k] ------------------ 4876| 2.20k| translator = &mCompositorTranslator; 4877| 28.3k| else if(obj->id == ID_TECHNIQUE && parent && parent->id == ID_COMPOSITOR) ------------------ | Branch (4877:21): [True: 2.52k, False: 25.7k] | Branch (4877:48): [True: 2.26k, False: 265] | Branch (4877:58): [True: 2.03k, False: 231] ------------------ 4878| 2.03k| translator = &mCompositionTechniqueTranslator; 4879| 26.2k| else if((obj->id == ID_TARGET || obj->id == ID_TARGET_OUTPUT) && parent && parent->id == ID_TECHNIQUE) ------------------ | Branch (4879:22): [True: 3.53k, False: 22.7k] | Branch (4879:46): [True: 1.57k, False: 21.1k] | Branch (4879:78): [True: 4.93k, False: 170] | Branch (4879:88): [True: 4.41k, False: 520] ------------------ 4880| 4.41k| translator = &mCompositionTargetPassTranslator; 4881| 21.8k| else if(obj->id == ID_PASS && parent && (parent->id == ID_TARGET || parent->id == ID_TARGET_OUTPUT)) ------------------ | Branch (4881:21): [True: 4.25k, False: 17.6k] | Branch (4881:43): [True: 4.04k, False: 213] | Branch (4881:54): [True: 2.56k, False: 1.48k] | Branch (4881:81): [True: 1.06k, False: 418] ------------------ 4882| 3.62k| translator = &mCompositionPassTranslator; 4883| 18.2k| else if(obj->id == ID_SAMPLER) ------------------ | Branch (4883:21): [True: 281, False: 17.9k] ------------------ 4884| 281| translator = &mSamplerTranslator; 4885| 84.5k| } 4886| | 4887| 107k| return translator; 4888| 107k| } OgreScriptTranslator.cpp:_ZN4OgreL9getAtomIdERKNS_9SharedPtrINS_12AbstractNodeEEE: 87| 33.5k| { 88| 33.5k| return node->type == ANT_ATOM ? static_cast(node.get())->id : 0; ------------------ | Branch (88:16): [True: 33.3k, False: 199] ------------------ 89| 33.5k| } OgreScriptTranslator.cpp:_ZN4OgreL19applyTextureAliasesEPNS_14ScriptCompilerEPKNS_8MaterialERKNSt3__13mapINS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESC_NS5_4lessISC_EENSA_INS5_4pairIKSC_SC_EEEEEE: 64| 12.2k| { 65| 12.2k| for (auto t : mat->getTechniques()) ------------------ | Branch (65:21): [True: 11.4k, False: 12.2k] ------------------ 66| 11.4k| { 67| 11.4k| for (auto p : t->getPasses()) ------------------ | Branch (67:25): [True: 11.3k, False: 11.4k] ------------------ 68| 11.3k| { 69| 11.3k| for (auto tus : p->getTextureUnitStates()) ------------------ | Branch (69:31): [True: 12.6k, False: 11.3k] ------------------ 70| 12.6k| { 71| 12.6k| auto aliasIt = aliasList.find(tus->getName()); 72| 12.6k| if (aliasIt == aliasList.end()) ------------------ | Branch (72:25): [True: 12.6k, False: 0] ------------------ 73| 12.6k| continue; 74| | 75| 0| auto name = processResourceName(compiler, ResourceType::TEXTURE, aliasIt->second); 76| 0| if (tus->getNumFrames() > 1) ------------------ | Branch (76:25): [True: 0, False: 0] ------------------ 77| 0| tus->setAnimatedTextureName(name, tus->getNumFrames(), 78| 0| tus->getAnimationDuration()); 79| 0| else 80| 0| tus->setTextureName(name, tus->getTextureType()); 81| 0| } 82| 11.3k| } 83| 11.4k| } 84| 12.2k| } OgreScriptTranslator.cpp:_ZN4OgreL19processResourceNameEPNS_14ScriptCompilerENS_38ProcessResourceNameScriptCompilerEvent12ResourceTypeERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 50| 19.5k| { 51| 19.5k| ProcessResourceNameScriptCompilerEvent evt(type, name); 52| 19.5k| compiler->_fireEvent(&evt, 0); 53| 19.5k| return evt.mName; 54| 19.5k| } OgreScriptTranslator.cpp:_ZZN4Ogre14PassTranslator9translateEPNS_14ScriptCompilerERKNS_9SharedPtrINS_12AbstractNodeEEEENK3$_0clENSt3__121__list_const_iteratorIS5_PvEE: 1860| 223| { 1861| 223| if(it == prop->values.end()) ------------------ | Branch (1861:28): [True: 171, False: 52] ------------------ 1862| 171| { 1863| 171| mPass->setIteratePerLight(true, false); 1864| 171| return; 1865| 171| } 1866| 52| switch(getAtomId(*it)) 1867| 52| { 1868| 17| case ID_POINT: ------------------ | Branch (1868:25): [True: 17, False: 35] ------------------ 1869| 17| mPass->setIteratePerLight(true, true, Light::LT_POINT); 1870| 17| break; 1871| 0| case ID_DIRECTIONAL: ------------------ | Branch (1871:25): [True: 0, False: 52] ------------------ 1872| 0| mPass->setIteratePerLight(true, true, Light::LT_DIRECTIONAL); 1873| 0| break; 1874| 0| case ID_SPOT: ------------------ | Branch (1874:25): [True: 0, False: 52] ------------------ 1875| 0| mPass->setIteratePerLight(true, true, Light::LT_SPOTLIGHT); 1876| 0| break; 1877| 35| default: ------------------ | Branch (1877:25): [True: 35, False: 17] ------------------ 1878| 35| compiler->addError(*prop, (*it)->getValue() + " is not a valid light type (point, directional, or spot)"); 1879| 52| } 1880| 52| }; OgreScriptTranslator.cpp:_ZN4OgreL14getProgramTypeEi: 472| 8.79k| { 473| 8.79k| switch(id) 474| 8.79k| { 475| 0| default: ------------------ | Branch (475:9): [True: 0, False: 8.79k] ------------------ 476| 0| assert(false); 477| 0| OGRE_FALLTHROUGH; 478| 1.36k| case ID_VERTEX_PROGRAM: ------------------ | Branch (478:9): [True: 1.36k, False: 7.43k] ------------------ 479| 2.13k| case ID_VERTEX_PROGRAM_REF: ------------------ | Branch (479:9): [True: 769, False: 8.02k] ------------------ 480| 2.13k| return GPT_VERTEX_PROGRAM; 481| 2.61k| case ID_FRAGMENT_PROGRAM: ------------------ | Branch (481:9): [True: 2.61k, False: 6.17k] ------------------ 482| 3.47k| case ID_FRAGMENT_PROGRAM_REF: ------------------ | Branch (482:9): [True: 864, False: 7.92k] ------------------ 483| 3.47k| return GPT_FRAGMENT_PROGRAM; 484| 229| case ID_GEOMETRY_PROGRAM: ------------------ | Branch (484:9): [True: 229, False: 8.56k] ------------------ 485| 286| case ID_GEOMETRY_PROGRAM_REF: ------------------ | Branch (485:9): [True: 57, False: 8.73k] ------------------ 486| 286| return GPT_GEOMETRY_PROGRAM; 487| 118| case ID_TESSELLATION_DOMAIN_PROGRAM: ------------------ | Branch (487:9): [True: 118, False: 8.67k] ------------------ 488| 1.02k| case ID_TESSELLATION_DOMAIN_PROGRAM_REF: ------------------ | Branch (488:9): [True: 910, False: 7.88k] ------------------ 489| 1.02k| return GPT_DOMAIN_PROGRAM; 490| 101| case ID_TESSELLATION_HULL_PROGRAM: ------------------ | Branch (490:9): [True: 101, False: 8.69k] ------------------ 491| 1.74k| case ID_TESSELLATION_HULL_PROGRAM_REF: ------------------ | Branch (491:9): [True: 1.64k, False: 7.15k] ------------------ 492| 1.74k| return GPT_HULL_PROGRAM; 493| 93| case ID_COMPUTE_PROGRAM: ------------------ | Branch (493:9): [True: 93, False: 8.70k] ------------------ 494| 108| case ID_COMPUTE_PROGRAM_REF: ------------------ | Branch (494:9): [True: 15, False: 8.77k] ------------------ 495| 108| return GPT_COMPUTE_PROGRAM; 496| 17| case ID_MESH_PROGRAM: ------------------ | Branch (496:9): [True: 17, False: 8.77k] ------------------ 497| 18| case ID_MESH_PROGRAM_REF: ------------------ | Branch (497:9): [True: 1, False: 8.79k] ------------------ 498| 18| return GPT_MESH_PROGRAM; 499| 0| case ID_TASK_PROGRAM: ------------------ | Branch (499:9): [True: 0, False: 8.79k] ------------------ 500| 0| case ID_TASK_PROGRAM_REF: ------------------ | Branch (500:9): [True: 0, False: 8.79k] ------------------ 501| 0| return GPT_TASK_PROGRAM; 502| 8.79k| } 503| 8.79k| } OgreScriptTranslator.cpp:_ZN4OgreL10getProgramEPNS_14ScriptCompilerEPNS_18ObjectAbstractNodeE: 2042| 4.29k| { 2043| 4.29k| if(node->name.empty()) ------------------ | Branch (2043:12): [True: 23, False: 4.27k] ------------------ 2044| 23| { 2045| 23| compiler->addError(ScriptCompiler::CE_OBJECTNAMEEXPECTED, node->file, node->line); 2046| 23| return nullptr; 2047| 23| } 2048| | 2049| 4.27k| String name = processResourceName(compiler, ResourceType::GPU_PROGRAM, node->name); 2050| | 2051| 4.27k| auto& mgr = GpuProgramManager::getSingleton(); 2052| 4.27k| if (auto ret = mgr.getByName(name, compiler->getResourceGroup())) ------------------ | Branch (2052:18): [True: 2.49k, False: 1.77k] ------------------ 2053| 2.49k| return ret; 2054| | 2055| | // recheck with auto resource group 2056| 1.77k| if (auto ret = mgr.getByName(name, RGN_AUTODETECT)) ------------------ | Branch (2056:18): [True: 0, False: 1.77k] ------------------ 2057| 0| return ret; 2058| | 2059| 1.77k| compiler->addError(ScriptCompiler::CE_REFERENCETOANONEXISTINGOBJECT, node->file, node->line, 2060| 1.77k| name); 2061| 1.77k| return nullptr; 2062| 1.77k| } OgreScriptTranslator.cpp:_ZN4OgreL20processResourceNamesEPNS_14ScriptCompilerENS_38ProcessResourceNameScriptCompilerEvent12ResourceTypeERNSt3__16vectorINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENS9_ISB_EEEE: 56| 125| { 57| 125| if (!compiler->getListener()) ------------------ | Branch (57:13): [True: 0, False: 125] ------------------ 58| 0| return; // nothing would change 59| 125| for (String& n : names) ------------------ | Branch (59:24): [True: 608, False: 125] ------------------ 60| 608| n = processResourceName(compiler, type, n); 61| 125| } OgreScriptTranslator.cpp:_ZN4OgreL10_getVectorIiEEbNSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEES7_RNS1_6vectorIT_NS1_9allocatorIS9_EEEEm: 452| 90| { 453| 90| vals.reserve(count); 454| 90| size_t n = 0; 455| 257| while (n < count) ------------------ | Branch (455:16): [True: 195, False: 62] ------------------ 456| 195| { 457| 195| if (i != end) ------------------ | Branch (457:17): [True: 191, False: 4] ------------------ 458| 191| { 459| 191| T v; 460| 191| if (!getValue(*i++, v)) ------------------ | Branch (460:21): [True: 28, False: 163] ------------------ 461| 28| return false; 462| 163| vals.push_back(v); 463| 163| } 464| 167| ++n; 465| 167| } 466| | 467| 62| vals.resize(count); 468| 62| return true; 469| 90| } OgreScriptTranslator.cpp:_ZN4OgreL10_getVectorIfEEbNSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEES7_RNS1_6vectorIT_NS1_9allocatorIS9_EEEEm: 452| 1.74k| { 453| 1.74k| vals.reserve(count); 454| 1.74k| size_t n = 0; 455| 5.15k| while (n < count) ------------------ | Branch (455:16): [True: 3.48k, False: 1.67k] ------------------ 456| 3.48k| { 457| 3.48k| if (i != end) ------------------ | Branch (457:17): [True: 3.48k, False: 0] ------------------ 458| 3.48k| { 459| 3.48k| T v; 460| 3.48k| if (!getValue(*i++, v)) ------------------ | Branch (460:21): [True: 70, False: 3.41k] ------------------ 461| 70| return false; 462| 3.41k| vals.push_back(v); 463| 3.41k| } 464| 3.41k| ++n; 465| 3.41k| } 466| | 467| 1.67k| vals.resize(count); 468| 1.67k| return true; 469| 1.74k| } OgreScriptTranslator.cpp:_ZN4OgreL8getValueINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_: 433| 9.80k| { 434| 9.80k| if (prop->values.size() != 1) ------------------ | Branch (434:13): [True: 224, False: 9.57k] ------------------ 435| 224| { 436| 224| compiler->addError(*prop, prop->name + " must have exactly 1 argument"); 437| 224| } 438| 9.57k| else 439| 9.57k| { 440| 9.57k| if (getValue(prop->values.front(), val)) ------------------ | Branch (440:17): [True: 9.56k, False: 14] ------------------ 441| 9.56k| return true; 442| 14| else 443| 14| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name); 444| 9.57k| } 445| | 446| 238| return false; 447| 9.80k| } OgreScriptTranslator.cpp:_ZN4OgreL8getValueIbEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_: 433| 9.67k| { 434| 9.67k| if (prop->values.size() != 1) ------------------ | Branch (434:13): [True: 155, False: 9.51k] ------------------ 435| 155| { 436| 155| compiler->addError(*prop, prop->name + " must have exactly 1 argument"); 437| 155| } 438| 9.51k| else 439| 9.51k| { 440| 9.51k| if (getValue(prop->values.front(), val)) ------------------ | Branch (440:17): [True: 8.95k, False: 563] ------------------ 441| 8.95k| return true; 442| 563| else 443| 563| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name); 444| 9.51k| } 445| | 446| 718| return false; 447| 9.67k| } OgreScriptTranslator.cpp:_ZN4OgreL8getValueIjEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_: 433| 2.11k| { 434| 2.11k| if (prop->values.size() != 1) ------------------ | Branch (434:13): [True: 111, False: 2.00k] ------------------ 435| 111| { 436| 111| compiler->addError(*prop, prop->name + " must have exactly 1 argument"); 437| 111| } 438| 2.00k| else 439| 2.00k| { 440| 2.00k| if (getValue(prop->values.front(), val)) ------------------ | Branch (440:17): [True: 1.93k, False: 64] ------------------ 441| 1.93k| return true; 442| 64| else 443| 64| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name); 444| 2.00k| } 445| | 446| 175| return false; 447| 2.11k| } OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_19SceneBlendOperationEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_: 433| 14| { 434| 14| if (prop->values.size() != 1) ------------------ | Branch (434:13): [True: 11, False: 3] ------------------ 435| 11| { 436| 11| compiler->addError(*prop, prop->name + " must have exactly 1 argument"); 437| 11| } 438| 3| else 439| 3| { 440| 3| if (getValue(prop->values.front(), val)) ------------------ | Branch (440:17): [True: 0, False: 3] ------------------ 441| 0| return true; 442| 3| else 443| 3| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name); 444| 3| } 445| | 446| 14| return false; 447| 14| } OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_15CompareFunctionEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_: 433| 189| { 434| 189| if (prop->values.size() != 1) ------------------ | Branch (434:13): [True: 33, False: 156] ------------------ 435| 33| { 436| 33| compiler->addError(*prop, prop->name + " must have exactly 1 argument"); 437| 33| } 438| 156| else 439| 156| { 440| 156| if (getValue(prop->values.front(), val)) ------------------ | Branch (440:17): [True: 115, False: 41] ------------------ 441| 115| return true; 442| 41| else 443| 41| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name); 444| 156| } 445| | 446| 74| return false; 447| 189| } OgreScriptTranslator.cpp:_ZN4OgreL8getValueIfEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_: 433| 570| { 434| 570| if (prop->values.size() != 1) ------------------ | Branch (434:13): [True: 87, False: 483] ------------------ 435| 87| { 436| 87| compiler->addError(*prop, prop->name + " must have exactly 1 argument"); 437| 87| } 438| 483| else 439| 483| { 440| 483| if (getValue(prop->values.front(), val)) ------------------ | Branch (440:17): [True: 425, False: 58] ------------------ 441| 425| return true; 442| 58| else 443| 58| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name); 444| 483| } 445| | 446| 145| return false; 447| 570| } OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_17IlluminationStageEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_: 433| 39| { 434| 39| if (prop->values.size() != 1) ------------------ | Branch (434:13): [True: 17, False: 22] ------------------ 435| 17| { 436| 17| compiler->addError(*prop, prop->name + " must have exactly 1 argument"); 437| 17| } 438| 22| else 439| 22| { 440| 22| if (getValue(prop->values.front(), val)) ------------------ | Branch (440:17): [True: 5, False: 17] ------------------ 441| 5| return true; 442| 17| else 443| 17| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name); 444| 22| } 445| | 446| 34| return false; 447| 39| } OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_11CullingModeEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_: 433| 2.49k| { 434| 2.49k| if (prop->values.size() != 1) ------------------ | Branch (434:13): [True: 66, False: 2.42k] ------------------ 435| 66| { 436| 66| compiler->addError(*prop, prop->name + " must have exactly 1 argument"); 437| 66| } 438| 2.42k| else 439| 2.42k| { 440| 2.42k| if (getValue(prop->values.front(), val)) ------------------ | Branch (440:17): [True: 2.34k, False: 86] ------------------ 441| 2.34k| return true; 442| 86| else 443| 86| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name); 444| 2.42k| } 445| | 446| 152| return false; 447| 2.49k| } OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_17ManualCullingModeEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_: 433| 72| { 434| 72| if (prop->values.size() != 1) ------------------ | Branch (434:13): [True: 11, False: 61] ------------------ 435| 11| { 436| 11| compiler->addError(*prop, prop->name + " must have exactly 1 argument"); 437| 11| } 438| 61| else 439| 61| { 440| 61| if (getValue(prop->values.front(), val)) ------------------ | Branch (440:17): [True: 38, False: 23] ------------------ 441| 38| return true; 442| 23| else 443| 23| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name); 444| 61| } 445| | 446| 34| return false; 447| 72| } OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_12ShadeOptionsEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_: 433| 58| { 434| 58| if (prop->values.size() != 1) ------------------ | Branch (434:13): [True: 51, False: 7] ------------------ 435| 51| { 436| 51| compiler->addError(*prop, prop->name + " must have exactly 1 argument"); 437| 51| } 438| 7| else 439| 7| { 440| 7| if (getValue(prop->values.front(), val)) ------------------ | Branch (440:17): [True: 0, False: 7] ------------------ 441| 0| return true; 442| 7| else 443| 7| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name); 444| 7| } 445| | 446| 58| return false; 447| 58| } OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_11PolygonModeEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_: 433| 82| { 434| 82| if (prop->values.size() != 1) ------------------ | Branch (434:13): [True: 48, False: 34] ------------------ 435| 48| { 436| 48| compiler->addError(*prop, prop->name + " must have exactly 1 argument"); 437| 48| } 438| 34| else 439| 34| { 440| 34| if (getValue(prop->values.front(), val)) ------------------ | Branch (440:17): [True: 5, False: 29] ------------------ 441| 5| return true; 442| 29| else 443| 29| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name); 444| 34| } 445| | 446| 77| return false; 447| 82| } OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_19LayerBlendOperationEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_: 433| 104| { 434| 104| if (prop->values.size() != 1) ------------------ | Branch (434:13): [True: 40, False: 64] ------------------ 435| 40| { 436| 40| compiler->addError(*prop, prop->name + " must have exactly 1 argument"); 437| 40| } 438| 64| else 439| 64| { 440| 64| if (getValue(prop->values.front(), val)) ------------------ | Branch (440:17): [True: 34, False: 30] ------------------ 441| 34| return true; 442| 30| else 443| 30| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name); 444| 64| } 445| | 446| 70| return false; 447| 104| } OgreScriptTranslator.cpp:_ZN4OgreL10_getVectorINSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEEEbNS1_21__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEESD_RNS1_6vectorIT_NS5_ISF_EEEEm: 452| 7.27k| { 453| 7.27k| vals.reserve(count); 454| 7.27k| size_t n = 0; 455| 19.7k| while (n < count) ------------------ | Branch (455:16): [True: 12.5k, False: 7.22k] ------------------ 456| 12.5k| { 457| 12.5k| if (i != end) ------------------ | Branch (457:17): [True: 12.5k, False: 0] ------------------ 458| 12.5k| { 459| 12.5k| T v; 460| 12.5k| if (!getValue(*i++, v)) ------------------ | Branch (460:21): [True: 49, False: 12.5k] ------------------ 461| 49| return false; 462| 12.5k| vals.push_back(v); 463| 12.5k| } 464| 12.5k| ++n; 465| 12.5k| } 466| | 467| 7.22k| vals.resize(count); 468| 7.22k| return true; 469| 7.27k| } OgreScriptTranslator.cpp:_ZN4OgreL10_getVectorIjEEbNSt3__121__list_const_iteratorINS_9SharedPtrINS_12AbstractNodeEEEPvEES7_RNS1_6vectorIT_NS1_9allocatorIS9_EEEEm: 452| 25| { 453| 25| vals.reserve(count); 454| 25| size_t n = 0; 455| 8.22k| while (n < count) ------------------ | Branch (455:16): [True: 8.21k, False: 7] ------------------ 456| 8.21k| { 457| 8.21k| if (i != end) ------------------ | Branch (457:17): [True: 22, False: 8.19k] ------------------ 458| 22| { 459| 22| T v; 460| 22| if (!getValue(*i++, v)) ------------------ | Branch (460:21): [True: 18, False: 4] ------------------ 461| 18| return false; 462| 4| vals.push_back(v); 463| 4| } 464| 8.19k| ++n; 465| 8.19k| } 466| | 467| 7| vals.resize(count); 468| 7| return true; 469| 25| } OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_21CompositionTargetPass9InputModeEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_: 433| 5.84k| { 434| 5.84k| if (prop->values.size() != 1) ------------------ | Branch (434:13): [True: 194, False: 5.65k] ------------------ 435| 194| { 436| 194| compiler->addError(*prop, prop->name + " must have exactly 1 argument"); 437| 194| } 438| 5.65k| else 439| 5.65k| { 440| 5.65k| if (getValue(prop->values.front(), val)) ------------------ | Branch (440:17): [True: 5.52k, False: 130] ------------------ 441| 5.52k| return true; 442| 130| else 443| 130| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name); 444| 5.65k| } 445| | 446| 324| return false; 447| 5.84k| } OgreScriptTranslator.cpp:_ZN4OgreL8getValueINS_16StencilOperationEEEbPNS_20PropertyAbstractNodeEPNS_14ScriptCompilerERT_: 433| 41| { 434| 41| if (prop->values.size() != 1) ------------------ | Branch (434:13): [True: 26, False: 15] ------------------ 435| 26| { 436| 26| compiler->addError(*prop, prop->name + " must have exactly 1 argument"); 437| 26| } 438| 15| else 439| 15| { 440| 15| if (getValue(prop->values.front(), val)) ------------------ | Branch (440:17): [True: 0, False: 15] ------------------ 441| 0| return true; 442| 15| else 443| 15| compiler->addError(*prop, prop->values.front()->getValue() + " is not a valid value for " + prop->name); 444| 15| } 445| | 446| 41| return false; 447| 41| } _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| 82| { 204| 82| std::transform( 205| 82| str.begin(), 206| 82| str.end(), 207| 82| str.begin(), 208| 82| tolower); 209| 82| } _ZN4Ogre10StringUtil11toUpperCaseERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 213| 5.38k| { 214| 5.38k| std::transform( 215| 5.38k| str.begin(), 216| 5.38k| str.end(), 217| 5.38k| str.begin(), 218| 5.38k| toupper); 219| 5.38k| } _ZN4Ogre10StringUtil17splitBaseFilenameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERS7_SA_: 382| 534| { 383| 534| size_t i = fullName.find_last_of('.'); 384| 534| if (i == Ogre::String::npos) ------------------ | Branch (384:13): [True: 4, False: 530] ------------------ 385| 4| { 386| 4| outExtention.clear(); 387| 4| outBasename = fullName; 388| 4| } 389| 530| else 390| 530| { 391| 530| outExtention = fullName.substr(i+1); 392| 530| outBasename = fullName.substr(0, i); 393| 530| } 394| 534| } _ZN4Ogre10StringUtil5matchERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_b: 405| 383| { 406| 383| String tmpStr = str; 407| 383| String tmpPattern = pattern; 408| 383| if (!caseSensitive) ------------------ | Branch (408:13): [True: 0, False: 383] ------------------ 409| 0| { 410| 0| StringUtil::toLowerCase(tmpStr); 411| 0| StringUtil::toLowerCase(tmpPattern); 412| 0| } 413| | 414| 383| String::const_iterator strIt = tmpStr.begin(); 415| 383| String::const_iterator patIt = tmpPattern.begin(); 416| 383| String::const_iterator lastWildCardIt = tmpPattern.end(); 417| 8.20k| while (strIt != tmpStr.end() && patIt != tmpPattern.end()) ------------------ | Branch (417:16): [True: 7.84k, False: 359] | Branch (417:16): [True: 7.84k, False: 361] | Branch (417:41): [True: 7.84k, False: 2] ------------------ 418| 7.84k| { 419| 7.84k| if (*patIt == '*') ------------------ | Branch (419:17): [True: 362, False: 7.47k] ------------------ 420| 362| { 421| 362| lastWildCardIt = patIt; 422| | // Skip over looking for next character 423| 362| ++patIt; 424| 362| if (patIt == tmpPattern.end()) ------------------ | Branch (424:21): [True: 29, False: 333] ------------------ 425| 29| { 426| | // Skip right to the end since * matches the entire rest of the string 427| 29| strIt = tmpStr.end(); 428| 29| } 429| 333| else 430| 333| { 431| | // scan until we find next pattern character 432| 1.81k| while(strIt != tmpStr.end() && *strIt != *patIt) ------------------ | Branch (432:27): [True: 1.75k, False: 64] | Branch (432:27): [True: 1.48k, False: 333] | Branch (432:52): [True: 1.48k, False: 269] ------------------ 433| 1.48k| ++strIt; 434| 333| } 435| 362| } 436| 7.47k| else 437| 7.47k| { 438| 7.47k| if (*patIt != *strIt) ------------------ | Branch (438:21): [True: 86, False: 7.39k] ------------------ 439| 86| { 440| 86| if (lastWildCardIt != tmpPattern.end()) ------------------ | Branch (440:25): [True: 64, False: 22] ------------------ 441| 64| { 442| | // The last wildcard can match this incorrect sequence 443| | // rewind pattern to wildcard and keep searching 444| 64| patIt = lastWildCardIt; 445| 64| lastWildCardIt = tmpPattern.end(); 446| 64| } 447| 22| else 448| 22| { 449| | // no wildwards left 450| 22| return false; 451| 22| } 452| 86| } 453| 7.39k| else 454| 7.39k| { 455| 7.39k| ++patIt; 456| 7.39k| ++strIt; 457| 7.39k| } 458| 7.47k| } 459| | 460| 7.84k| } 461| | // If we reached the end of both the pattern and the string, we succeeded 462| 361| if ((patIt == tmpPattern.end() || (*patIt == '*' && patIt + 1 == tmpPattern.end())) && strIt == tmpStr.end()) ------------------ | Branch (462:13): [True: 240, False: 121] | Branch (462:14): [True: 233, False: 128] | Branch (462:44): [True: 10, False: 118] | Branch (462:61): [True: 9, False: 1] | Branch (462:96): [True: 240, False: 2] ------------------ 463| 240| { 464| 240| return true; 465| 240| } 466| 121| else 467| 121| { 468| 121| return false; 469| 121| } 470| | 471| 361| } _ZN4Ogre10StringUtil6formatEPKcz: 488| 1.36M| { 489| | // try to use a stack buffer and fall back to heap for large strings 490| 1.36M| char sbuf[1024]; 491| 1.36M| size_t bsize = sizeof(sbuf); 492| 1.36M| std::vector hbuf; 493| 1.36M| char* pbuf = sbuf; 494| | 495| 1.36M| while (true) ------------------ | Branch (495:16): [True: 1.36M, Folded] ------------------ 496| 1.36M| { 497| 1.36M| va_list va; 498| 1.36M| va_start(va, fmt); 499| 1.36M| int len = vsnprintf(pbuf, bsize, fmt, va); 500| 1.36M| va_end(va); 501| | 502| 1.36M| OgreAssert(len >= 0, "Check format string for errors"); ------------------ | Branch (502:13): [True: 0, False: 1.36M] ------------------ 503| 1.36M| if (size_t(len) >= bsize) ------------------ | Branch (503:17): [True: 0, False: 1.36M] ------------------ 504| 0| { 505| 0| hbuf.resize(len + 1); 506| 0| pbuf = hbuf.data(); 507| 0| bsize = hbuf.size(); 508| 0| continue; 509| 0| } 510| 1.36M| pbuf[bsize - 1] = 0; 511| 1.36M| return String(pbuf, len); 512| 1.36M| } 513| 1.36M| } _ZN4Ogre15StringConverter8toStringERKNSt3__16vectorINS1_12basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS6_IS8_EEEE: 239| 7.27k| { 240| 7.27k| StringStream stream; 241| 7.27k| StringVector::const_iterator i, iend, ibegin; 242| 7.27k| ibegin = val.begin(); 243| 7.27k| iend = val.end(); 244| 19.7k| for (i = ibegin; i != iend; ++i) ------------------ | Branch (244:26): [True: 12.5k, False: 7.27k] ------------------ 245| 12.5k| { 246| 12.5k| if (i != ibegin) ------------------ | Branch (246:17): [True: 5.26k, False: 7.24k] ------------------ 247| 5.26k| stream << " "; 248| | 249| 12.5k| stream << *i; 250| 12.5k| } 251| 7.27k| return stream.str(); 252| 7.27k| } _ZN4Ogre15StringConverter5parseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERf: 263| 26.2k| { 264| 26.2k| char* end; 265| 26.2k| auto tmp = (float)strtod_l(val.c_str(), &end, _numLocale); 266| 26.2k| return assignValid(val.c_str() != end, tmp, ret); 267| 26.2k| } _ZN4Ogre15StringConverter5parseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERi: 276| 1.98k| { 277| 1.98k| char* end; 278| 1.98k| auto tmp = (int32)strtol_l(val.c_str(), &end, 0, _numLocale); 279| 1.98k| return assignValid(val.c_str() != end, tmp, ret); 280| 1.98k| } _ZN4Ogre15StringConverter5parseERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERj: 303| 13.6k| { 304| 13.6k| char* end; 305| 13.6k| auto tmp = (uint32)strtoul_l(val.c_str(), &end, 0, _numLocale); 306| 13.6k| return assignValid(val.c_str() != end, tmp, ret); 307| 13.6k| } OgreStringConverter.cpp:_ZN4OgreL11assignValidIfEEbbRKT_RS1_: 256| 26.2k| { 257| 26.2k| if (valid) ------------------ | Branch (257:13): [True: 25.1k, False: 1.09k] ------------------ 258| 25.1k| ret = val; 259| 26.2k| return valid; 260| 26.2k| } OgreStringConverter.cpp:_ZN4OgreL11assignValidIiEEbbRKT_RS1_: 256| 1.98k| { 257| 1.98k| if (valid) ------------------ | Branch (257:13): [True: 1.14k, False: 835] ------------------ 258| 1.14k| ret = val; 259| 1.98k| return valid; 260| 1.98k| } OgreStringConverter.cpp:_ZN4OgreL11assignValidIjEEbbRKT_RS1_: 256| 13.6k| { 257| 13.6k| if (valid) ------------------ | Branch (257:13): [True: 8.55k, False: 5.11k] ------------------ 258| 8.55k| ret = val; 259| 13.6k| return valid; 260| 13.6k| } _ZN4Ogre15ParamDictionaryC2Ev: 36| 4| ParamDictionary::ParamDictionary() {} _ZN4Ogre15ParamDictionaryD2Ev: 37| 8| ParamDictionary::~ParamDictionary() {} _ZN4Ogre15ParamDictionary15getParamCommandERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 40| 2.67k| { 41| 2.67k| ParamCommandMap::iterator i = mParamCommands.find(name); 42| 2.67k| if (i != mParamCommands.end()) ------------------ | Branch (42:13): [True: 2.65k, False: 16] ------------------ 43| 2.65k| { 44| 2.65k| return i->second; 45| 2.65k| } 46| 16| else 47| 16| { 48| 16| return 0; 49| 16| } 50| 2.67k| } _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| 708k| { 73| 708k| OGRE_LOCK_MUTEX( msDictionaryMutex ); 74| | 75| 708k| ParamDictionaryMap::iterator it = msDictionary.find(className); 76| | 77| 708k| if ( it == msDictionary.end() ) ------------------ | Branch (77:14): [True: 4, False: 708k] ------------------ 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| 708k| else 84| 708k| { 85| 708k| mParamDict = &it->second; 86| 708k| mParamDictName = className; 87| 708k| return false; 88| 708k| } 89| 708k| } _ZN4Ogre15StringInterface12setParameterERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 124| 4.28k| { 125| | // Get dictionary 126| 4.28k| ParamDictionary* dict = getParamDictionary(); 127| | 128| 4.28k| if (dict) ------------------ | Branch (128:13): [True: 2.67k, False: 1.61k] ------------------ 129| 2.67k| { 130| | // Look up command object 131| 2.67k| ParamCommand* cmd = dict->getParamCommand(name); 132| 2.67k| if (cmd) ------------------ | Branch (132:17): [True: 2.65k, False: 16] ------------------ 133| 2.65k| { 134| 2.65k| cmd->doSet(this, value); 135| 2.65k| return true; 136| 2.65k| } 137| 2.67k| } 138| | // Fallback 139| 1.62k| return false; 140| 4.28k| } _ZN4Ogre9TechniqueC2EPNS_8MaterialE: 35| 24.6k| : mParent(parent), mIlluminationPassesCompilationPhase(IPS_NOT_COMPILED), mIsSupported(false), mLodIndex(0), mSchemeIndex(0) 36| 24.6k| { 37| | // See above, defaults to unsupported until examined 38| 24.6k| } _ZN4Ogre9TechniqueD2Ev: 48| 24.6k| { 49| 24.6k| removeAllPasses(); 50| 24.6k| clearIlluminationPasses(); 51| 24.6k| } _ZNK4Ogre9Technique11isSupportedEv: 54| 12.9k| { 55| 12.9k| return mIsSupported; 56| 12.9k| } _ZN4Ogre9Technique10createPassEv: 310| 11.5k| { 311| | Pass* newPass = OGRE_NEW Pass(this, static_cast(mPasses.size())); 312| 11.5k| mPasses.push_back(newPass); 313| 11.5k| return newPass; 314| 11.5k| } _ZN4Ogre9Technique15removeAllPassesEv: 341| 37.6k| { 342| 37.6k| for (auto *p : mPasses) ------------------ | Branch (342:22): [True: 24.5k, False: 37.6k] ------------------ 343| 24.5k| { 344| 24.5k| p->queueForDeletion(); 345| 24.5k| } 346| 37.6k| mPasses.clear(); 347| 37.6k| } _ZN4Ogre9TechniqueaSERKS0_: 398| 12.9k| { 399| 12.9k| if (this == &rhs) ------------------ | Branch (399:13): [True: 0, False: 12.9k] ------------------ 400| 0| return *this; 401| | 402| 12.9k| mName = rhs.mName; 403| 12.9k| this->mIsSupported = rhs.mIsSupported; 404| 12.9k| this->mLodIndex = rhs.mLodIndex; 405| 12.9k| this->mSchemeIndex = rhs.mSchemeIndex; 406| 12.9k| this->mShadowCasterMaterial = rhs.mShadowCasterMaterial; 407| 12.9k| this->mShadowCasterMaterialName = rhs.mShadowCasterMaterialName; 408| 12.9k| this->mShadowReceiverMaterial = rhs.mShadowReceiverMaterial; 409| 12.9k| this->mShadowReceiverMaterialName = rhs.mShadowReceiverMaterialName; 410| 12.9k| this->mGPUVendorRules = rhs.mGPUVendorRules; 411| 12.9k| this->mGPUDeviceNameRules = rhs.mGPUDeviceNameRules; 412| | 413| | // copy passes 414| 12.9k| removeAllPasses(); 415| 12.9k| for (auto *rp : rhs.mPasses) ------------------ | Branch (415:23): [True: 12.9k, False: 12.9k] ------------------ 416| 12.9k| { 417| 12.9k| Pass* p = OGRE_NEW Pass(this, rp->getIndex(), *(rp)); 418| 12.9k| mPasses.push_back(p); 419| 12.9k| } 420| | // Compile for categorised illumination on demand 421| 12.9k| clearIlluminationPasses(); 422| 12.9k| mIlluminationPassesCompilationPhase = IPS_NOT_COMPILED; 423| 12.9k| return *this; 424| 12.9k| } _ZNK4Ogre9Technique8isLoadedEv: 576| 12.6k| { 577| | // Only supported technique will be loaded 578| 12.6k| return mParent->isLoaded() && mIsSupported; ------------------ | Branch (578:16): [True: 0, False: 12.6k] | Branch (578:39): [True: 0, False: 0] ------------------ 579| 12.6k| } _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| 1.84k| { 674| 1.84k| mName = name; 675| 1.84k| } _ZN4Ogre9Technique21_notifyNeedsRecompileEv: 680| 15.9k| { 681| | // Disable require to recompile when splitting illumination passes 682| 15.9k| if (mIlluminationPassesCompilationPhase != IPS_COMPILE_DISABLED) ------------------ | Branch (682:13): [True: 15.9k, False: 0] ------------------ 683| 15.9k| { 684| 15.9k| mParent->_notifyNeedsRecompile(); 685| 15.9k| } 686| 15.9k| } _ZN4Ogre9Technique13setSchemeNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 695| 189| { 696| 189| mSchemeIndex = MaterialManager::getSingleton()._getSchemeIndex(schemeName); 697| 189| _notifyNeedsRecompile(); 698| 189| } _ZN4Ogre9Technique23clearIlluminationPassesEv: 958| 37.6k| { 959| 37.6k| if(MaterialManager::getSingletonPtr()) ------------------ | Branch (959:12): [True: 37.6k, False: 0] ------------------ 960| 37.6k| MaterialManager::getSingleton()._notifyBeforeIlluminationPassesCleared(this); 961| | 962| 37.6k| for (auto *i : mIlluminationPasses) ------------------ | Branch (962:22): [True: 0, False: 37.6k] ------------------ 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| 37.6k| mIlluminationPasses.clear(); 971| 37.6k| } _ZNK4Ogre9Technique16getResourceGroupEv: 995| 1.36M| { 996| 1.36M| return mParent->getGroup(); 997| 1.36M| } _ZN4Ogre9Technique23setShadowCasterMaterialENS_9SharedPtrINS_8MaterialEEE: 1005| 148| { 1006| 148| if (!val) ------------------ | Branch (1006:13): [True: 44, False: 104] ------------------ 1007| 44| { 1008| 44| mShadowCasterMaterial.reset(); 1009| 44| mShadowCasterMaterialName.clear(); 1010| 44| } 1011| 104| else 1012| 104| { 1013| 104| if(val.get() == mParent) ------------------ | Branch (1013:16): [True: 0, False: 104] ------------------ 1014| 104| OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Using parent material is not allowed"); 1015| | 1016| | // shadow caster material should never receive shadows 1017| 104| val->setReceiveShadows(false); // should we warn if this is not set? 1018| 104| mShadowCasterMaterial = val; 1019| 104| mShadowCasterMaterialName = val->getName(); 1020| 104| } 1021| 148| } _ZN4Ogre9Technique23setShadowCasterMaterialERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 1024| 148| { 1025| 148| setShadowCasterMaterial(MaterialManager::getSingleton().getByName(name)); 1026| | // remember the name, even if it is not created yet 1027| 148| mShadowCasterMaterialName = name; 1028| 148| } _ZN4Ogre9Technique25setShadowReceiverMaterialENS_9SharedPtrINS_8MaterialEEE: 1036| 16| { 1037| 16| if (!val) ------------------ | Branch (1037:13): [True: 16, False: 0] ------------------ 1038| 16| { 1039| 16| mShadowReceiverMaterial.reset(); 1040| 16| mShadowReceiverMaterialName.clear(); 1041| 16| } 1042| 0| else 1043| 0| { 1044| 0| if(val.get() == mParent) ------------------ | Branch (1044:16): [True: 0, False: 0] ------------------ 1045| 0| OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Using parent material is not allowed"); 1046| | 1047| 0| mShadowReceiverMaterial = val; 1048| 0| mShadowReceiverMaterialName = val->getName(); 1049| 0| } 1050| 16| } _ZN4Ogre9Technique25setShadowReceiverMaterialERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 1053| 16| { 1054| 16| setShadowReceiverMaterial(MaterialManager::getSingleton().getByName(name)); 1055| 16| mShadowReceiverMaterialName = name; 1056| 16| } _ZN4Ogre9Technique20addGPUDeviceNameRuleERKNS0_17GPUDeviceNameRuleE: 1093| 1.92k| { 1094| | // remove duplicates 1095| 1.92k| removeGPUDeviceNameRule(rule.devicePattern); 1096| 1.92k| mGPUDeviceNameRules.push_back(rule); 1097| 1.92k| } _ZN4Ogre9Technique23removeGPUDeviceNameRuleERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 1100| 1.92k| { 1101| 14.6k| for (GPUDeviceNameRuleList::iterator i = mGPUDeviceNameRules.begin(); i != mGPUDeviceNameRules.end(); ) ------------------ | Branch (1101:79): [True: 12.7k, False: 1.92k] ------------------ 1102| 12.7k| { 1103| 12.7k| if (i->devicePattern == devicePattern) ------------------ | Branch (1103:17): [True: 1.26k, False: 11.4k] ------------------ 1104| 1.26k| i = mGPUDeviceNameRules.erase(i); 1105| 11.4k| else 1106| 11.4k| ++i; 1107| 12.7k| } 1108| 1.92k| } _ZN4Ogre7TextureC2EPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE: 40| 694k| : Resource(creator, name, handle, group, isManual, loader), 41| | // init defaults; can be overridden before load() 42| 694k| mHeight(512), 43| 694k| mWidth(512), 44| 694k| mDepth(1), 45| 694k| mNumRequestedMipmaps(0), 46| 694k| mNumMipmaps(0), 47| 694k| mGamma(1.0f), 48| 694k| mFSAA(0), 49| 694k| mFormat(PF_UNKNOWN), 50| 694k| mUsage(TU_DEFAULT), 51| 694k| mSrcFormat(PF_UNKNOWN), 52| 694k| mSrcWidth(0), 53| 694k| mSrcHeight(0), 54| 694k| mSrcDepth(0), 55| 694k| mTreatLuminanceAsAlpha(false), 56| 694k| mInternalResourcesCreated(false), 57| 694k| mMipmapsHardwareGenerated(false), 58| 694k| mHwGamma(false), 59| 694k| mTextureType(TEX_TYPE_2D), 60| 694k| mDesiredIntegerBitDepth(0), 61| 694k| mDesiredFloatBitDepth(0), 62| 694k| mDesiredFormat(PF_UNKNOWN) 63| 694k| { 64| 694k| if (createParamDictionary("Texture")) ------------------ | Branch (64:13): [True: 1, False: 694k] ------------------ 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| 694k| if (TextureManager::getSingletonPtr()) ------------------ | Branch (73:13): [True: 694k, False: 0] ------------------ 74| 694k| { 75| 694k| TextureManager& tmgr = TextureManager::getSingleton(); 76| 694k| setNumMipmaps(tmgr.getDefaultNumMipmaps()); 77| 694k| setDesiredBitDepths(tmgr.getPreferredIntegerBitDepth(), tmgr.getPreferredFloatBitDepth()); 78| 694k| } 79| | 80| | 81| 694k| } _ZN4Ogre7Texture9setFormatENS_11PixelFormatE: 118| 8.93k| { 119| 8.93k| mFormat = pf; 120| 8.93k| mDesiredFormat = pf; 121| 8.93k| } _ZN4Ogre7Texture19setDesiredBitDepthsEtt: 149| 694k| { 150| 694k| mDesiredIntegerBitDepth = integerBits; 151| 694k| mDesiredFloatBitDepth = floatBits; 152| 694k| } _ZN4Ogre7Texture24setTreatLuminanceAsAlphaEb: 155| 8.93k| { 156| 8.93k| mTreatLuminanceAsAlpha = asAlpha; 157| 8.93k| } _ZN4Ogre14TextureManager15getSingletonPtrEv: 35| 707k| { 36| 707k| return msSingleton; 37| 707k| } _ZN4Ogre14TextureManager12getSingletonEv: 39| 2.09M| { 40| | assert( msSingleton ); return ( *msSingleton ); 41| 2.09M| } _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| 4.63k| { 61| 4.63k| SamplerPtr ret = _createSamplerImpl(); 62| 4.63k| if(!name.empty()) ------------------ | Branch (62:12): [True: 206, False: 4.43k] ------------------ 63| 206| { 64| 206| if (mNamedSamplers.find(name) != mNamedSamplers.end()) ------------------ | Branch (64:17): [True: 66, False: 140] ------------------ 65| 206| OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "Sampler '" + name + "' already exists"); 66| 140| mNamedSamplers[name] = ret; 67| 140| } 68| 4.57k| return ret; 69| 4.63k| } _ZNK4Ogre14TextureManager10getSamplerERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 73| 439| { 74| 439| static SamplerPtr nullPtr; 75| 439| auto it = mNamedSamplers.find(name); 76| 439| if(it == mNamedSamplers.end()) ------------------ | Branch (76:12): [True: 64, False: 375] ------------------ 77| 64| return nullPtr; 78| 375| return it->second; 79| 439| } _ZNK4Ogre14TextureManager9getByNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 82| 8.93k| { 83| 8.93k| return static_pointer_cast(getResourceByName(name, groupName)); 84| 8.93k| } _ZNK4Ogre14TextureManager27getPreferredIntegerBitDepthEv: 245| 694k| { 246| 694k| return mPreferredIntegerBitDepth; 247| 694k| } _ZNK4Ogre14TextureManager25getPreferredFloatBitDepthEv: 275| 694k| { 276| 694k| return mPreferredFloatBitDepth; 277| 694k| } _ZN4Ogre14TextureManager17getDefaultSamplerEv: 361| 19.4k| { 362| 19.4k| if(!mDefaultSampler) ------------------ | Branch (362:12): [True: 1, False: 19.4k] ------------------ 363| 1| mDefaultSampler = createSampler(); 364| | 365| 19.4k| return mDefaultSampler; 366| 19.4k| } _ZN4Ogre7SamplerC2Ev: 40| 4.63k| : mBorderColour(ColourValue::Black) 41| 4.63k| , mMaxAniso(1) 42| 4.63k| , mMipmapBias(0) 43| 4.63k| , mMinFilter(FO_LINEAR) 44| 4.63k| , mMagFilter(FO_LINEAR) 45| 4.63k| , mMipFilter(FO_POINT) 46| 4.63k| , mCompareFunc(CMPF_GREATER_EQUAL) 47| 4.63k| , mCompareEnabled(false) 48| 4.63k| , mDirty(true) 49| 4.63k| { 50| 4.63k| setAddressingMode(TAM_WRAP); 51| 4.63k| } _ZN4Ogre7SamplerD2Ev: 52| 4.49k| Sampler::~Sampler() {} _ZN4Ogre7Sampler17setAddressingModeERKNS0_17UVWAddressingModeE: 55| 8.13k| { 56| 8.13k| mAddressMode = uvw; 57| 8.13k| mDirty = true; 58| 8.13k| } _ZN4Ogre7Sampler12setFilteringENS_20TextureFilterOptionsE: 62| 2.44k| { 63| 2.44k| switch (filterType) ------------------ | Branch (63:17): [True: 2.44k, False: 0] ------------------ 64| 2.44k| { 65| 2.26k| case TFO_NONE: ------------------ | Branch (65:9): [True: 2.26k, False: 179] ------------------ 66| 2.26k| setFiltering(FO_POINT, FO_POINT, FO_NONE); 67| 2.26k| break; 68| 13| case TFO_BILINEAR: ------------------ | Branch (68:9): [True: 13, False: 2.43k] ------------------ 69| 13| setFiltering(FO_LINEAR, FO_LINEAR, FO_POINT); 70| 13| break; 71| 163| case TFO_TRILINEAR: ------------------ | Branch (71:9): [True: 163, False: 2.28k] ------------------ 72| 163| setFiltering(FO_LINEAR, FO_LINEAR, FO_LINEAR); 73| 163| break; 74| 3| case TFO_ANISOTROPIC: ------------------ | Branch (74:9): [True: 3, False: 2.44k] ------------------ 75| 3| setFiltering(FO_ANISOTROPIC, FO_ANISOTROPIC, FO_LINEAR); 76| 3| break; 77| 2.44k| } 78| 2.44k| } _ZN4Ogre7Sampler12setFilteringENS_13FilterOptionsES1_S1_: 98| 2.72k| { 99| 2.72k| mMinFilter = minFilter; 100| 2.72k| mMagFilter = magFilter; 101| 2.72k| mMipFilter = mipFilter; 102| 2.72k| mDirty = true; 103| 2.72k| } _ZN4Ogre16TextureUnitStateC2EPNS_4PassE: 121| 12.7k| : mCurrentFrame(0) 122| 12.7k| , mAnimDuration(0) 123| 12.7k| , mUnorderedAccessMipLevel(-1) 124| 12.7k| , mGamma(1) 125| 12.7k| , mUMod(0) 126| 12.7k| , mVMod(0) 127| 12.7k| , mUScale(1) 128| 12.7k| , mVScale(1) 129| 12.7k| , mRotate(0) 130| 12.7k| , mTexModMatrix(Matrix4::IDENTITY) 131| 12.7k| , mContentType(CONTENT_NAMED) 132| 12.7k| , mTextureLoadFailed(false) 133| 12.7k| , mRecalcTexMatrix(false) 134| 12.7k| , mTextureCoordSetIndex(0) 135| 12.7k| , mFramePtrs(1) 136| 12.7k| , mSampler(TextureManager::getSingletonPtr() ? TextureManager::getSingleton().getDefaultSampler() : DUMMY_SAMPLER) ------------------ | Branch (136:20): [True: 12.7k, False: 0] ------------------ 137| 12.7k| , mParent(parent) 138| 12.7k| , mAnimController(0) 139| 12.7k| { 140| 12.7k| mColourBlendMode.blendType = LBT_COLOUR; 141| 12.7k| mAlphaBlendMode.operation = LBX_MODULATE; 142| 12.7k| mAlphaBlendMode.blendType = LBT_ALPHA; 143| 12.7k| mAlphaBlendMode.source1 = LBS_TEXTURE; 144| 12.7k| mAlphaBlendMode.source2 = LBS_CURRENT; 145| 12.7k| setColourOperation(LBO_MODULATE); 146| | 147| 12.7k| if( Pass::getHashFunction() == Pass::getBuiltinHashFunction( Pass::MIN_TEXTURE_CHANGE ) ) ------------------ | Branch (147:13): [True: 0, False: 12.7k] ------------------ 148| 0| { 149| 0| mParent->_dirtyHash(); 150| 0| } 151| | 152| 12.7k| } _ZN4Ogre16TextureUnitStateD2Ev: 171| 12.7k| { 172| | // Unload ensure all controllers destroyed 173| 12.7k| _unload(); 174| 12.7k| } _ZN4Ogre16TextureUnitState14setTextureNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEENS_11TextureTypeE: 232| 8.93k| { 233| 8.93k| TexturePtr tex = retrieveTexture(name); 234| | 235| 8.93k| if(!tex) ------------------ | Branch (235:12): [True: 0, False: 8.93k] ------------------ 236| 0| return; 237| | 238| 8.93k| tex->setTextureType(texType); 239| 8.93k| setTexture(tex); 240| 8.93k| } _ZN4Ogre16TextureUnitState10setTextureERKNS_9SharedPtrINS_7TextureEEE: 243| 8.95k| { 244| 8.95k| if (!texPtr) ------------------ | Branch (244:13): [True: 0, False: 8.95k] ------------------ 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| 8.95k| setContentType(CONTENT_NAMED); 252| 8.95k| mTextureLoadFailed = false; 253| | 254| 8.95k| if (texPtr->getTextureType() == TEX_TYPE_EXTERNAL_OES) ------------------ | Branch (254:13): [True: 0, False: 8.95k] ------------------ 255| 0| { 256| 0| setTextureAddressingMode( TAM_CLAMP ); 257| 0| setTextureFiltering(FT_MIP, FO_NONE); 258| 0| } 259| | 260| 8.95k| mFramePtrs.resize(1); 261| 8.95k| mFramePtrs[0] = texPtr; 262| | 263| 8.95k| mCurrentFrame = 0; 264| | 265| | // Load immediately ? 266| 8.95k| if (isLoaded()) ------------------ | Branch (266:13): [True: 0, False: 8.95k] ------------------ 267| 0| { 268| 0| _load(); // reload 269| 0| } 270| | // Tell parent to recalculate hash 271| 8.95k| if( Pass::getHashFunction() == Pass::getBuiltinHashFunction( Pass::MIN_TEXTURE_CHANGE ) ) ------------------ | Branch (271:13): [True: 0, False: 8.95k] ------------------ 272| 0| { 273| 0| mParent->_dirtyHash(); 274| 0| } 275| 8.95k| } _ZN4Ogre16TextureUnitState14setContentTypeENS0_11ContentTypeE: 278| 12.4k| { 279| 12.4k| mContentType = ct; 280| 12.4k| } _ZN4Ogre16TextureUnitState22setAnimatedTextureNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmf: 356| 534| { 357| 534| String baseName, ext; 358| 534| StringUtil::splitBaseFilename(name, baseName, ext); 359| | 360| 534| std::vector names(numFrames); 361| 1.35M| for (uint32 i = 0; i < names.size(); ++i) ------------------ | Branch (361:28): [True: 1.35M, False: 534] ------------------ 362| 1.35M| { 363| 1.35M| names[i] = StringUtil::format("%s_%u.%s", baseName.c_str(), i, ext.c_str()); 364| 1.35M| } 365| | 366| 534| setAnimatedTextureName(names, duration); 367| 534| } _ZN4Ogre16TextureUnitState22setAnimatedTextureNameEPKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmf: 370| 604| { 371| 604| OgreAssert(numFrames > 0, "numFrames must be greater than 0"); ------------------ | Branch (371:9): [True: 0, False: 604] ------------------ 372| 604| setContentType(CONTENT_NAMED); 373| 604| mTextureLoadFailed = false; 374| | 375| | // resize pointers, but don't populate until needed 376| 604| mFramePtrs.resize(numFrames); 377| 604| mAnimDuration = duration; 378| 604| mCurrentFrame = 0; 379| | 380| 1.35M| for (unsigned int i = 0; i < mFramePtrs.size(); ++i) ------------------ | Branch (380:34): [True: 1.35M, False: 604] ------------------ 381| 1.35M| { 382| 1.35M| mFramePtrs[i] = retrieveTexture(names[i]); 383| 1.35M| } 384| | 385| | // Load immediately if Material loaded 386| 604| if (isLoaded()) ------------------ | Branch (386:13): [True: 0, False: 604] ------------------ 387| 0| { 388| 0| _load(); 389| 0| } 390| | // Tell parent to recalculate hash 391| 604| if( Pass::getHashFunction() == Pass::getBuiltinHashFunction( Pass::MIN_TEXTURE_CHANGE ) ) ------------------ | Branch (391:13): [True: 0, False: 604] ------------------ 392| 0| { 393| 0| mParent->_dirtyHash(); 394| 0| } 395| 604| } _ZN4Ogre16TextureUnitState18setLayerArrayNamesENS_11TextureTypeERKNSt3__16vectorINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEE: 397| 17| { 398| 17| OgreAssert(!names.empty(), "array layers empty"); ------------------ | Branch (398:9): [True: 0, False: 17] ------------------ 399| | 400| 17| const char* typeName; 401| 17| switch(type) 402| 17| { 403| 17| case TEX_TYPE_CUBE_MAP: ------------------ | Branch (403:9): [True: 17, False: 0] ------------------ 404| 17| typeName = "Cube"; 405| 17| break; 406| 0| case TEX_TYPE_2D_ARRAY: ------------------ | Branch (406:9): [True: 0, False: 17] ------------------ 407| 0| typeName = "Array"; 408| 0| break; 409| 0| case TEX_TYPE_3D: ------------------ | Branch (409:9): [True: 0, False: 17] ------------------ 410| 0| typeName = "Volume"; 411| 0| break; 412| 0| default: ------------------ | Branch (412:9): [True: 0, False: 17] ------------------ 413| 0| OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS, "arrays not possible for this texture type"); 414| 0| return; 415| 17| } 416| | 417| | // use hash to auto-name the texture 418| 17| uint32 hash = 0; 419| 17| for(const String& name : names) ------------------ | Branch (419:32): [True: 102, False: 17] ------------------ 420| 102| hash = FastHash(name.data(), name.size(), hash); 421| | 422| 17| auto tex = retrieveTexture(StringUtil::format("%sTex_%x", typeName, hash)); 423| 17| tex->setTextureType(type); 424| 17| tex->setLayerNames(names); 425| 17| setTexture(tex); 426| 17| } _ZN4Ogre16TextureUnitState16setDesiredFormatENS_11PixelFormatE: 469| 8.93k| { 470| 8.93k| OgreAssert(mFramePtrs[0], "frame must not be blank"); ------------------ | Branch (470:9): [True: 0, False: 8.93k] ------------------ 471| 8.93k| for(auto& frame : mFramePtrs) ------------------ | Branch (471:25): [True: 8.93k, False: 8.93k] ------------------ 472| 8.93k| frame->setFormat(desiredFormat); 473| 8.93k| } _ZN4Ogre16TextureUnitState13setNumMipmapsEi: 481| 8.93k| { 482| 8.93k| OgreAssert(mFramePtrs[0], "frame must not be blank"); ------------------ | Branch (482:9): [True: 0, False: 8.93k] ------------------ 483| 8.93k| for (auto& frame : mFramePtrs) ------------------ | Branch (483:26): [True: 8.93k, False: 8.93k] ------------------ 484| 8.93k| frame->setNumMipmaps(numMipmaps == MIP_DEFAULT ------------------ | Branch (484:34): [True: 18, False: 8.91k] ------------------ 485| 8.93k| ? TextureManager::getSingleton().getDefaultNumMipmaps() 486| 8.93k| : numMipmaps); 487| 8.93k| } _ZN4Ogre16TextureUnitState10setIsAlphaEb: 495| 8.93k| { 496| 8.93k| OgreAssert(mFramePtrs[0], "frame must not be blank"); ------------------ | Branch (496:9): [True: 0, False: 8.93k] ------------------ 497| 8.93k| OGRE_IGNORE_DEPRECATED_BEGIN 498| 8.93k| for(auto& frame : mFramePtrs) ------------------ | Branch (498:25): [True: 8.93k, False: 8.93k] ------------------ 499| 8.93k| frame->setTreatLuminanceAsAlpha(isAlpha); 500| 8.93k| OGRE_IGNORE_DEPRECATED_END 501| 8.93k| } _ZN4Ogre16TextureUnitState23setHardwareGammaEnabledEb: 514| 8.93k| { 515| 8.93k| OgreAssert(mFramePtrs[0], "frame must not be blank"); ------------------ | Branch (515:9): [True: 0, False: 8.93k] ------------------ 516| 8.93k| for(auto& frame : mFramePtrs) ------------------ | Branch (516:25): [True: 8.93k, False: 8.93k] ------------------ 517| 8.93k| frame->setHardwareGammaEnabled(g); 518| 8.93k| } _ZN4Ogre16TextureUnitState18setTextureCoordSetEh: 531| 262| { 532| 262| mTextureCoordSetIndex = set; 533| 262| } _ZN4Ogre16TextureUnitState20setColourOperationExENS_21LayerBlendOperationExENS_16LayerBlendSourceES2_RKNS_11ColourValueES5_f: 541| 13.1k| { 542| 13.1k| mColourBlendMode.operation = op; 543| 13.1k| mColourBlendMode.source1 = source1; 544| 13.1k| mColourBlendMode.source2 = source2; 545| 13.1k| mColourBlendMode.colourArg1 = arg1; 546| 13.1k| mColourBlendMode.colourArg2 = arg2; 547| 13.1k| mColourBlendMode.factor = manualBlend; 548| 13.1k| } _ZN4Ogre16TextureUnitState18setColourOperationENS_19LayerBlendOperationE: 551| 12.7k| { 552| | // Set up the multitexture and multipass blending operations 553| 12.7k| switch (op) ------------------ | Branch (553:17): [True: 12.7k, False: 0] ------------------ 554| 12.7k| { 555| 7| case LBO_REPLACE: ------------------ | Branch (555:9): [True: 7, False: 12.7k] ------------------ 556| 7| setColourOperationEx(LBX_SOURCE1, LBS_TEXTURE, LBS_CURRENT); 557| 7| setColourOpMultipassFallback(SBF_ONE, SBF_ZERO); 558| 7| break; 559| 2| case LBO_ADD: ------------------ | Branch (559:9): [True: 2, False: 12.7k] ------------------ 560| 2| setColourOperationEx(LBX_ADD, LBS_TEXTURE, LBS_CURRENT); 561| 2| setColourOpMultipassFallback(SBF_ONE, SBF_ONE); 562| 2| break; 563| 12.7k| case LBO_MODULATE: ------------------ | Branch (563:9): [True: 12.7k, False: 9] ------------------ 564| 12.7k| setColourOperationEx(LBX_MODULATE, LBS_TEXTURE, LBS_CURRENT); 565| 12.7k| setColourOpMultipassFallback(SBF_DEST_COLOUR, SBF_ZERO); 566| 12.7k| break; 567| 0| case LBO_ALPHA_BLEND: ------------------ | Branch (567:9): [True: 0, False: 12.7k] ------------------ 568| 0| setColourOperationEx(LBX_BLEND_TEXTURE_ALPHA, LBS_TEXTURE, LBS_CURRENT); 569| 0| setColourOpMultipassFallback(SBF_SOURCE_ALPHA, SBF_ONE_MINUS_SOURCE_ALPHA); 570| 0| break; 571| 12.7k| } 572| | 573| | 574| 12.7k| } _ZN4Ogre16TextureUnitState28setColourOpMultipassFallbackENS_16SceneBlendFactorES1_: 577| 12.9k| { 578| 12.9k| mColourBlendFallbackSrc = sourceFactor; 579| 12.9k| mColourBlendFallbackDest = destFactor; 580| 12.9k| } _ZN4Ogre16TextureUnitState17setAlphaOperationENS_21LayerBlendOperationExENS_16LayerBlendSourceES2_fff: 588| 28| { 589| 28| mAlphaBlendMode.operation = op; 590| 28| mAlphaBlendMode.source1 = source1; 591| 28| mAlphaBlendMode.source2 = source2; 592| 28| mAlphaBlendMode.alphaArg1 = arg1; 593| 28| mAlphaBlendMode.alphaArg2 = arg2; 594| 28| mAlphaBlendMode.factor = manualBlend; 595| 28| } _ZN4Ogre16TextureUnitState9addEffectENS0_13TextureEffectE: 598| 3.09k| { 599| | // Ensure controller pointer is null 600| 3.09k| effect.controller = 0; 601| | 602| 3.09k| if (effect.type != ET_TRANSFORM) ------------------ | Branch (602:13): [True: 2.48k, False: 605] ------------------ 603| 2.48k| { 604| | // Replace - must be unique 605| | // Search for existing effect of this type 606| 2.48k| EffectMap::iterator i = mEffects.find(effect.type); 607| 2.48k| if (i != mEffects.end()) ------------------ | Branch (607:17): [True: 64, False: 2.42k] ------------------ 608| 64| { 609| | // Destroy old effect controller if exist 610| 64| if (i->second.controller) ------------------ | Branch (610:21): [True: 0, False: 64] ------------------ 611| 0| { 612| 0| ControllerManager::getSingleton().destroyController(i->second.controller); 613| 0| } 614| | 615| 64| mEffects.erase(i); 616| 64| } 617| 2.48k| } 618| | 619| 3.09k| if (isLoaded()) ------------------ | Branch (619:13): [True: 0, False: 3.09k] ------------------ 620| 0| { 621| | // Create controller 622| 0| createEffectController(effect); 623| 0| } 624| | 625| | // Record new effect 626| 3.09k| mEffects.emplace(effect.type, effect); 627| | 628| 3.09k| } _ZN4Ogre16TextureUnitState17setEnvironmentMapEbi: 674| 936| { 675| 936| if (enable) ------------------ | Branch (675:13): [True: 935, False: 1] ------------------ 676| 935| { 677| 935| TextureEffect eff = {ET_ENVIRONMENT_MAP}; 678| 935| eff.subtype = envMapType; 679| 935| addEffect(eff); 680| 935| } 681| 1| else 682| 1| { 683| 1| removeEffect(ET_ENVIRONMENT_MAP); 684| 1| } 685| 936| } _ZN4Ogre16TextureUnitState12removeEffectENS0_17TextureEffectTypeE: 688| 3.54k| { 689| | // Get range of items matching this effect 690| 3.54k| std::pair< EffectMap::iterator, EffectMap::iterator > remPair = 691| 3.54k| mEffects.equal_range( type ); 692| | // Remove controllers 693| 3.61k| for (EffectMap::iterator i = remPair.first; i != remPair.second; ++i) ------------------ | Branch (693:53): [True: 70, False: 3.54k] ------------------ 694| 70| { 695| 70| if (i->second.controller) ------------------ | Branch (695:17): [True: 0, False: 70] ------------------ 696| 0| { 697| 0| ControllerManager::getSingleton().destroyController(i->second.controller); 698| 0| } 699| 70| } 700| | // Erase 701| 3.54k| mEffects.erase( remPair.first, remPair.second ); 702| 3.54k| } _ZN4Ogre16TextureUnitState16setTextureScrollEff: 717| 221| { 718| 221| mUMod = u; 719| 221| mVMod = v; 720| 221| mRecalcTexMatrix = true; 721| 221| } _ZN4Ogre16TextureUnitState15setTextureScaleEff: 724| 364| { 725| 364| mUScale = uScale; 726| 364| mVScale = vScale; 727| 364| mRecalcTexMatrix = true; 728| 364| } _ZN4Ogre16TextureUnitState16setTextureRotateERKNS_6RadianE: 731| 2| { 732| 2| mRotate = angle; 733| 2| mRecalcTexMatrix = true; 734| 2| } _ZN4Ogre16TextureUnitState18setScrollAnimationEff: 814| 1.07k| { 815| | // Remove existing effects 816| 1.07k| removeEffect(ET_UVSCROLL); 817| 1.07k| removeEffect(ET_USCROLL); 818| 1.07k| removeEffect(ET_VSCROLL); 819| | 820| | // don't create an effect if the speeds are both 0 821| 1.07k| if (uSpeed == 0.0f && vSpeed == 0.0f) ------------------ | Branch (821:13): [True: 223, False: 855] | Branch (821:31): [True: 15, False: 208] ------------------ 822| 15| { 823| 15| return; 824| 15| } 825| | 826| | // Create new effect 827| 1.06k| if (uSpeed == vSpeed) ------------------ | Branch (827:13): [True: 176, False: 887] ------------------ 828| 176| { 829| 176| addEffect({ET_UVSCROLL, uSpeed}); 830| 176| } 831| 887| else 832| 887| { 833| 887| if (uSpeed) ------------------ | Branch (833:17): [True: 679, False: 208] ------------------ 834| 679| { 835| 679| addEffect({ET_USCROLL, uSpeed}); 836| 679| } 837| 887| if (vSpeed) ------------------ | Branch (837:17): [True: 396, False: 491] ------------------ 838| 396| { 839| 396| addEffect({ET_VSCROLL, vSpeed}); 840| 396| } 841| 887| } 842| 1.06k| } _ZN4Ogre16TextureUnitState18setRotateAnimationEf: 845| 314| { 846| | // Remove existing effect 847| 314| removeEffect(ET_ROTATE); 848| | // don't create an effect if the speed is 0 849| 314| if(speed == 0.0f) ------------------ | Branch (849:12): [True: 13, False: 301] ------------------ 850| 13| { 851| 13| return; 852| 13| } 853| | // Create new effect 854| 301| addEffect({ET_ROTATE, speed}); 855| 301| } _ZN4Ogre16TextureUnitState21setTransformAnimationENS0_20TextureTransformTypeENS_12WaveformTypeEffff: 859| 624| { 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| 897| for (EffectMap::iterator i = mEffects.begin(); i != mEffects.end(); ++i) ------------------ | Branch (864:56): [True: 276, False: 621] ------------------ 865| 276| { 866| 276| if (i->second.type == ET_TRANSFORM && i->second.subtype == ttype) ------------------ | Branch (866:17): [True: 157, False: 119] | Branch (866:51): [True: 3, False: 154] ------------------ 867| 3| { 868| 3| if (i->second.controller) ------------------ | Branch (868:21): [True: 0, False: 3] ------------------ 869| 0| { 870| 0| ControllerManager::getSingleton().destroyController(i->second.controller); 871| 0| } 872| 3| mEffects.erase(i); 873| | 874| | // should only be one, so jump out 875| 3| break; 876| 3| } 877| 276| } 878| | 879| | // don't create an effect if the given values are all 0 880| 624| if(base == 0.0f && phase == 0.0f && frequency == 0.0f && amplitude == 0.0f) ------------------ | Branch (880:12): [True: 252, False: 372] | Branch (880:28): [True: 242, False: 10] | Branch (880:45): [True: 22, False: 220] | Branch (880:66): [True: 19, False: 3] ------------------ 881| 19| { 882| 19| return; 883| 19| } 884| | // Create new effect 885| 605| TextureEffect eff = {ET_TRANSFORM}; 886| 605| eff.subtype = ttype; 887| 605| eff.waveType = waveType; 888| 605| eff.base = base; 889| 605| eff.frequency = frequency; 890| 605| eff.phase = phase; 891| 605| eff.amplitude = amplitude; 892| 605| addEffect(eff); 893| 605| } _ZN4Ogre16TextureUnitState15retrieveTextureERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 961| 1.35M| TexturePtr TextureUnitState::retrieveTexture(const String& name) { 962| 1.35M| TextureManager::ResourceCreateOrRetrieveResult res; 963| 1.35M| res = TextureManager::getSingleton().createOrRetrieve(name, mParent->getResourceGroup()); 964| 1.35M| return static_pointer_cast(res.first); 965| 1.35M| } _ZN4Ogre16TextureUnitState7_unloadEv: 1125| 12.7k| { 1126| | // Destroy animation controller 1127| 12.7k| if (mAnimController) ------------------ | Branch (1127:13): [True: 0, False: 12.7k] ------------------ 1128| 0| { 1129| 0| ControllerManager::getSingleton().destroyController(mAnimController); 1130| 0| mAnimController = 0; 1131| 0| } 1132| | 1133| | // Destroy effect controllers 1134| 12.7k| for (auto & e : mEffects) ------------------ | Branch (1134:23): [True: 2.95k, False: 12.7k] ------------------ 1135| 2.95k| { 1136| 2.95k| if (e.second.controller) ------------------ | Branch (1136:17): [True: 0, False: 2.95k] ------------------ 1137| 0| { 1138| 0| ControllerManager::getSingleton().destroyController(e.second.controller); 1139| 0| e.second.controller = 0; 1140| 0| } 1141| 2.95k| } 1142| | 1143| | // don't unload named textures. may be used elsewhere 1144| | // drop references on managed textures, however 1145| 12.7k| if(mContentType != CONTENT_NAMED) ------------------ | Branch (1145:12): [True: 1.17k, False: 11.5k] ------------------ 1146| 1.17k| mFramePtrs[0].reset(); 1147| 12.7k| } _ZNK4Ogre16TextureUnitState8isLoadedEv: 1150| 12.6k| { 1151| 12.6k| return mParent->isLoaded(); 1152| 12.6k| } _ZN4Ogre16TextureUnitState7setNameERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 1186| 15.5k| { 1187| 15.5k| mName = name; 1188| 15.5k| } _ZN4Ogre16TextureUnitState13_notifyParentEPNS_4PassE: 1191| 12.7k| { 1192| 12.7k| mParent = parent; 1193| 12.7k| } _ZN4Ogre16TextureUnitState22setCompositorReferenceERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_j: 1196| 794| { 1197| 794| mCompositorRefName = compositorName; 1198| 794| mCompositorRefTexName = textureName; 1199| 794| mCompositorRefMrtIndex = mrtIndex; 1200| 794| } _ZNK4Ogre16TextureUnitState18isDefaultFilteringEv: 1210| 6.72k| bool TextureUnitState::isDefaultFiltering() const { 1211| 6.72k| return mSampler == TextureManager::getSingleton().getDefaultSampler(); 1212| 6.72k| } _ZN4Ogre16TextureUnitState16_getLocalSamplerEv: 1215| 6.72k| { 1216| 6.72k| if(isDefaultFiltering()) ------------------ | Branch (1216:12): [True: 4.43k, False: 2.29k] ------------------ 1217| 4.43k| mSampler = TextureManager::getSingleton().createSampler(); 1218| | 1219| 6.72k| return mSampler; 1220| 6.72k| } _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| 807| :GpuProgram(creator, name, handle, group, isManual, loader) 51| 807| { 52| 807| if (createParamDictionary("UnifiedHighLevelGpuProgram")) ------------------ | Branch (52:13): [True: 1, False: 806] ------------------ 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| 807| } _ZN4Ogre26UnifiedHighLevelGpuProgramD2Ev: 66| 807| { 67| | 68| 807| } _ZNK4Ogre26UnifiedHighLevelGpuProgram14chooseDelegateEv: 71| 3.43k| { 72| 3.43k| OGRE_LOCK_AUTO_MUTEX; 73| | 74| 3.43k| mChosenDelegate.reset(); 75| | 76| 3.43k| for (const String& dn : mDelegateNames) ------------------ | Branch (76:31): [True: 9.66k, False: 3.43k] ------------------ 77| 9.66k| { 78| 9.66k| GpuProgramPtr deleg = GpuProgramManager::getSingleton().getByName(dn, mGroup); 79| | 80| | //recheck with auto resource group 81| 9.66k| if (!deleg) ------------------ | Branch (81:17): [True: 4.62k, False: 5.04k] ------------------ 82| 4.62k| deleg = GpuProgramManager::getSingleton().getByName(dn, RGN_AUTODETECT); 83| | 84| | // Silently ignore missing links 85| 9.66k| if(!deleg) ------------------ | Branch (85:16): [True: 4.62k, False: 5.04k] ------------------ 86| 4.62k| continue; 87| | 88| 5.04k| if (deleg->getLanguage() == sLanguage) ------------------ | Branch (88:17): [True: 11, False: 5.03k] ------------------ 89| 11| { 90| 11| LogManager::getSingleton().logError("unified program '" + getName() + 91| 11| "' cannot delegate to another unified program '" + dn + "'"); 92| 11| continue; 93| 11| } 94| | 95| 5.03k| if (deleg->getType() != getType()) ------------------ | Branch (95:17): [True: 0, False: 5.03k] ------------------ 96| 0| { 97| 0| LogManager::getSingleton().logError("unified program '" + getName() + 98| 0| "' cannot delegate to program with different type '" + dn + "'"); 99| 0| continue; 100| 0| } 101| | 102| 5.03k| if(!deleg->isSupported() && !deleg->hasCompileError()) ------------------ | Branch (102:16): [True: 5.03k, False: 0] | Branch (102:41): [True: 5.03k, False: 0] ------------------ 103| 5.03k| continue; 104| | 105| 0| mChosenDelegate = deleg; 106| 0| break; 107| 5.03k| } 108| 3.43k| } _ZNK4Ogre26UnifiedHighLevelGpuProgram12_getDelegateEv: 111| 3.43k| { 112| 3.43k| if (!mChosenDelegate) ------------------ | Branch (112:13): [True: 3.43k, False: 0] ------------------ 113| 3.43k| { 114| 3.43k| chooseDelegate(); 115| 3.43k| } 116| 3.43k| return mChosenDelegate; 117| 3.43k| } _ZN4Ogre26UnifiedHighLevelGpuProgram18addDelegateProgramERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 120| 2.65k| { 121| 2.65k| OGRE_LOCK_AUTO_MUTEX; 122| | 123| 2.65k| mDelegateNames.push_back(name); 124| | 125| | // reset chosen delegate 126| 2.65k| mChosenDelegate.reset(); 127| | 128| 2.65k| } _ZNK4Ogre26UnifiedHighLevelGpuProgram11getLanguageEv: 153| 11| { 154| 11| return sLanguage; 155| 11| } _ZN4Ogre26UnifiedHighLevelGpuProgram16createParametersEv: 158| 316| { 159| 316| if (isSupported()) ------------------ | Branch (159:13): [True: 0, False: 316] ------------------ 160| 0| { 161| 0| return _getDelegate()->createParameters(); 162| 0| } 163| 316| else 164| 316| { 165| | // return a default set 166| 316| GpuProgramParametersSharedPtr params = GpuProgramManager::getSingleton().createParameters(); 167| | // avoid any errors on parameter names that don't exist 168| 316| params->setIgnoreMissingParams(true); 169| 316| return params; 170| 316| } 171| 316| } _ZNK4Ogre26UnifiedHighLevelGpuProgram11isSupportedEv: 182| 2.02k| { 183| | // Supported if one of the delegates is 184| 2.02k| return _getDelegate() && _getDelegate()->isSupported(); ------------------ | Branch (184:16): [True: 0, False: 2.02k] | Branch (184:34): [True: 0, False: 0] ------------------ 185| 2.02k| } _ZN4Ogre26UnifiedHighLevelGpuProgram6unloadEv: 308| 780| { 309| 780| if (_getDelegate()) ------------------ | Branch (309:13): [True: 0, False: 780] ------------------ 310| 0| _getDelegate()->unload(); 311| 780| } _ZN4Ogre26UnifiedHighLevelGpuProgram11addListenerEPNS_8Resource8ListenerE: 372| 316| { 373| 316| if (_getDelegate()) ------------------ | Branch (373:13): [True: 0, False: 316] ------------------ 374| 0| _getDelegate()->addListener(lis); 375| 316| } _ZN4Ogre26UnifiedHighLevelGpuProgram14removeListenerEPNS_8Resource8ListenerE: 378| 316| { 379| 316| if (_getDelegate()) ------------------ | Branch (379:13): [True: 0, False: 316] ------------------ 380| 0| _getDelegate()->removeListener(lis); 381| 316| } _ZN4Ogre11CmdDelegate5doSetEPvRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 412| 2.65k| { 413| 2.65k| static_cast(target)->addDelegateProgram(val); 414| 2.65k| } _ZN4Ogre33UnifiedHighLevelGpuProgramFactoryC2Ev: 418| 1| { 419| 1| } _ZNK4Ogre33UnifiedHighLevelGpuProgramFactory11getLanguageEv: 426| 1| { 427| 1| return sLanguage; 428| 1| } _ZN4Ogre33UnifiedHighLevelGpuProgramFactory6createEPNS_15ResourceManagerERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEmSB_bPNS_20ManualResourceLoaderE: 433| 807| { 434| | return OGRE_NEW UnifiedHighLevelGpuProgram(creator, name, handle, group, isManual, loader); 435| 807| } _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: 331| 2| { 332| 2| static String name = "Zip"; 333| 2| return name; 334| 2| } _ZN4Ogre25EmbeddedZipArchiveFactoryC2Ev: 358| 1| EmbeddedZipArchiveFactory::EmbeddedZipArchiveFactory() {} _ZNK4Ogre25EmbeddedZipArchiveFactory7getTypeEv: 378| 2| { 379| 2| static String name = "EmbeddedZip"; 380| 2| return name; 381| 2| } LLVMFuzzerTestOneInput: 98| 7.21k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { 99| 7.21k| if (size == 0 || size > FUZZ_MAX_INPUT) ------------------ | Branch (99:7): [True: 0, False: 7.21k] | Branch (99:20): [True: 7, False: 7.20k] ------------------ 100| 7| return 0; 101| | 102| 7.20k| global_init(); 103| | 104| 7.20k| Ogre::DataStreamPtr stream(new Ogre::MemoryDataStream("fuzz.os", const_cast(data), size, false, true)); 105| | 106| 7.20k| try 107| 7.20k| { 108| 7.20k| Ogre::ScriptCompilerManager::getSingleton().parseScript(stream, FUZZ_GROUP); 109| 7.20k| } 110| 7.20k| catch (std::exception&) 111| 7.20k| { 112| 816| } 113| | 114| 7.20k| purge_state(); 115| 7.20k| return 0; 116| 7.20k|} script_fuzz.cpp:_ZL11global_initv: 63| 7.20k|static void global_init() { 64| 7.20k| if (g_initialized) ------------------ | Branch (64:7): [True: 7.20k, False: 1] ------------------ 65| 7.20k| 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| 21.2k| { 57| 21.2k| return std::make_shared(); 58| 21.2k| } _ZN18FuzzScriptListener11handleErrorEPN4Ogre14ScriptCompilerEjRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEiSB_: 53| 124k| void handleError(Ogre::ScriptCompiler*, Ogre::uint32, const Ogre::String&, int, const Ogre::String&) override {} script_fuzz.cpp:_ZL11purge_statev: 85| 7.20k|static void purge_state() { 86| 7.20k| auto &rgm = Ogre::ResourceGroupManager::getSingleton(); 87| 7.20k| rgm.destroyResourceGroup(FUZZ_GROUP); 88| 7.20k| 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| 7.20k| Ogre::ParticleSystemManager::getSingleton().removeAllTemplates(); 93| | 94| | // clean the pass graveyard 95| 7.20k| Ogre::Pass::processPendingPassUpdates(); 96| 7.20k|}