_ZN6Assimp19Discreet3DSImporterC2Ev: 104| 297| mStream(nullptr), mLastNodeIndex(), mCurrentNode(), mRootNode(), mScene(), mMasterScale(), bHasBG(), bIsPrj() { 105| | // empty 106| 297|} _ZNK6Assimp19Discreet3DSImporter7GetInfoEv: 117| 297|const aiImporterDesc *Discreet3DSImporter::GetInfo() const { 118| 297| return &desc; 119| 297|} _ZN6Assimp19Discreet3DSImporterD2Ev: 65| 297| ~Discreet3DSImporter() override = default; _ZNK6Assimp12D3MFImporter7GetInfoEv: 101| 297|const aiImporterDesc *D3MFImporter::GetInfo() const { 102| 297| return &desc; 103| 297|} _ZN6Assimp12D3MFImporterC2Ev: 59| 297| D3MFImporter() = default; _ZN6Assimp12AC3DImporterC2Ev: 161| 297| mBuffer(), 162| | configSplitBFCull(), 163| | configEvalSubdivision(), 164| | mNumMeshes(), 165| | mLights(), 166| 297| mLightsCounter(0), 167| 297| mGroupsCounter(0), 168| 297| mPolysCounter(0), 169| 297| mWorldsCounter(0) { 170| | // nothing to be done here 171| 297|} _ZNK6Assimp12AC3DImporter7GetInfoEv: 182| 297|const aiImporterDesc *AC3DImporter::GetInfo() const { 183| 297| return &desc; 184| 297|} _ZN6Assimp11AMFImporter5ClearEv: 69| 297|void AMFImporter::Clear() { 70| 297| mNodeElement_Cur = nullptr; 71| 297| mUnit.clear(); 72| 297| mMaterial_Converted.clear(); 73| 297| mTexture_Converted.clear(); 74| | // Delete all elements 75| 297| if (!mNodeElement_List.empty()) { ------------------ | Branch (75:9): [True: 0, False: 297] ------------------ 76| 0| for (AMFNodeElementBase *ne : mNodeElement_List) { ------------------ | Branch (76:37): [True: 0, False: 0] ------------------ 77| 0| delete ne; 78| 0| } 79| | 80| 0| mNodeElement_List.clear(); 81| 0| } 82| 297|} _ZN6Assimp11AMFImporterC2Ev: 85| 297| mNodeElement_Cur(nullptr), 86| 297| mXmlParser(nullptr) { 87| | // empty 88| 297|} _ZN6Assimp11AMFImporterD2Ev: 90| 297|AMFImporter::~AMFImporter() { 91| 297| delete mXmlParser; 92| | // Clear() is accounting if data already is deleted. So, just check again if all data is deleted. 93| 297| Clear(); 94| 297|} _ZNK6Assimp11AMFImporter7GetInfoEv: 487| 297|const aiImporterDesc *AMFImporter::GetInfo() const { 488| 297| return &Description; 489| 297|} _ZN6Assimp11ASEImporterC2Ev: 85| 297| mParser(), mBuffer(), pcScene(), configRecomputeNormals(), noSkeletonMesh() { 86| | // empty 87| 297|} _ZNK6Assimp11ASEImporter7GetInfoEv: 98| 297|const aiImporterDesc *ASEImporter::GetInfo() const { 99| 297| return &desc; 100| 297|} _ZNK6Assimp14AssbinImporter7GetInfoEv: 82| 297|const aiImporterDesc *AssbinImporter::GetInfo() const { 83| 297| return &desc; 84| 297|} _ZN6Assimp11B3DImporterD2Ev: 91| 297|B3DImporter::~B3DImporter() = default; _ZNK6Assimp11B3DImporter7GetInfoEv: 110| 297|const aiImporterDesc *B3DImporter::GetInfo() const { 111| 297| return &desc; 112| 297|} _ZN6Assimp11B3DImporterC2Ev: 66| 297| B3DImporter() = default; _ZN6Assimp9BVHLoaderC2Ev: 86| 297| noSkeletonMesh() { 87| | // empty 88| 297|} _ZNK6Assimp9BVHLoader7GetInfoEv: 104| 297|const aiImporterDesc *BVHLoader::GetInfo() const { 105| 297| return &desc; 106| 297|} _ZN6Assimp9BVHLoaderD2Ev: 88| 297| ~BVHLoader() override = default; _ZN6Assimp7Blender25CustomDataTypeDescriptionC2EPFbPNS0_8ElemBaseEmRKNS0_12FileDatabaseEEPFS3_mEPFvS3_E: 77| 84| Read(read), Create(create), Destroy(destroy) {} _ZN6Assimp7Blender9TempArrayINSt3__16vectorENS0_15BlenderModifierEEC2Ev: 67| 297| TempArray() = default; _ZN6Assimp7Blender9TempArrayINSt3__16vectorENS0_15BlenderModifierEED2Ev: 69| 297| ~TempArray () { 70| 297| for(T* elem : arr) { ------------------ | Branch (70:25): [True: 0, False: 297] ------------------ 71| 0| delete elem; 72| 0| } 73| 297| } _ZN6Assimp15BlenderImporterC2Ev: 101| 297| modifier_cache(new BlenderModifierShowcase()) { 102| | // empty 103| 297|} _ZN6Assimp15BlenderImporterD2Ev: 107| 297|BlenderImporter::~BlenderImporter() { 108| 297| delete modifier_cache; 109| 297|} _ZNK6Assimp15BlenderImporter7GetInfoEv: 121| 297|const aiImporterDesc *BlenderImporter::GetInfo() const { 122| 297| return &blenderDesc; 123| 297|} _ZNK6Assimp11COBImporter7GetInfoEv: 102| 297|const aiImporterDesc *COBImporter::GetInfo() const { 103| 297| return &desc; 104| 297|} _ZN6Assimp11COBImporterC2Ev: 77| 297| COBImporter() = default; _ZN6Assimp11CSMImporterC2Ev: 76| 297|CSMImporter::CSMImporter() : noSkeletonMesh() { 77| | // empty 78| 297|} _ZNK6Assimp11CSMImporter7GetInfoEv: 89| 297|const aiImporterDesc* CSMImporter::GetInfo () const { 90| 297| return &desc; 91| 297|} _ZN6Assimp13ColladaLoaderC2Ev: 103| 297| noSkeletonMesh(false), 104| 297| removeEmptyBones(false), 105| 297| ignoreUpDirection(false), 106| 297| ignoreUnitSize(false), 107| 297| useColladaName(false), 108| 297| mNodeNameCounter(0) { 109| | // empty 110| 297|} _ZNK6Assimp13ColladaLoader7GetInfoEv: 136| 297|const aiImporterDesc *ColladaLoader::GetInfo() const { 137| 297| return &desc; 138| 297|} _ZN6Assimp13ColladaLoaderD2Ev: 91| 297| ~ColladaLoader() override = default; _ZNK6Assimp11DXFImporter7GetInfoEv: 363| 297|const aiImporterDesc* DXFImporter::GetInfo () const { 364| 297| return &desc; 365| 297|} _ZN6Assimp11DXFImporterC2Ev: 71| 297| DXFImporter() = default; _ZN6Assimp3FBX14AnimationCurveC2EmRKNS0_7ElementERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERKNS0_8DocumentE: 61| 28.0k| Object(id, element, name) { 62| 28.0k| const Scope &sc = GetRequiredScope(element); 63| 28.0k| const Element &KeyTime = GetRequiredElement(sc, "KeyTime"); 64| 28.0k| const Element &KeyValueFloat = GetRequiredElement(sc, "KeyValueFloat"); 65| | 66| 28.0k| ParseVectorDataArray(keys, KeyTime); 67| 28.0k| ParseVectorDataArray(values, KeyValueFloat); 68| | 69| 28.0k| if (keys.size() != values.size()) { ------------------ | Branch (69:9): [True: 0, False: 28.0k] ------------------ 70| 0| DOMError("the number of key times does not match the number of keyframe values", &KeyTime); 71| 0| } 72| | 73| | // check if the key times are well-ordered 74| 28.0k| if (!std::equal(keys.begin(), keys.end() - 1, keys.begin() + 1, std::less())) { ------------------ | Branch (74:9): [True: 114, False: 27.9k] ------------------ 75| 114| DOMError("the keyframes are not in ascending order", &KeyTime); 76| 114| } 77| | 78| 27.9k| const Element *KeyAttrDataFloat = sc["KeyAttrDataFloat"]; 79| 27.9k| if (KeyAttrDataFloat) { ------------------ | Branch (79:9): [True: 27.6k, False: 327] ------------------ 80| 27.6k| ParseVectorDataArray(attributes, *KeyAttrDataFloat); 81| 27.6k| } 82| | 83| 27.9k| const Element *KeyAttrFlags = sc["KeyAttrFlags"]; 84| 27.9k| if (KeyAttrFlags) { ------------------ | Branch (84:9): [True: 27.6k, False: 316] ------------------ 85| 27.6k| ParseVectorDataArray(flags, *KeyAttrFlags); 86| 27.6k| } 87| 27.9k|} _ZN6Assimp3FBX18AnimationCurveNodeC2EmRKNS0_7ElementERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERKNS0_8DocumentEPKPKcm: 93| 10.8k| Object(id, element, name), target(), doc(doc) { 94| 10.8k| const Scope &sc = GetRequiredScope(element); 95| | 96| | // find target node 97| 10.8k| const char *whitelist[] = { "Model", "NodeAttribute", "Deformer" }; 98| 10.8k| const std::vector &conns = doc.GetConnectionsBySourceSequenced(ID(), whitelist, 3); 99| | 100| 10.8k| for (const Connection *con : conns) { ------------------ | Branch (100:32): [True: 10.4k, False: 382] ------------------ 101| | 102| | // link should go for a property 103| 10.4k| if (!con->PropertyName().length()) { ------------------ | Branch (103:13): [True: 8, False: 10.4k] ------------------ 104| 8| continue; 105| 8| } 106| | 107| 10.4k| if (target_prop_whitelist) { ------------------ | Branch (107:13): [True: 0, False: 10.4k] ------------------ 108| 0| const char *const s = con->PropertyName().c_str(); 109| 0| bool ok = false; 110| 0| for (size_t i = 0; i < whitelist_size; ++i) { ------------------ | Branch (110:32): [True: 0, False: 0] ------------------ 111| 0| if (!strcmp(s, target_prop_whitelist[i])) { ------------------ | Branch (111:21): [True: 0, False: 0] ------------------ 112| 0| ok = true; 113| 0| break; 114| 0| } 115| 0| } 116| | 117| 0| if (!ok) { ------------------ | Branch (117:17): [True: 0, False: 0] ------------------ 118| 0| throw std::range_error("AnimationCurveNode target property is not in whitelist"); 119| 0| } 120| 0| } 121| | 122| 10.4k| const Object *const ob = con->DestinationObject(); 123| 10.4k| if (!ob) { ------------------ | Branch (123:13): [True: 6, False: 10.4k] ------------------ 124| 6| DOMWarning("failed to read destination object for AnimationCurveNode->Model link, ignoring", &element); 125| 6| continue; 126| 6| } 127| | 128| 10.4k| target = ob; 129| 10.4k| if (!target) { ------------------ | Branch (129:13): [True: 0, False: 10.4k] ------------------ 130| 0| continue; 131| 0| } 132| | 133| 10.4k| prop = con->PropertyName(); 134| 10.4k| break; 135| 10.4k| } 136| | 137| 10.8k| if (!target) { ------------------ | Branch (137:9): [True: 382, False: 10.4k] ------------------ 138| 382| DOMWarning("failed to resolve target Model/NodeAttribute/Constraint for AnimationCurveNode", &element); 139| 382| } 140| | 141| 10.8k| props = GetPropertyTable(doc, "AnimationCurveNode.FbxAnimCurveNode", element, sc, false); 142| 10.8k|} _ZNK6Assimp3FBX18AnimationCurveNode6CurvesEv: 145| 28.3k|const AnimationCurveMap &AnimationCurveNode::Curves() const { 146| 28.3k| if (!curves.empty()) { ------------------ | Branch (146:9): [True: 18.7k, False: 9.53k] ------------------ 147| 18.7k| return curves; 148| 18.7k| } 149| | 150| | // resolve attached animation curves 151| 9.53k| const std::vector &conns = doc.GetConnectionsByDestinationSequenced(ID(), "AnimationCurve"); 152| | 153| 28.0k| for (const Connection *con : conns) { ------------------ | Branch (153:32): [True: 28.0k, False: 9.53k] ------------------ 154| | 155| | // link should go for a property 156| 28.0k| if (!con->PropertyName().length()) { ------------------ | Branch (156:13): [True: 19, False: 28.0k] ------------------ 157| 19| continue; 158| 19| } 159| | 160| 28.0k| const Object *const ob = con->SourceObject(); 161| 28.0k| if (nullptr == ob) { ------------------ | Branch (161:13): [True: 366, False: 27.6k] ------------------ 162| 366| DOMWarning("failed to read source object for AnimationCurve->AnimationCurveNode link, ignoring", &element); 163| 366| continue; 164| 366| } 165| | 166| 27.6k| const AnimationCurve *const anim = dynamic_cast(ob); 167| 27.6k| if (nullptr == anim) { ------------------ | Branch (167:13): [True: 0, False: 27.6k] ------------------ 168| 0| DOMWarning("source object for ->AnimationCurveNode link is not an AnimationCurve", &element); 169| 0| continue; 170| 0| } 171| | 172| 27.6k| curves[con->PropertyName()] = anim; 173| 27.6k| } 174| | 175| 9.53k| return curves; 176| 28.3k|} _ZN6Assimp3FBX14AnimationLayerC2EmRKNS0_7ElementERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERKNS0_8DocumentE: 180| 250| Object(id, element, name), doc(doc) { 181| 250| const Scope &sc = GetRequiredScope(element); 182| | 183| | // note: the props table here bears little importance and is usually absent 184| 250| props = GetPropertyTable(doc, "AnimationLayer.FbxAnimLayer", element, sc, true); 185| 250|} _ZNK6Assimp3FBX14AnimationLayer5NodesEPKPKcm: 189| 250| size_t whitelist_size /*= 0*/) const { 190| 250| AnimationCurveNodeList nodes; 191| | 192| | // resolve attached animation nodes 193| 250| const std::vector &conns = doc.GetConnectionsByDestinationSequenced(ID(), "AnimationCurveNode"); 194| 250| nodes.reserve(conns.size()); 195| | 196| 10.8k| for (const Connection *con : conns) { ------------------ | Branch (196:32): [True: 10.8k, False: 250] ------------------ 197| | 198| | // link should not go to a property 199| 10.8k| if (con->PropertyName().length()) { ------------------ | Branch (199:13): [True: 0, False: 10.8k] ------------------ 200| 0| continue; 201| 0| } 202| | 203| 10.8k| const Object *const ob = con->SourceObject(); 204| 10.8k| if (!ob) { ------------------ | Branch (204:13): [True: 3, False: 10.8k] ------------------ 205| 3| DOMWarning("failed to read source object for AnimationCurveNode->AnimationLayer link, ignoring", &element); 206| 3| continue; 207| 3| } 208| | 209| 10.8k| const AnimationCurveNode *const anim = dynamic_cast(ob); 210| 10.8k| if (!anim) { ------------------ | Branch (210:13): [True: 0, False: 10.8k] ------------------ 211| 0| DOMWarning("source object for ->AnimationLayer link is not an AnimationCurveNode", &element); 212| 0| continue; 213| 0| } 214| | 215| 10.8k| if (target_prop_whitelist) { ------------------ | Branch (215:13): [True: 10.8k, False: 5] ------------------ 216| 10.8k| const char *s = anim->TargetProperty().c_str(); 217| 10.8k| bool ok = false; 218| 23.7k| for (size_t i = 0; i < whitelist_size; ++i) { ------------------ | Branch (218:32): [True: 23.0k, False: 667] ------------------ 219| 23.0k| if (!strcmp(s, target_prop_whitelist[i])) { ------------------ | Branch (219:21): [True: 10.1k, False: 12.8k] ------------------ 220| 10.1k| ok = true; 221| 10.1k| break; 222| 10.1k| } 223| 23.0k| } 224| 10.8k| if (!ok) { ------------------ | Branch (224:17): [True: 667, False: 10.1k] ------------------ 225| 667| continue; 226| 667| } 227| 10.8k| } 228| 10.1k| nodes.push_back(anim); 229| 10.1k| } 230| | 231| 250| return nodes; // pray for NRVO 232| 250|} _ZN6Assimp3FBX14AnimationStackC2EmRKNS0_7ElementERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERKNS0_8DocumentE: 236| 256| Object(id, element, name) { 237| 256| const Scope &sc = GetRequiredScope(element); 238| | 239| | // note: we don't currently use any of these properties so we shouldn't bother if it is missing 240| 256| props = GetPropertyTable(doc, "AnimationStack.FbxAnimStack", element, sc, true); 241| | 242| | // resolve attached animation layers 243| 256| const std::vector &conns = doc.GetConnectionsByDestinationSequenced(ID(), "AnimationLayer"); 244| 256| layers.reserve(conns.size()); 245| | 246| 256| for (const Connection *con : conns) { ------------------ | Branch (246:32): [True: 250, False: 256] ------------------ 247| | 248| | // link should not go to a property 249| 250| if (con->PropertyName().length()) { ------------------ | Branch (249:13): [True: 0, False: 250] ------------------ 250| 0| continue; 251| 0| } 252| | 253| 250| const Object *const ob = con->SourceObject(); 254| 250| if (!ob) { ------------------ | Branch (254:13): [True: 0, False: 250] ------------------ 255| 0| DOMWarning("failed to read source object for AnimationLayer->AnimationStack link, ignoring", &element); 256| 0| continue; 257| 0| } 258| | 259| 250| const AnimationLayer *const anim = dynamic_cast(ob); 260| 250| if (!anim) { ------------------ | Branch (260:13): [True: 0, False: 250] ------------------ 261| 0| DOMWarning("source object for ->AnimationStack link is not an AnimationLayer", &element); 262| 0| continue; 263| 0| } 264| 250| layers.push_back(anim); 265| 250| } 266| 256|} _ZN6Assimp3FBX5TokenC2EPKcS3_NS0_9TokenTypeEm: 67| 3.24M| sbegin(sbegin), 68| 3.24M| send(send), 69| 3.24M| type(type), 70| 3.24M| line(offset), 71| 3.24M| column(BINARY_MARKER) { 72| 3.24M| ai_assert(sbegin); ------------------ | | 67| 3.24M|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 3.24M, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 73| 3.24M| ai_assert(send); ------------------ | | 67| 3.24M|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 3.24M, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 74| | 75| | // binary tokens may have zero length because they are sometimes dummies 76| | // inserted by TokenizeBinary() 77| 3.24M| ai_assert(send >= sbegin); ------------------ | | 67| 3.24M|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 3.24M, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 78| 3.24M|} _ZN6Assimp3FBX14TokenizeBinaryERNSt3__16vectorIPKNS0_5TokenENS1_9allocatorIS5_EEEEPKcmRNS_14StackAllocatorE: 394| 258|void TokenizeBinary(TokenList &output_tokens, const char *input, size_t length, StackAllocator &token_allocator) { 395| 258| ai_assert(input); ------------------ | | 67| 258|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 258, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 396| 258| ASSIMP_LOG_DEBUG("Tokenizing binary FBX file"); 397| | 398| 258| if(length < 0x1b) { ------------------ | Branch (398:8): [True: 0, False: 258] ------------------ 399| 0| TokenizeError("file is too short",0); 400| 0| } 401| | 402| | //uint32_t offset = 0x15; 403| |/* const char* cursor = input + 0x15; 404| | 405| | const uint32_t flags = ReadWord(input, cursor, input + length); 406| | 407| | const uint8_t padding_0 = ReadByte(input, cursor, input + length); // unused 408| | const uint8_t padding_1 = ReadByte(input, cursor, input + length); // unused*/ 409| | 410| 258| if (strncmp(input,"Kaydara FBX Binary",18)) { ------------------ | Branch (410:9): [True: 0, False: 258] ------------------ 411| 0| TokenizeError("magic bytes not found",0); 412| 0| } 413| | 414| 258| const char* cursor = input + 18; 415| 258| /*Result ignored*/ ReadByte(input, cursor, input + length); 416| 258| /*Result ignored*/ ReadByte(input, cursor, input + length); 417| 258| /*Result ignored*/ ReadByte(input, cursor, input + length); 418| 258| /*Result ignored*/ ReadByte(input, cursor, input + length); 419| 258| /*Result ignored*/ ReadByte(input, cursor, input + length); 420| 258| const uint32_t version = ReadWord(input, cursor, input + length); 421| 258| ASSIMP_LOG_DEBUG("FBX version: ", version); 422| 258| const bool is64bits = version >= 7500; 423| 258| const char *end = input + length; 424| 258| try 425| 258| { 426| 3.04k| while (cursor < end ) { ------------------ | Branch (426:16): [True: 3.03k, False: 8] ------------------ 427| 3.03k| if (!ReadScope(output_tokens, token_allocator, input, cursor, input + length, is64bits)) { ------------------ | Branch (427:17): [True: 250, False: 2.78k] ------------------ 428| 250| break; 429| 250| } 430| 3.03k| } 431| 258| } 432| 258| catch (const DeadlyImportError& e) 433| 258| { 434| 8| if (!is64bits && (length > std::numeric_limits::max())) { ------------------ | Branch (434:13): [True: 7, False: 1] | Branch (434:26): [True: 0, False: 7] ------------------ 435| 0| throw DeadlyImportError("The FBX file is invalid. This may be because the content is too big for this older version (", ai_to_string(version), ") of the FBX format. (", e.what(), ")"); 436| 0| } 437| 8| throw; 438| 8| } 439| 258|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_113TokenizeErrorERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEm: 87| 8|{ 88| 8| throw DeadlyImportError("FBX-Tokenize", Util::GetOffsetText(offset), message); 89| 8|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_18ReadByteEPKcRS3_S3_: 140| 632k|uint8_t ReadByte(const char* input, const char*& cursor, const char* end) { 141| 632k| if(Offset(cursor, end) < sizeof( uint8_t ) ) { ------------------ | Branch (141:8): [True: 0, False: 632k] ------------------ 142| 0| TokenizeError("cannot ReadByte, out of bounds",input, cursor); 143| 0| } 144| | 145| 632k| uint8_t word;/* = *reinterpret_cast< const uint8_t* >( cursor )*/ 146| 632k| ::memcpy( &word, cursor, sizeof( uint8_t ) ); 147| 632k| ++cursor; 148| | 149| 632k| return word; 150| 632k|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_16OffsetEPKcS3_: 93| 15.5M|size_t Offset(const char* begin, const char* cursor) { 94| 15.5M| if (begin > cursor) { ------------------ | Branch (94:9): [True: 0, False: 15.5M] ------------------ 95| 0| return 0; 96| 0| } 97| | 98| 15.5M| return cursor - begin; 99| 15.5M|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_113TokenizeErrorERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKcSC_: 103| 8|void TokenizeError(const std::string& message, const char* begin, const char* cursor) { 104| 8| TokenizeError(message, Offset(begin, cursor)); 105| 8|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_18ReadWordEPKcRS3_S3_: 108| 3.28M|uint32_t ReadWord(const char* input, const char*& cursor, const char* end) { 109| 3.28M| const size_t k_to_read = sizeof( uint32_t ); 110| 3.28M| if(Offset(cursor, end) < k_to_read ) { ------------------ | Branch (110:8): [True: 0, False: 3.28M] ------------------ 111| 0| TokenizeError("cannot ReadWord, out of bounds",input, cursor); 112| 0| } 113| | 114| 3.28M| uint32_t word; 115| 3.28M| ::memcpy(&word, cursor, 4); 116| 3.28M| AI_SWAP4(word); 117| | 118| 3.28M| cursor += k_to_read; 119| | 120| 3.28M| return word; 121| 3.28M|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_19ReadScopeERNSt3__16vectorIPKNS0_5TokenENS2_9allocatorIS6_EEEERNS_14StackAllocatorEPKcRSE_SE_b: 305| 631k|bool ReadScope(TokenList &output_tokens, StackAllocator &token_allocator, const char *input, const char *&cursor, const char *end, bool const is64bits) { 306| | // the first word contains the offset at which this block ends 307| 631k| const uint64_t end_offset = is64bits ? ReadDoubleWord(input, cursor, end) : ReadWord(input, cursor, end); ------------------ | Branch (307:30): [True: 1, False: 631k] ------------------ 308| | 309| | // we may get 0 if reading reached the end of the file - 310| | // fbx files have a mysterious extra footer which I don't know 311| | // how to extract any information from, but at least it always 312| | // starts with a 0. 313| 631k| if(!end_offset) { ------------------ | Branch (313:8): [True: 250, False: 630k] ------------------ 314| 250| return false; 315| 250| } 316| | 317| 630k| if(end_offset > Offset(input, end)) { ------------------ | Branch (317:8): [True: 1, False: 630k] ------------------ 318| 1| TokenizeError("block offset is out of range",input, cursor); 319| 1| } 320| 630k| else if(end_offset < Offset(input, cursor)) { ------------------ | Branch (320:13): [True: 1, False: 630k] ------------------ 321| 1| TokenizeError("block offset is negative out of range",input, cursor); 322| 1| } 323| | 324| | // the second data word contains the number of properties in the scope 325| 630k| const uint64_t prop_count = is64bits ? ReadDoubleWord(input, cursor, end) : ReadWord(input, cursor, end); ------------------ | Branch (325:30): [True: 1, False: 630k] ------------------ 326| | 327| | // the third data word contains the length of the property list 328| 630k| const uint64_t prop_length = is64bits ? ReadDoubleWord(input, cursor, end) : ReadWord(input, cursor, end); ------------------ | Branch (328:31): [True: 1, False: 630k] ------------------ 329| | 330| | // now comes the name of the scope/key 331| 630k| const char* sbeg, *send; 332| 630k| ReadString(sbeg, send, input, cursor, end); 333| | 334| 630k| output_tokens.push_back(new_Token(sbeg, send, TokenType_KEY, Offset(input, cursor) )); ------------------ | | 160| 1.26M|#define new_Token new (token_allocator.Allocate(sizeof(Token))) Token ------------------ 335| | 336| | // now come the individual properties 337| 630k| const char* begin_cursor = cursor; 338| | 339| 630k| if ((begin_cursor + prop_length) > end) { ------------------ | Branch (339:9): [True: 0, False: 630k] ------------------ 340| 0| TokenizeError("property length out of bounds reading length ", input, cursor); 341| 0| } 342| | 343| 2.13M| for (unsigned int i = 0; i < prop_count; ++i) { ------------------ | Branch (343:30): [True: 1.50M, False: 630k] ------------------ 344| 1.50M| ReadData(sbeg, send, input, cursor, begin_cursor + prop_length); 345| | 346| 1.50M| output_tokens.push_back(new_Token(sbeg, send, TokenType_DATA, Offset(input, cursor) )); ------------------ | | 160| 3.01M|#define new_Token new (token_allocator.Allocate(sizeof(Token))) Token ------------------ 347| | 348| 1.50M| if(i != prop_count-1) { ------------------ | Branch (348:12): [True: 908k, False: 599k] ------------------ 349| 908k| output_tokens.push_back(new_Token(cursor, cursor + 1, TokenType_COMMA, Offset(input, cursor) )); ------------------ | | 160| 1.81M|#define new_Token new (token_allocator.Allocate(sizeof(Token))) Token ------------------ 350| 908k| } 351| 1.50M| } 352| | 353| 630k| if (Offset(begin_cursor, cursor) != prop_length) { ------------------ | Branch (353:9): [True: 0, False: 630k] ------------------ 354| 0| TokenizeError("property length not reached, something is wrong",input, cursor); 355| 0| } 356| | 357| | // at the end of each nested block, there is a NUL record to indicate 358| | // that the sub-scope exists (i.e. to distinguish between P: and P : {}) 359| | // this NUL record is 13 bytes long on 32 bit version and 25 bytes long on 64 bit. 360| 630k| const size_t sentinel_block_length = is64bits ? (sizeof(uint64_t)* 3 + 1) : (sizeof(uint32_t)* 3 + 1); ------------------ | Branch (360:39): [True: 0, False: 630k] ------------------ 361| | 362| 630k| if (Offset(input, cursor) < end_offset) { ------------------ | Branch (362:9): [True: 98.3k, False: 532k] ------------------ 363| 98.3k| if (end_offset - Offset(input, cursor) < sentinel_block_length) { ------------------ | Branch (363:13): [True: 0, False: 98.3k] ------------------ 364| 0| TokenizeError("insufficient padding bytes at block end",input, cursor); 365| 0| } 366| | 367| 98.3k| output_tokens.push_back(new_Token(cursor, cursor + 1, TokenType_OPEN_BRACKET, Offset(input, cursor) )); ------------------ | | 160| 196k|#define new_Token new (token_allocator.Allocate(sizeof(Token))) Token ------------------ 368| | 369| | // XXX this is vulnerable to stack overflowing .. 370| 726k| while(Offset(input, cursor) < end_offset - sentinel_block_length) { ------------------ | Branch (370:15): [True: 628k, False: 98.3k] ------------------ 371| 628k| ReadScope(output_tokens, token_allocator, input, cursor, input + end_offset - sentinel_block_length, is64bits); 372| 628k| } 373| 98.3k| output_tokens.push_back(new_Token(cursor, cursor + 1, TokenType_CLOSE_BRACKET, Offset(input, cursor) )); ------------------ | | 160| 196k|#define new_Token new (token_allocator.Allocate(sizeof(Token))) Token ------------------ 374| | 375| 1.37M| for (unsigned int i = 0; i < sentinel_block_length; ++i) { ------------------ | Branch (375:34): [True: 1.27M, False: 98.3k] ------------------ 376| 1.27M| if(cursor[i] != '\0') { ------------------ | Branch (376:16): [True: 0, False: 1.27M] ------------------ 377| 0| TokenizeError("failed to read nested block sentinel, expected all bytes to be 0",input, cursor); 378| 0| } 379| 1.27M| } 380| 98.3k| cursor += sentinel_block_length; 381| 98.3k| } 382| | 383| 630k| if (Offset(input, cursor) != end_offset) { ------------------ | Branch (383:9): [True: 0, False: 630k] ------------------ 384| 0| TokenizeError("scope length not reached, something is wrong",input, cursor); 385| 0| } 386| | 387| 630k| return true; 388| 630k|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_114ReadDoubleWordEPKcRS3_S3_: 124| 3|uint64_t ReadDoubleWord(const char* input, const char*& cursor, const char* end) { 125| 3| const size_t k_to_read = sizeof(uint64_t); 126| 3| if(Offset(cursor, end) < k_to_read) { ------------------ | Branch (126:8): [True: 0, False: 3] ------------------ 127| 0| TokenizeError("cannot ReadDoubleWord, out of bounds",input, cursor); 128| 0| } 129| | 130| 3| uint64_t dword /*= *reinterpret_cast(cursor)*/; 131| 3| ::memcpy( &dword, cursor, sizeof( uint64_t ) ); 132| 3| AI_SWAP8(dword); 133| | 134| 3| cursor += k_to_read; 135| | 136| 3| return dword; 137| 3|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_110ReadStringERPKcS4_S3_S4_S3_bb: 154| 1.44M| const char*& cursor, const char* end, bool long_length = false, bool allow_null = false) { 155| 1.44M| const uint32_t len_len = long_length ? 4 : 1; ------------------ | Branch (155:30): [True: 809k, False: 630k] ------------------ 156| 1.44M| if(Offset(cursor, end) < len_len) { ------------------ | Branch (156:8): [True: 0, False: 1.44M] ------------------ 157| 0| TokenizeError("cannot ReadString, out of bounds reading length",input, cursor); 158| 0| } 159| | 160| 1.44M| const uint32_t length = long_length ? ReadWord(input, cursor, end) : ReadByte(input, cursor, end); ------------------ | Branch (160:29): [True: 809k, False: 630k] ------------------ 161| | 162| 1.44M| if (Offset(cursor, end) < length) { ------------------ | Branch (162:9): [True: 0, False: 1.44M] ------------------ 163| 0| TokenizeError("cannot ReadString, length is out of bounds",input, cursor); 164| 0| } 165| | 166| 1.44M| sbegin_out = cursor; 167| 1.44M| cursor += length; 168| | 169| 1.44M| send_out = cursor; 170| | 171| 1.44M| if(!allow_null) { ------------------ | Branch (171:8): [True: 630k, False: 809k] ------------------ 172| 5.42M| for (unsigned int i = 0; i < length; ++i) { ------------------ | Branch (172:34): [True: 4.79M, False: 630k] ------------------ 173| 4.79M| if(sbegin_out[i] == '\0') { ------------------ | Branch (173:16): [True: 5, False: 4.79M] ------------------ 174| 5| TokenizeError("failed ReadString, unexpected NUL character in string",input, cursor); 175| 5| } 176| 4.79M| } 177| 630k| } 178| | 179| 1.44M| return length; 180| 1.44M|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_18ReadDataERPKcS4_S3_S4_S3_: 183| 1.50M|void ReadData(const char*& sbegin_out, const char*& send_out, const char* input, const char*& cursor, const char* end) { 184| 1.50M| if(Offset(cursor, end) < 1) { ------------------ | Branch (184:8): [True: 0, False: 1.50M] ------------------ 185| 0| TokenizeError("cannot ReadData, out of bounds reading length",input, cursor); 186| 0| } 187| | 188| 1.50M| const char type = *cursor; 189| 1.50M| sbegin_out = cursor++; 190| | 191| 1.50M| switch(type) 192| 1.50M| { 193| | // 16 bit int 194| 0| case 'Y': ------------------ | Branch (194:5): [True: 0, False: 1.50M] ------------------ 195| 0| cursor += 2; 196| 0| break; 197| | 198| | // 1 bit bool flag (yes/no) 199| 5.04k| case 'C': ------------------ | Branch (199:5): [True: 5.04k, False: 1.50M] ------------------ 200| 5.04k| cursor += 1; 201| 5.04k| break; 202| | 203| | // 32 bit int 204| 102k| case 'I': ------------------ | Branch (204:5): [True: 102k, False: 1.40M] ------------------ 205| | // <- fall through 206| | 207| | // float 208| 102k| case 'F': ------------------ | Branch (208:5): [True: 0, False: 1.50M] ------------------ 209| 102k| cursor += 4; 210| 102k| break; 211| | 212| | // double 213| 177k| case 'D': ------------------ | Branch (213:5): [True: 177k, False: 1.32M] ------------------ 214| 177k| cursor += 8; 215| 177k| break; 216| | 217| | // 64 bit int 218| 218k| case 'L': ------------------ | Branch (218:5): [True: 218k, False: 1.28M] ------------------ 219| 218k| cursor += 8; 220| 218k| break; 221| | 222| | // note: do not write cursor += ReadWord(...cursor) as this would be UB 223| | 224| | // raw binary data 225| 262| case 'R': ------------------ | Branch (225:5): [True: 262, False: 1.50M] ------------------ 226| 262| { 227| 262| const uint32_t length = ReadWord(input, cursor, end); 228| 262| cursor += length; 229| 262| break; 230| 102k| } 231| | 232| 36| case 'b': ------------------ | Branch (232:5): [True: 36, False: 1.50M] ------------------ 233| | // TODO: what is the 'b' type code? Right now we just skip over it / 234| | // take the full range we could get 235| 36| cursor = end; 236| 36| break; 237| | 238| | // array of * 239| 68.3k| case 'f': ------------------ | Branch (239:5): [True: 68.3k, False: 1.43M] ------------------ 240| 87.2k| case 'd': ------------------ | Branch (240:5): [True: 18.9k, False: 1.48M] ------------------ 241| 121k| case 'l': ------------------ | Branch (241:5): [True: 34.1k, False: 1.47M] ------------------ 242| 194k| case 'i': ------------------ | Branch (242:5): [True: 72.8k, False: 1.43M] ------------------ 243| 194k| case 'c': { ------------------ | Branch (243:5): [True: 1, False: 1.50M] ------------------ 244| 194k| const uint32_t length = ReadWord(input, cursor, end); 245| 194k| const uint32_t encoding = ReadWord(input, cursor, end); 246| | 247| 194k| const uint32_t comp_len = ReadWord(input, cursor, end); 248| | 249| | // compute length based on type and check against the stored value 250| 194k| if(encoding == 0) { ------------------ | Branch (250:12): [True: 185k, False: 8.57k] ------------------ 251| 185k| uint32_t stride = 0; 252| 185k| switch(type) 253| 185k| { 254| 68.3k| case 'f': ------------------ | Branch (254:13): [True: 68.3k, False: 117k] ------------------ 255| 136k| case 'i': ------------------ | Branch (255:13): [True: 68.5k, False: 117k] ------------------ 256| 136k| stride = 4; 257| 136k| break; 258| | 259| 14.6k| case 'd': ------------------ | Branch (259:13): [True: 14.6k, False: 171k] ------------------ 260| 48.7k| case 'l': ------------------ | Branch (260:13): [True: 34.1k, False: 151k] ------------------ 261| 48.7k| stride = 8; 262| 48.7k| break; 263| | 264| 0| case 'c': ------------------ | Branch (264:13): [True: 0, False: 185k] ------------------ 265| 0| stride = 1; 266| 0| break; 267| | 268| 0| default: ------------------ | Branch (268:13): [True: 0, False: 185k] ------------------ 269| 0| ai_assert(false); ------------------ | | 67| 0|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [Folded, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 270| 185k| }; 271| 185k| ai_assert(stride > 0); ------------------ | | 67| 185k|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 185k, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 272| 185k| if(length * stride != comp_len) { ------------------ | Branch (272:16): [True: 0, False: 185k] ------------------ 273| 0| TokenizeError("cannot ReadData, calculated data stride differs from what the file claims",input, cursor); 274| 0| } 275| 185k| } 276| | // zip/deflate algorithm (encoding==1)? take given length. anything else? die 277| 8.57k| else if (encoding != 1) { ------------------ | Branch (277:18): [True: 0, False: 8.57k] ------------------ 278| 0| TokenizeError("cannot ReadData, unknown encoding",input, cursor); 279| 0| } 280| 194k| cursor += comp_len; 281| 194k| break; 282| 194k| } 283| | 284| | // string 285| 809k| case 'S': { ------------------ | Branch (285:5): [True: 809k, False: 698k] ------------------ 286| 809k| const char* sb, *se; 287| | // 0 characters can legally happen in such strings 288| 809k| ReadString(sb, se, input, cursor, end, true, true); 289| 809k| break; 290| 194k| } 291| 1| default: ------------------ | Branch (291:5): [True: 1, False: 1.50M] ------------------ 292| 1| TokenizeError("cannot ReadData, unexpected type code: " + std::string(&type, 1),input, cursor); 293| 1.50M| } 294| | 295| 1.50M| if(cursor > end) { ------------------ | Branch (295:8): [True: 0, False: 1.50M] ------------------ 296| 0| TokenizeError("cannot ReadData, the remaining size is too small for the data type: " + std::string(&type, 1),input, cursor); 297| 0| } 298| | 299| | // the type code is contained in the returned range 300| 1.50M| send_out = cursor; 301| 1.50M|} _ZN6Assimp3FBX12FBXConverterC2EP7aiSceneRKNS0_8DocumentEb: 128| 271| mMeshes(), 129| 271| lights(), 130| 271| cameras(), 131| 271| textures(), 132| 271| materials_converted(), 133| 271| textures_converted(), 134| 271| meshes_converted(), 135| 271| node_anim_chain_bits(), 136| 271| mNodeNames(), 137| | anim_fps(), 138| 271| mSceneOut(out), 139| 271| doc(doc), 140| 271| mRemoveEmptyBones(removeEmptyBones) { 141| | 142| | 143| | // animations need to be converted first since this will 144| | // populate the node_anim_chain_bits map, which is needed 145| | // to determine which nodes need to be generated. 146| 271| ConvertAnimations(); 147| | // Embedded textures in FBX could be connected to nothing but to itself, 148| | // for instance Texture -> Video connection only but not to the main graph, 149| | // The idea here is to traverse all objects to find these Textures and convert them, 150| | // so later during material conversion it will find converted texture in the textures_converted array. 151| 271| if (doc.Settings().readTextures) { ------------------ | Branch (151:9): [True: 249, False: 22] ------------------ 152| 249| ConvertOrphanedEmbeddedTextures(); 153| 249| } 154| 271| ConvertRootNode(); 155| | 156| 271| if (doc.Settings().readAllMaterials) { ------------------ | Branch (156:9): [True: 0, False: 271] ------------------ 157| | // unfortunately this means we have to evaluate all objects 158| 0| for (const ObjectMap::value_type &v : doc.Objects()) { ------------------ | Branch (158:45): [True: 0, False: 0] ------------------ 159| | 160| 0| const Object *ob = v.second->Get(); 161| 0| if (!ob) { ------------------ | Branch (161:17): [True: 0, False: 0] ------------------ 162| 0| continue; 163| 0| } 164| | 165| 0| const Material *mat = dynamic_cast(ob); 166| 0| if (mat) { ------------------ | Branch (166:17): [True: 0, False: 0] ------------------ 167| | 168| 0| if (materials_converted.find(mat) == materials_converted.end()) { ------------------ | Branch (168:21): [True: 0, False: 0] ------------------ 169| 0| ConvertMaterial(*mat, nullptr); 170| 0| } 171| 0| } 172| 0| } 173| 0| } 174| | 175| 271| ConvertGlobalSettings(); 176| 271| TransferDataToScene(); 177| | 178| | // if we didn't read any meshes set the AI_SCENE_FLAGS_INCOMPLETE 179| | // to make sure the scene passes assimp's validation. FBX files 180| | // need not contain geometry (i.e. camera animations, raw armatures). 181| 271| if (out->mNumMeshes == 0) { ------------------ | Branch (181:9): [True: 135, False: 136] ------------------ 182| 135| out->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; 183| 136| } else { 184| | // Apply the FBX axis metadata unless requested not to 185| 136| if (!doc.Settings().ignoreUpDirection) ------------------ | Branch (185:13): [True: 92, False: 44] ------------------ 186| 92| correctRootTransform(mSceneOut); 187| 136| } 188| 271|} _ZN6Assimp3FBX12FBXConverterD2Ev: 190| 227|FBXConverter::~FBXConverter() { 191| 227| std::for_each(mMeshes.begin(), mMeshes.end(), Util::delete_fun()); 192| 227| std::for_each(materials.begin(), materials.end(), Util::delete_fun()); 193| 227| std::for_each(animations.begin(), animations.end(), Util::delete_fun()); 194| 227| std::for_each(lights.begin(), lights.end(), Util::delete_fun()); 195| 227| std::for_each(cameras.begin(), cameras.end(), Util::delete_fun()); 196| 227| std::for_each(textures.begin(), textures.end(), Util::delete_fun()); 197| 227|} _ZN6Assimp3FBX12FBXConverter15ConvertRootNodeEv: 199| 249|void FBXConverter::ConvertRootNode() { 200| 249| mSceneOut->mRootNode = new aiNode(); 201| 249| std::string unique_name; 202| 249| GetUniqueName("RootNode", unique_name); 203| 249| mSceneOut->mRootNode->mName.Set(unique_name); 204| | 205| | // root has ID 0 206| 249| ConvertNodes(0L, mSceneOut->mRootNode, mSceneOut->mRootNode); 207| 249|} _ZN6Assimp3FBX12FBXConverter12ConvertNodesEmP6aiNodeS3_RK12aiMatrix4x4tIfE: 250| 3.81k|void FBXConverter::ConvertNodes(uint64_t id, aiNode *parent, aiNode *root_node, const aiMatrix4x4& parent_transform) { 251| 3.81k| const std::vector &conns = doc.GetConnectionsByDestinationSequenced(id, "Model"); 252| | 253| 3.81k| std::vector nodes; 254| 3.81k| nodes.reserve(conns.size()); 255| | 256| 3.81k| std::vector nodes_chain; 257| 3.81k| std::vector post_nodes_chain; 258| | 259| 3.81k| for (const Connection *con : conns) { ------------------ | Branch (259:32): [True: 3.59k, False: 3.81k] ------------------ 260| | // ignore object-property links 261| 3.59k| if (con->PropertyName().length()) { ------------------ | Branch (261:13): [True: 0, False: 3.59k] ------------------ 262| | // really important we document why this is ignored. 263| 0| FBXImporter::LogInfo("ignoring property link - no docs on why this is ignored"); 264| 0| continue; //? 265| 0| } 266| | 267| | // convert connection source object into Object base class 268| 3.59k| const Object *const object = con->SourceObject(); 269| 3.59k| if (nullptr == object) { ------------------ | Branch (269:13): [True: 2, False: 3.58k] ------------------ 270| 2| FBXImporter::LogError("failed to convert source object for Model link"); 271| 2| continue; 272| 2| } 273| | 274| | // FBX Model::Cube, Model::Bone001, etc elements 275| | // This detects if we can cast the object into this model structure. 276| 3.58k| const Model *const model = dynamic_cast(object); 277| | 278| 3.58k| if (nullptr != model) { ------------------ | Branch (278:13): [True: 3.58k, False: 0] ------------------ 279| 3.58k| nodes_chain.clear(); 280| 3.58k| post_nodes_chain.clear(); 281| 3.58k| aiMatrix4x4 new_abs_transform = parent_transform; 282| 3.58k| std::string node_name = FixNodeName(model->Name()); 283| | // even though there is only a single input node, the design of 284| | // assimp (or rather: the complicated transformation chain that 285| | // is employed by fbx) means that we may need multiple aiNode's 286| | // to represent a fbx node's transformation. 287| | 288| | // generate node transforms - this includes pivot data 289| | // if need_additional_node is true then you t 290| 3.58k| const bool need_additional_node = GenerateTransformationNodeChain(*model, node_name, nodes_chain, post_nodes_chain); 291| | 292| | // assert that for the current node we must have at least a single transform 293| 3.58k| ai_assert(nodes_chain.size()); 294| | 295| 3.58k| if (need_additional_node) { ------------------ | Branch (295:17): [True: 356, False: 3.23k] ------------------ 296| 356| nodes_chain.emplace_back(node_name); 297| 356| } 298| | 299| | //setup metadata on newest node 300| 3.58k| SetupNodeMetadata(*model, *nodes_chain.back().mNode); 301| | 302| | // link all nodes in a row 303| 3.58k| aiNode *last_parent = parent; 304| 4.89k| for (PotentialNode& child : nodes_chain) { ------------------ | Branch (304:39): [True: 4.89k, False: 3.58k] ------------------ 305| 4.89k| ai_assert(child.mNode); 306| | 307| 4.89k| if (last_parent != parent) { ------------------ | Branch (307:21): [True: 1.32k, False: 3.56k] ------------------ 308| 1.32k| last_parent->mNumChildren = 1; 309| 1.32k| last_parent->mChildren = new aiNode *[1]; 310| 1.32k| last_parent->mChildren[0] = child.mOwnership.release(); 311| 1.32k| } 312| | 313| 4.89k| child->mParent = last_parent; 314| 4.89k| last_parent = child.mNode; 315| | 316| 4.89k| new_abs_transform *= child->mTransformation; 317| 4.89k| } 318| | 319| | // attach geometry 320| 3.58k| ConvertModel(*model, nodes_chain.back().mNode, root_node, new_abs_transform); 321| | 322| | // check if there will be any child nodes 323| 3.58k| const std::vector &child_conns = doc.GetConnectionsByDestinationSequenced(model->ID(), "Model"); 324| | 325| | // if so, link the geometric transform inverse nodes 326| | // before we attach any child nodes 327| 3.58k| if (child_conns.size()) { ------------------ | Branch (327:17): [True: 2.50k, False: 1.08k] ------------------ 328| 2.50k| for (PotentialNode& postnode : post_nodes_chain) { ------------------ | Branch (328:46): [True: 141, False: 2.50k] ------------------ 329| 141| ai_assert(postnode.mNode); 330| | 331| 141| if (last_parent != parent) { ------------------ | Branch (331:25): [True: 141, False: 0] ------------------ 332| 141| last_parent->mNumChildren = 1; 333| 141| last_parent->mChildren = new aiNode *[1]; 334| 141| last_parent->mChildren[0] = postnode.mOwnership.release(); 335| 141| } 336| | 337| 141| postnode->mParent = last_parent; 338| 141| last_parent = postnode.mNode; 339| | 340| 141| new_abs_transform *= postnode->mTransformation; 341| 141| } 342| 2.50k| } else { 343| | // free the nodes we allocated as we don't need them 344| 1.08k| post_nodes_chain.clear(); 345| 1.08k| } 346| | 347| | // recursion call - child nodes 348| 3.58k| ConvertNodes(model->ID(), last_parent, root_node, new_abs_transform); 349| | 350| 3.58k| if (doc.Settings().readLights) { ------------------ | Branch (350:17): [True: 3.55k, False: 32] ------------------ 351| 3.55k| ConvertLights(*model, node_name); 352| 3.55k| } 353| | 354| 3.58k| if (doc.Settings().readCameras) { ------------------ | Branch (354:17): [True: 3.55k, False: 32] ------------------ 355| 3.55k| ConvertCameras(*model, node_name); 356| 3.55k| } 357| | 358| 3.58k| nodes.push_back(std::move(nodes_chain.front())); 359| 3.58k| nodes_chain.clear(); 360| 3.58k| } 361| 3.58k| } 362| | 363| 3.81k| if (nodes.empty()) { ------------------ | Branch (363:9): [True: 1.06k, False: 2.75k] ------------------ 364| 1.06k| parent->mNumChildren = 0; 365| 1.06k| parent->mChildren = nullptr; 366| 2.75k| } else { 367| 2.75k| parent->mChildren = new aiNode *[nodes.size()](); 368| 2.75k| parent->mNumChildren = static_cast(nodes.size()); 369| 6.25k| for (unsigned int i = 0; i < nodes.size(); ++i) { ------------------ | Branch (369:34): [True: 3.50k, False: 2.75k] ------------------ 370| 3.50k| parent->mChildren[i] = nodes[i].mOwnership.release(); 371| 3.50k| } 372| 2.75k| } 373| 3.81k|} _ZN6Assimp3FBX12FBXConverter13ConvertLightsERKNS0_5ModelERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 375| 3.55k|void FBXConverter::ConvertLights(const Model &model, const std::string &orig_name) { 376| 3.55k| const std::vector &node_attrs = model.GetAttributes(); 377| 3.55k| for (const NodeAttribute *attr : node_attrs) { ------------------ | Branch (377:36): [True: 3.23k, False: 3.55k] ------------------ 378| 3.23k| const Light *const light = dynamic_cast(attr); 379| 3.23k| if (light) { ------------------ | Branch (379:13): [True: 215, False: 3.02k] ------------------ 380| 215| ConvertLight(*light, orig_name); 381| 215| } 382| 3.23k| } 383| 3.55k|} _ZN6Assimp3FBX12FBXConverter14ConvertCamerasERKNS0_5ModelERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 385| 3.55k|void FBXConverter::ConvertCameras(const Model &model, const std::string &orig_name) { 386| 3.55k| const std::vector &node_attrs = model.GetAttributes(); 387| 3.55k| for (const NodeAttribute *attr : node_attrs) { ------------------ | Branch (387:36): [True: 3.23k, False: 3.55k] ------------------ 388| 3.23k| const Camera *const cam = dynamic_cast(attr); 389| 3.23k| if (cam) { ------------------ | Branch (389:13): [True: 221, False: 3.01k] ------------------ 390| 221| ConvertCamera(*cam, orig_name); 391| 221| } 392| 3.23k| } 393| 3.55k|} _ZN6Assimp3FBX12FBXConverter12ConvertLightERKNS0_5LightERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 395| 215|void FBXConverter::ConvertLight(const Light &light, const std::string &orig_name) { 396| 215| lights.push_back(new aiLight()); 397| 215| aiLight *const out_light = lights.back(); 398| | 399| 215| out_light->mName.Set(orig_name); 400| | 401| 215| const float intensity = light.Intensity() / 100.0f; 402| 215| const aiVector3D &col = light.Color(); 403| | 404| 215| out_light->mColorDiffuse = aiColor3D(col.x, col.y, col.z); 405| 215| out_light->mColorDiffuse.r *= intensity; 406| 215| out_light->mColorDiffuse.g *= intensity; 407| 215| out_light->mColorDiffuse.b *= intensity; 408| | 409| 215| out_light->mColorSpecular = out_light->mColorDiffuse; 410| | 411| | //lights are defined along negative y direction 412| 215| out_light->mPosition = aiVector3D(0.0f); 413| 215| out_light->mDirection = aiVector3D(0.0f, -1.0f, 0.0f); 414| 215| out_light->mUp = aiVector3D(0.0f, 0.0f, -1.0f); 415| | 416| 215| switch (light.LightType()) { 417| 215| case Light::Type_Point: ------------------ | Branch (417:9): [True: 215, False: 0] ------------------ 418| 215| out_light->mType = aiLightSource_POINT; 419| 215| break; 420| | 421| 0| case Light::Type_Directional: ------------------ | Branch (421:9): [True: 0, False: 215] ------------------ 422| 0| out_light->mType = aiLightSource_DIRECTIONAL; 423| 0| break; 424| | 425| 0| case Light::Type_Spot: ------------------ | Branch (425:9): [True: 0, False: 215] ------------------ 426| 0| out_light->mType = aiLightSource_SPOT; 427| 0| out_light->mAngleOuterCone = AI_DEG_TO_RAD(light.OuterAngle()); 428| 0| out_light->mAngleInnerCone = AI_DEG_TO_RAD(light.InnerAngle()); 429| 0| break; 430| | 431| 0| case Light::Type_Area: ------------------ | Branch (431:9): [True: 0, False: 215] ------------------ 432| 0| FBXImporter::LogWarn("cannot represent area light, set to UNDEFINED"); 433| 0| out_light->mType = aiLightSource_UNDEFINED; 434| 0| break; 435| | 436| 0| case Light::Type_Volume: ------------------ | Branch (436:9): [True: 0, False: 215] ------------------ 437| 0| FBXImporter::LogWarn("cannot represent volume light, set to UNDEFINED"); 438| 0| out_light->mType = aiLightSource_UNDEFINED; 439| 0| break; 440| 0| default: ------------------ | Branch (440:9): [True: 0, False: 215] ------------------ 441| 0| FBXImporter::LogError("Not handled light type: ", light.LightType()); 442| 0| break; 443| 215| } 444| | 445| 215| float decay = light.DecayStart(); 446| 215| switch (light.DecayType()) { 447| 0| case Light::Decay_None: ------------------ | Branch (447:9): [True: 0, False: 215] ------------------ 448| 0| out_light->mAttenuationConstant = decay; 449| 0| out_light->mAttenuationLinear = 0.0f; 450| 0| out_light->mAttenuationQuadratic = 0.0f; 451| 0| break; 452| 0| case Light::Decay_Linear: ------------------ | Branch (452:9): [True: 0, False: 215] ------------------ 453| 0| out_light->mAttenuationConstant = 0.0f; 454| 0| out_light->mAttenuationLinear = 2.0f / decay; 455| 0| out_light->mAttenuationQuadratic = 0.0f; 456| 0| break; 457| 215| case Light::Decay_Quadratic: ------------------ | Branch (457:9): [True: 215, False: 0] ------------------ 458| 215| out_light->mAttenuationConstant = 0.0f; 459| 215| out_light->mAttenuationLinear = 0.0f; 460| 215| out_light->mAttenuationQuadratic = 2.0f / (decay * decay); 461| 215| break; 462| 0| case Light::Decay_Cubic: ------------------ | Branch (462:9): [True: 0, False: 215] ------------------ 463| 0| FBXImporter::LogWarn("cannot represent cubic attenuation, set to Quadratic"); 464| 0| out_light->mAttenuationQuadratic = 1.0f; 465| 0| break; 466| 0| default: ------------------ | Branch (466:9): [True: 0, False: 215] ------------------ 467| 0| FBXImporter::LogError("Not handled light decay type: ", light.DecayType()); 468| 0| break; 469| 215| } 470| 215|} _ZN6Assimp3FBX12FBXConverter13ConvertCameraERKNS0_6CameraERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 472| 221|void FBXConverter::ConvertCamera(const Camera &cam, const std::string &orig_name) { 473| 221| cameras.push_back(new aiCamera()); 474| 221| aiCamera *const out_camera = cameras.back(); 475| | 476| 221| out_camera->mName.Set(orig_name); 477| | 478| 221| out_camera->mAspect = cam.AspectWidth() / cam.AspectHeight(); 479| | 480| | // NOTE: Camera mPosition, mLookAt and mUp must be set to default here. 481| | // All transformations to the camera will be handled by its node in the scenegraph. 482| 221| out_camera->mPosition = aiVector3D(0.0f); 483| 221| out_camera->mLookAt = aiVector3D(1.0f, 0.0f, 0.0f); 484| 221| out_camera->mUp = aiVector3D(0.0f, 1.0f, 0.0f); 485| | 486| | // NOTE: Some software (maya) does not put FieldOfView in FBX, so we compute 487| | // mHorizontalFOV from FocalLength and FilmWidth with unit conversion. 488| | 489| | // TODO: This is not a complete solution for how FBX cameras can be stored. 490| | // TODO: Incorporate non-square pixel aspect ratio. 491| | // TODO: FBX aperture mode might be storing vertical FOV in need of conversion with aspect ratio. 492| | 493| 221| float fov_deg = cam.FieldOfView(); 494| | // If FOV not specified in file, compute using FilmWidth and FocalLength. 495| 221| if (fov_deg == kFovUnknown) { ------------------ | Branch (495:9): [True: 4, False: 217] ------------------ 496| 4| float film_width_inches = cam.FilmWidth(); 497| 4| float focal_length_mm = cam.FocalLength(); 498| 4| ASSIMP_LOG_VERBOSE_DEBUG("FBX FOV unspecified. Computing from FilmWidth (", film_width_inches, "inches) and FocalLength (", focal_length_mm, "mm)."); 499| 4| double half_fov_rad = std::atan2(film_width_inches * 25.4 * 0.5, focal_length_mm); 500| 4| out_camera->mHorizontalFOV = static_cast(half_fov_rad); 501| 217| } else { 502| | // FBX fov is full-view degrees. We want half-view radians. 503| 217| out_camera->mHorizontalFOV = AI_DEG_TO_RAD(fov_deg) * 0.5f; 504| 217| } 505| | 506| 221| out_camera->mClipPlaneNear = cam.NearPlane(); 507| 221| out_camera->mClipPlaneFar = cam.FarPlane(); 508| 221|} _ZN6Assimp3FBX12FBXConverter13GetUniqueNameERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS8_: 510| 249|void FBXConverter::GetUniqueName(const std::string &name, std::string &uniqueName) { 511| 249| uniqueName = name; 512| 249| auto it_pair = mNodeNames.insert({ name, 0 }); // duplicate node name instance count 513| 249| unsigned int &i = it_pair.first->second; 514| 249| while (!it_pair.second) { ------------------ | Branch (514:12): [True: 0, False: 249] ------------------ 515| 0| ++i; 516| 0| std::ostringstream ext; 517| 0| ext << name << std::setfill('0') << std::setw(3) << i; 518| 0| uniqueName = ext.str(); 519| 0| it_pair = mNodeNames.insert({ uniqueName, 0 }); 520| 0| } 521| 249|} _ZN6Assimp3FBX12FBXConverter22NameTransformationCompENS1_18TransformationCompE: 523| 2.99k|const char *FBXConverter::NameTransformationComp(TransformationComp comp) { 524| 2.99k| switch (comp) { 525| 832| case TransformationComp_Translation: ------------------ | Branch (525:9): [True: 832, False: 2.16k] ------------------ 526| 832| return "Translation"; 527| 0| case TransformationComp_RotationOffset: ------------------ | Branch (527:9): [True: 0, False: 2.99k] ------------------ 528| 0| return "RotationOffset"; 529| 35| case TransformationComp_RotationPivot: ------------------ | Branch (529:9): [True: 35, False: 2.96k] ------------------ 530| 35| return "RotationPivot"; 531| 57| case TransformationComp_PreRotation: ------------------ | Branch (531:9): [True: 57, False: 2.94k] ------------------ 532| 57| return "PreRotation"; 533| 802| case TransformationComp_Rotation: ------------------ | Branch (533:9): [True: 802, False: 2.19k] ------------------ 534| 802| return "Rotation"; 535| 0| case TransformationComp_PostRotation: ------------------ | Branch (535:9): [True: 0, False: 2.99k] ------------------ 536| 0| return "PostRotation"; 537| 35| case TransformationComp_RotationPivotInverse: ------------------ | Branch (537:9): [True: 35, False: 2.96k] ------------------ 538| 35| return "RotationPivotInverse"; 539| 0| case TransformationComp_ScalingOffset: ------------------ | Branch (539:9): [True: 0, False: 2.99k] ------------------ 540| 0| return "ScalingOffset"; 541| 0| case TransformationComp_ScalingPivot: ------------------ | Branch (541:9): [True: 0, False: 2.99k] ------------------ 542| 0| return "ScalingPivot"; 543| 749| case TransformationComp_Scaling: ------------------ | Branch (543:9): [True: 749, False: 2.24k] ------------------ 544| 749| return "Scaling"; 545| 0| case TransformationComp_ScalingPivotInverse: ------------------ | Branch (545:9): [True: 0, False: 2.99k] ------------------ 546| 0| return "ScalingPivotInverse"; 547| 264| case TransformationComp_GeometricScaling: ------------------ | Branch (547:9): [True: 264, False: 2.73k] ------------------ 548| 264| return "GeometricScaling"; 549| 0| case TransformationComp_GeometricRotation: ------------------ | Branch (549:9): [True: 0, False: 2.99k] ------------------ 550| 0| return "GeometricRotation"; 551| 0| case TransformationComp_GeometricTranslation: ------------------ | Branch (551:9): [True: 0, False: 2.99k] ------------------ 552| 0| return "GeometricTranslation"; 553| 224| case TransformationComp_GeometricScalingInverse: ------------------ | Branch (553:9): [True: 224, False: 2.77k] ------------------ 554| 224| return "GeometricScalingInverse"; 555| 0| case TransformationComp_GeometricRotationInverse: ------------------ | Branch (555:9): [True: 0, False: 2.99k] ------------------ 556| 0| return "GeometricRotationInverse"; 557| 0| case TransformationComp_GeometricTranslationInverse: ------------------ | Branch (557:9): [True: 0, False: 2.99k] ------------------ 558| 0| return "GeometricTranslationInverse"; 559| 0| case TransformationComp_MAXIMUM: // this is to silence compiler warnings ------------------ | Branch (559:9): [True: 0, False: 2.99k] ------------------ 560| 0| default: ------------------ | Branch (560:9): [True: 0, False: 2.99k] ------------------ 561| 0| break; 562| 2.99k| } 563| | 564| 2.99k| ai_assert(false); 565| | 566| 0| return nullptr; 567| 2.99k|} _ZN6Assimp3FBX12FBXConverter30NameTransformationCompPropertyENS1_18TransformationCompE: 569| 92.1k|const char *FBXConverter::NameTransformationCompProperty(TransformationComp comp) { 570| 92.1k| switch (comp) { ------------------ | Branch (570:13): [True: 92.1k, False: 0] ------------------ 571| 3.25k| case TransformationComp_Translation: ------------------ | Branch (571:9): [True: 3.25k, False: 88.9k] ------------------ 572| 3.25k| return "Lcl Translation"; 573| 6.51k| case TransformationComp_RotationOffset: ------------------ | Branch (573:9): [True: 6.51k, False: 85.6k] ------------------ 574| 6.51k| return "RotationOffset"; 575| 6.50k| case TransformationComp_RotationPivot: ------------------ | Branch (575:9): [True: 6.50k, False: 85.6k] ------------------ 576| 6.50k| return "RotationPivot"; 577| 6.45k| case TransformationComp_PreRotation: ------------------ | Branch (577:9): [True: 6.45k, False: 85.7k] ------------------ 578| 6.45k| return "PreRotation"; 579| 3.25k| case TransformationComp_Rotation: ------------------ | Branch (579:9): [True: 3.25k, False: 88.9k] ------------------ 580| 3.25k| return "Lcl Rotation"; 581| 6.23k| case TransformationComp_PostRotation: ------------------ | Branch (581:9): [True: 6.23k, False: 85.9k] ------------------ 582| 6.23k| return "PostRotation"; 583| 2.98k| case TransformationComp_RotationPivotInverse: ------------------ | Branch (583:9): [True: 2.98k, False: 89.2k] ------------------ 584| 2.98k| return "RotationPivotInverse"; 585| 6.23k| case TransformationComp_ScalingOffset: ------------------ | Branch (585:9): [True: 6.23k, False: 85.9k] ------------------ 586| 6.23k| return "ScalingOffset"; 587| 6.23k| case TransformationComp_ScalingPivot: ------------------ | Branch (587:9): [True: 6.23k, False: 85.9k] ------------------ 588| 6.23k| return "ScalingPivot"; 589| 3.25k| case TransformationComp_Scaling: ------------------ | Branch (589:9): [True: 3.25k, False: 88.9k] ------------------ 590| 3.25k| return "Lcl Scaling"; 591| 2.98k| case TransformationComp_ScalingPivotInverse: ------------------ | Branch (591:9): [True: 2.98k, False: 89.2k] ------------------ 592| 2.98k| return "ScalingPivotInverse"; 593| 6.23k| case TransformationComp_GeometricScaling: ------------------ | Branch (593:9): [True: 6.23k, False: 85.9k] ------------------ 594| 6.23k| return "GeometricScaling"; 595| 6.23k| case TransformationComp_GeometricRotation: ------------------ | Branch (595:9): [True: 6.23k, False: 85.9k] ------------------ 596| 6.23k| return "GeometricRotation"; 597| 6.23k| case TransformationComp_GeometricTranslation: ------------------ | Branch (597:9): [True: 6.23k, False: 85.9k] ------------------ 598| 6.23k| return "GeometricTranslation"; 599| 6.51k| case TransformationComp_GeometricScalingInverse: ------------------ | Branch (599:9): [True: 6.51k, False: 85.6k] ------------------ 600| 6.51k| return "GeometricScalingInverse"; 601| 6.51k| case TransformationComp_GeometricRotationInverse: ------------------ | Branch (601:9): [True: 6.51k, False: 85.6k] ------------------ 602| 6.51k| return "GeometricRotationInverse"; 603| 6.51k| case TransformationComp_GeometricTranslationInverse: ------------------ | Branch (603:9): [True: 6.51k, False: 85.6k] ------------------ 604| 6.51k| return "GeometricTranslationInverse"; 605| 0| case TransformationComp_MAXIMUM: ------------------ | Branch (605:9): [True: 0, False: 92.1k] ------------------ 606| 0| break; 607| 92.1k| } 608| | 609| 92.1k| ai_assert(false); 610| | 611| 0| return nullptr; 612| 92.1k|} _ZN6Assimp3FBX12FBXConverter17GetRotationMatrixENS0_5Model8RotOrderERK10aiVector3tIfER12aiMatrix4x4tIfE: 620| 4.88M|void FBXConverter::GetRotationMatrix(Model::RotOrder mode, const aiVector3D &rotation, aiMatrix4x4 &out) { 621| 4.88M| if (mode == Model::RotOrder_SphericXYZ) { ------------------ | Branch (621:9): [True: 0, False: 4.88M] ------------------ 622| 0| FBXImporter::LogError("Unsupported RotationMode: SphericXYZ"); 623| 0| out = aiMatrix4x4(); 624| 0| return; 625| 0| } 626| | 627| 4.88M| const float angle_epsilon = Math::getEpsilon(); 628| | 629| 4.88M| out = aiMatrix4x4(); 630| | 631| 4.88M| bool is_id[3] = { true, true, true }; 632| | 633| 4.88M| aiMatrix4x4 temp[3]; 634| 4.88M| const auto rot = AI_DEG_TO_RAD(rotation); 635| 4.88M| if (std::fabs(rot.z) > angle_epsilon) { ------------------ | Branch (635:9): [True: 1.28M, False: 3.59M] ------------------ 636| 1.28M| aiMatrix4x4::RotationZ(rot.z, temp[2]); 637| 1.28M| is_id[2] = false; 638| 1.28M| } 639| 4.88M| if (std::fabs(rot.y) > angle_epsilon) { ------------------ | Branch (639:9): [True: 1.05M, False: 3.82M] ------------------ 640| 1.05M| aiMatrix4x4::RotationY(rot.y, temp[1]); 641| 1.05M| is_id[1] = false; 642| 1.05M| } 643| 4.88M| if (std::fabs(rot.x) > angle_epsilon) { ------------------ | Branch (643:9): [True: 4.64M, False: 235k] ------------------ 644| 4.64M| aiMatrix4x4::RotationX(rot.x, temp[0]); 645| 4.64M| is_id[0] = false; 646| 4.64M| } 647| | 648| 4.88M| int order[3] = { -1, -1, -1 }; 649| | 650| | // note: rotation order is inverted since we're left multiplying as is usual in assimp 651| 4.88M| switch (mode) { 652| 4.88M| case Model::RotOrder_EulerXYZ: ------------------ | Branch (652:9): [True: 4.88M, False: 0] ------------------ 653| 4.88M| order[0] = 2; 654| 4.88M| order[1] = 1; 655| 4.88M| order[2] = 0; 656| 4.88M| break; 657| | 658| 0| case Model::RotOrder_EulerXZY: ------------------ | Branch (658:9): [True: 0, False: 4.88M] ------------------ 659| 0| order[0] = 1; 660| 0| order[1] = 2; 661| 0| order[2] = 0; 662| 0| break; 663| | 664| 0| case Model::RotOrder_EulerYZX: ------------------ | Branch (664:9): [True: 0, False: 4.88M] ------------------ 665| 0| order[0] = 0; 666| 0| order[1] = 2; 667| 0| order[2] = 1; 668| 0| break; 669| | 670| 0| case Model::RotOrder_EulerYXZ: ------------------ | Branch (670:9): [True: 0, False: 4.88M] ------------------ 671| 0| order[0] = 2; 672| 0| order[1] = 0; 673| 0| order[2] = 1; 674| 0| break; 675| | 676| 0| case Model::RotOrder_EulerZXY: ------------------ | Branch (676:9): [True: 0, False: 4.88M] ------------------ 677| 0| order[0] = 1; 678| 0| order[1] = 0; 679| 0| order[2] = 2; 680| 0| break; 681| | 682| 0| case Model::RotOrder_EulerZYX: ------------------ | Branch (682:9): [True: 0, False: 4.88M] ------------------ 683| 0| order[0] = 0; 684| 0| order[1] = 1; 685| 0| order[2] = 2; 686| 0| break; 687| | 688| 0| default: ------------------ | Branch (688:9): [True: 0, False: 4.88M] ------------------ 689| 0| ai_assert(false); 690| 0| break; 691| 4.88M| } 692| | 693| 4.88M| ai_assert(order[0] >= 0); 694| 4.88M| ai_assert(order[0] <= 2); 695| 4.88M| ai_assert(order[1] >= 0); 696| 4.88M| ai_assert(order[1] <= 2); 697| 4.88M| ai_assert(order[2] >= 0); 698| 4.88M| ai_assert(order[2] <= 2); 699| | 700| 4.88M| if (!is_id[order[0]]) { ------------------ | Branch (700:9): [True: 1.28M, False: 3.59M] ------------------ 701| 1.28M| out = temp[order[0]]; 702| 1.28M| } 703| | 704| 4.88M| if (!is_id[order[1]]) { ------------------ | Branch (704:9): [True: 1.05M, False: 3.82M] ------------------ 705| 1.05M| out = out * temp[order[1]]; 706| 1.05M| } 707| | 708| 4.88M| if (!is_id[order[2]]) { ------------------ | Branch (708:9): [True: 4.64M, False: 235k] ------------------ 709| 4.64M| out = out * temp[order[2]]; 710| 4.64M| } 711| 4.88M|} _ZN6Assimp3FBX12FBXConverter31NeedsComplexTransformationChainERKNS0_5ModelE: 713| 3.25k|bool FBXConverter::NeedsComplexTransformationChain(const Model &model) { 714| 3.25k| const PropertyTable &props = model.Props(); 715| | 716| 3.25k| const auto zero_epsilon = Math::getEpsilon(); 717| 3.25k| const aiVector3D all_ones(1.0f, 1.0f, 1.0f); 718| 55.2k| for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i) { ------------------ | Branch (718:24): [True: 52.5k, False: 2.72k] ------------------ 719| 52.5k| const TransformationComp comp = static_cast(i); 720| | 721| 52.5k| if (comp == TransformationComp_Rotation || comp == TransformationComp_Scaling || comp == TransformationComp_Translation) { ------------------ | Branch (721:13): [True: 2.98k, False: 49.5k] | Branch (721:52): [True: 2.98k, False: 46.5k] | Branch (721:90): [True: 3.25k, False: 43.3k] ------------------ 722| 9.22k| continue; 723| 9.22k| } 724| | 725| 43.3k| bool scale_compare = (comp == TransformationComp_GeometricScaling || comp == TransformationComp_Scaling); ------------------ | Branch (725:31): [True: 2.98k, False: 40.3k] | Branch (725:78): [True: 0, False: 40.3k] ------------------ 726| | 727| 43.3k| bool ok = true; 728| 43.3k| const aiVector3D &v = PropertyGet(props, NameTransformationCompProperty(comp), ok); 729| 43.3k| if (ok && scale_compare) { ------------------ | Branch (729:13): [True: 26.2k, False: 17.1k] | Branch (729:19): [True: 2.84k, False: 23.3k] ------------------ 730| 2.84k| if ((v - all_ones).SquareLength() > zero_epsilon) { ------------------ | Branch (730:17): [True: 260, False: 2.58k] ------------------ 731| 260| return true; 732| 260| } 733| 40.4k| } else if (ok) { ------------------ | Branch (733:20): [True: 23.3k, False: 17.1k] ------------------ 734| 23.3k| if (v.SquareLength() > zero_epsilon) { ------------------ | Branch (734:17): [True: 274, False: 23.0k] ------------------ 735| 274| return true; 736| 274| } 737| 23.3k| } 738| 43.3k| } 739| | 740| 2.72k| return false; 741| 3.25k|} _ZN6Assimp3FBX12FBXConverter27NameTransformationChainNodeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS1_18TransformationCompE: 743| 2.99k|std::string FBXConverter::NameTransformationChainNode(const std::string &name, TransformationComp comp) { 744| 2.99k| return name + std::string(MAGIC_NODE_TAG) + "_" + NameTransformationComp(comp); ------------------ | | 75| 2.99k|#define MAGIC_NODE_TAG "_$AssimpFbx$" ------------------ 745| 2.99k|} _ZN6Assimp3FBX12FBXConverter31GenerateTransformationNodeChainERKNS0_5ModelERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERNS5_6vectorINS1_13PotentialNodeENS9_ISF_EEEESI_: 748| 3.58k| std::vector &post_output_nodes) { 749| 3.58k| const PropertyTable &props = model.Props(); 750| 3.58k| const Model::RotOrder rot = model.RotationOrder(); 751| | 752| 3.58k| bool ok; 753| | 754| 3.58k| aiMatrix4x4 chain[TransformationComp_MAXIMUM]; 755| | 756| 3.58k| ai_assert(TransformationComp_MAXIMUM < 32); 757| 3.58k| std::uint32_t chainBits = 0; 758| | // A node won't need a node chain if it only has these. 759| 3.58k| const std::uint32_t chainMaskSimple = (1 << TransformationComp_Translation) + (1 << TransformationComp_Scaling) + (1 << TransformationComp_Rotation); 760| | // A node will need a node chain if it has any of these. 761| 3.58k| const std::uint32_t chainMaskComplex = ((1 << (TransformationComp_MAXIMUM)) - 1) - chainMaskSimple; 762| | 763| 3.58k| std::fill_n(chain, static_cast(TransformationComp_MAXIMUM), aiMatrix4x4()); 764| | 765| | // generate transformation matrices for all the different transformation components 766| 3.58k| const float zero_epsilon = Math::getEpsilon(); 767| 3.58k| const aiVector3D all_ones(1.0f, 1.0f, 1.0f); 768| | 769| 3.58k| const aiVector3D &PreRotation = PropertyGet(props, "PreRotation", ok); 770| 3.58k| if (ok && PreRotation.SquareLength() > zero_epsilon) { ------------------ | Branch (770:9): [True: 3.40k, False: 187] | Branch (770:15): [True: 70, False: 3.33k] ------------------ 771| 70| chainBits = chainBits | (1 << TransformationComp_PreRotation); 772| | 773| 70| GetRotationMatrix(Model::RotOrder::RotOrder_EulerXYZ, PreRotation, chain[TransformationComp_PreRotation]); 774| 70| } 775| | 776| 3.58k| const aiVector3D &PostRotation = PropertyGet(props, "PostRotation", ok); 777| 3.58k| if (ok && PostRotation.SquareLength() > zero_epsilon) { ------------------ | Branch (777:9): [True: 3.38k, False: 208] | Branch (777:15): [True: 0, False: 3.38k] ------------------ 778| 0| chainBits = chainBits | (1 << TransformationComp_PostRotation); 779| | 780| 0| GetRotationMatrix(Model::RotOrder::RotOrder_EulerXYZ, PostRotation, chain[TransformationComp_PostRotation]); 781| 0| } 782| | 783| 3.58k| const aiVector3D &RotationPivot = PropertyGet(props, "RotationPivot", ok); 784| 3.58k| if (ok && RotationPivot.SquareLength() > zero_epsilon) { ------------------ | Branch (784:9): [True: 3.38k, False: 204] | Branch (784:15): [True: 35, False: 3.35k] ------------------ 785| 35| chainBits = chainBits | (1 << TransformationComp_RotationPivot) | (1 << TransformationComp_RotationPivotInverse); 786| | 787| 35| aiMatrix4x4::Translation(RotationPivot, chain[TransformationComp_RotationPivot]); 788| 35| aiMatrix4x4::Translation(-RotationPivot, chain[TransformationComp_RotationPivotInverse]); 789| 35| } 790| | 791| 3.58k| const aiVector3D &RotationOffset = PropertyGet(props, "RotationOffset", ok); 792| 3.58k| if (ok && RotationOffset.SquareLength() > zero_epsilon) { ------------------ | Branch (792:9): [True: 3.36k, False: 224] | Branch (792:15): [True: 0, False: 3.36k] ------------------ 793| 0| chainBits = chainBits | (1 << TransformationComp_RotationOffset); 794| | 795| 0| aiMatrix4x4::Translation(RotationOffset, chain[TransformationComp_RotationOffset]); 796| 0| } 797| | 798| 3.58k| const aiVector3D &ScalingOffset = PropertyGet(props, "ScalingOffset", ok); 799| 3.58k| if (ok && ScalingOffset.SquareLength() > zero_epsilon) { ------------------ | Branch (799:9): [True: 3.37k, False: 212] | Branch (799:15): [True: 0, False: 3.37k] ------------------ 800| 0| chainBits = chainBits | (1 << TransformationComp_ScalingOffset); 801| | 802| 0| aiMatrix4x4::Translation(ScalingOffset, chain[TransformationComp_ScalingOffset]); 803| 0| } 804| | 805| 3.58k| const aiVector3D &ScalingPivot = PropertyGet(props, "ScalingPivot", ok); 806| 3.58k| if (ok && ScalingPivot.SquareLength() > zero_epsilon) { ------------------ | Branch (806:9): [True: 3.39k, False: 197] | Branch (806:15): [True: 0, False: 3.39k] ------------------ 807| 0| chainBits = chainBits | (1 << TransformationComp_ScalingPivot) | (1 << TransformationComp_ScalingPivotInverse); 808| | 809| 0| aiMatrix4x4::Translation(ScalingPivot, chain[TransformationComp_ScalingPivot]); 810| 0| aiMatrix4x4::Translation(-ScalingPivot, chain[TransformationComp_ScalingPivotInverse]); 811| 0| } 812| | 813| 3.58k| const aiVector3D &Translation = PropertyGet(props, "Lcl Translation", ok); 814| 3.58k| if (ok && Translation.SquareLength() > zero_epsilon) { ------------------ | Branch (814:9): [True: 3.54k, False: 47] | Branch (814:15): [True: 3.49k, False: 50] ------------------ 815| 3.49k| chainBits = chainBits | (1 << TransformationComp_Translation); 816| | 817| 3.49k| aiMatrix4x4::Translation(Translation, chain[TransformationComp_Translation]); 818| 3.49k| } 819| | 820| 3.58k| const aiVector3D &Scaling = PropertyGet(props, "Lcl Scaling", ok); 821| 3.58k| if (ok && (Scaling - all_ones).SquareLength() > zero_epsilon) { ------------------ | Branch (821:9): [True: 3.52k, False: 65] | Branch (821:9): [True: 861, False: 2.72k] | Branch (821:15): [True: 861, False: 2.66k] ------------------ 822| 861| chainBits = chainBits | (1 << TransformationComp_Scaling); 823| | 824| 861| aiMatrix4x4::Scaling(Scaling, chain[TransformationComp_Scaling]); 825| 861| } 826| | 827| 3.58k| const aiVector3D &Rotation = PropertyGet(props, "Lcl Rotation", ok); 828| 3.58k| if (ok && Rotation.SquareLength() > zero_epsilon) { ------------------ | Branch (828:9): [True: 3.52k, False: 69] | Branch (828:15): [True: 2.84k, False: 676] ------------------ 829| 2.84k| chainBits = chainBits | (1 << TransformationComp_Rotation); 830| | 831| 2.84k| GetRotationMatrix(rot, Rotation, chain[TransformationComp_Rotation]); 832| 2.84k| } 833| | 834| 3.58k| const aiVector3D &GeometricScaling = PropertyGet(props, "GeometricScaling", ok); 835| 3.58k| if (ok && (GeometricScaling - all_ones).SquareLength() > zero_epsilon) { ------------------ | Branch (835:9): [True: 3.39k, False: 198] | Branch (835:9): [True: 264, False: 3.32k] | Branch (835:15): [True: 264, False: 3.12k] ------------------ 836| 264| chainBits = chainBits | (1 << TransformationComp_GeometricScaling); 837| 264| aiMatrix4x4::Scaling(GeometricScaling, chain[TransformationComp_GeometricScaling]); 838| 264| aiVector3D GeometricScalingInverse = GeometricScaling; 839| 264| bool canscale = true; 840| 1.01k| for (unsigned int i = 0; i < 3; ++i) { ------------------ | Branch (840:34): [True: 792, False: 224] ------------------ 841| 792| if (std::fabs(GeometricScalingInverse[i]) > zero_epsilon) { ------------------ | Branch (841:17): [True: 752, False: 40] ------------------ 842| 752| GeometricScalingInverse[i] = 1.0f / GeometricScaling[i]; 843| 752| } else { 844| 40| FBXImporter::LogError("cannot invert geometric scaling matrix with a 0.0 scale component"); 845| 40| canscale = false; 846| 40| break; 847| 40| } 848| 792| } 849| 264| if (canscale) { ------------------ | Branch (849:13): [True: 224, False: 40] ------------------ 850| 224| chainBits = chainBits | (1 << TransformationComp_GeometricScalingInverse); 851| 224| aiMatrix4x4::Scaling(GeometricScalingInverse, chain[TransformationComp_GeometricScalingInverse]); 852| 224| } 853| 264| } 854| | 855| 3.58k| const aiVector3D &GeometricRotation = PropertyGet(props, "GeometricRotation", ok); 856| 3.58k| if (ok && GeometricRotation.SquareLength() > zero_epsilon) { ------------------ | Branch (856:9): [True: 3.37k, False: 218] | Branch (856:15): [True: 0, False: 3.37k] ------------------ 857| 0| chainBits = chainBits | (1 << TransformationComp_GeometricRotation) | (1 << TransformationComp_GeometricRotationInverse); 858| 0| GetRotationMatrix(rot, GeometricRotation, chain[TransformationComp_GeometricRotation]); 859| 0| GetRotationMatrix(rot, GeometricRotation, chain[TransformationComp_GeometricRotationInverse]); 860| 0| chain[TransformationComp_GeometricRotationInverse].Inverse(); 861| 0| } 862| | 863| 3.58k| const aiVector3D &GeometricTranslation = PropertyGet(props, "GeometricTranslation", ok); 864| 3.58k| if (ok && GeometricTranslation.SquareLength() > zero_epsilon) { ------------------ | Branch (864:9): [True: 3.31k, False: 278] | Branch (864:15): [True: 0, False: 3.31k] ------------------ 865| 0| chainBits = chainBits | (1 << TransformationComp_GeometricTranslation) | (1 << TransformationComp_GeometricTranslationInverse); 866| 0| aiMatrix4x4::Translation(GeometricTranslation, chain[TransformationComp_GeometricTranslation]); 867| 0| aiMatrix4x4::Translation(-GeometricTranslation, chain[TransformationComp_GeometricTranslationInverse]); 868| 0| } 869| | 870| | // now, if we have more than just Translation, Scaling and Rotation, 871| | // we need to generate a full node chain to accommodate for assimp's 872| | // lack to express pivots and offsets. 873| 3.58k| if ((chainBits & chainMaskComplex) && doc.Settings().preservePivots) { ------------------ | Branch (873:9): [True: 356, False: 3.23k] | Branch (873:43): [True: 356, False: 0] ------------------ 874| 356| FBXImporter::LogInfo("generating full transformation chain for node: ", name); 875| | 876| | // query the anim_chain_bits dictionary to find out which chain elements 877| | // have associated node animation channels. These can not be dropped 878| | // even if they have identity transform in bind pose. 879| 356| NodeAnimBitMap::const_iterator it = node_anim_chain_bits.find(name); 880| 356| const unsigned int anim_chain_bitmask = (it == node_anim_chain_bits.end() ? 0 : (*it).second); ------------------ | Branch (880:50): [True: 144, False: 212] ------------------ 881| | 882| 356| unsigned int bit = 0x1; 883| 6.40k| for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i, bit <<= 1) { ------------------ | Branch (883:28): [True: 6.05k, False: 356] ------------------ 884| 6.05k| const TransformationComp comp = static_cast(i); 885| | 886| 6.05k| if ((chainBits & bit) == 0 && (anim_chain_bitmask & bit) == 0) { ------------------ | Branch (886:17): [True: 4.70k, False: 1.34k] | Branch (886:43): [True: 4.50k, False: 207] ------------------ 887| 4.50k| continue; 888| 4.50k| } 889| | 890| 1.55k| if (comp == TransformationComp_PostRotation) { ------------------ | Branch (890:17): [True: 0, False: 1.55k] ------------------ 891| 0| chain[i] = chain[i].Inverse(); 892| 0| } 893| | 894| 1.55k| PotentialNode nd; 895| 1.55k| nd->mName.Set(NameTransformationChainNode(name, comp)); 896| 1.55k| nd->mTransformation = chain[i]; 897| | 898| | // geometric inverses go in a post-node chain 899| 1.55k| if (comp == TransformationComp_GeometricScalingInverse || ------------------ | Branch (899:17): [True: 224, False: 1.32k] ------------------ 900| 1.32k| comp == TransformationComp_GeometricRotationInverse || ------------------ | Branch (900:21): [True: 0, False: 1.32k] ------------------ 901| 1.32k| comp == TransformationComp_GeometricTranslationInverse) { ------------------ | Branch (901:21): [True: 0, False: 1.32k] ------------------ 902| 224| post_output_nodes.emplace_back(std::move(nd)); 903| 1.32k| } else { 904| 1.32k| output_nodes.emplace_back(std::move(nd)); 905| 1.32k| } 906| 1.55k| } 907| | 908| 356| ai_assert(output_nodes.size()); 909| 356| return true; 910| 356| } 911| | 912| | // else, we can just multiply the matrices together 913| 3.23k| PotentialNode nd; 914| | 915| | // name passed to the method is already unique 916| 3.23k| nd->mName.Set(name); 917| | // for (const auto &transform : chain) { 918| | // skip inverse chain for no preservePivots 919| 48.2k| for (unsigned int i = TransformationComp_Translation; i < TransformationComp_MAXIMUM; i++) { ------------------ | Branch (919:59): [True: 45.0k, False: 3.23k] ------------------ 920| 45.0k| nd->mTransformation = nd->mTransformation * chain[i]; 921| 45.0k| } 922| 3.23k| output_nodes.push_back(std::move(nd)); 923| 3.23k| return false; 924| 3.58k|} _ZN6Assimp3FBX12FBXConverter17SetupNodeMetadataERKNS0_5ModelER6aiNode: 926| 3.57k|void FBXConverter::SetupNodeMetadata(const Model &model, aiNode &nd) { 927| 3.57k| const PropertyTable &props = model.Props(); 928| 3.57k| DirectPropertyMap unparsedProperties = props.GetUnparsedProperties(); 929| | 930| | // create metadata on node 931| 3.57k| const std::size_t numStaticMetaData = 2; 932| 3.57k| aiMetadata *data = aiMetadata::Alloc(static_cast(unparsedProperties.size() + numStaticMetaData)); 933| 3.57k| nd.mMetaData = data; 934| 3.57k| int index = 0; 935| | 936| | // find user defined properties (3ds Max) 937| 3.57k| data->Set(index++, "UserProperties", aiString(PropertyGet(props, "UDP3DSMAX", ""))); 938| | // preserve the info that a node was marked as Null node in the original file. 939| 3.57k| data->Set(index++, "IsNull", model.IsNull() ? true : false); ------------------ | Branch (939:34): [True: 185, False: 3.39k] ------------------ 940| | 941| | // add unparsed properties to the node's metadata 942| 10.3k| for (const DirectPropertyMap::value_type &prop : unparsedProperties) { ------------------ | Branch (942:52): [True: 10.3k, False: 3.57k] ------------------ 943| | // Interpret the property as a concrete type 944| 10.3k| if (const TypedProperty *interpretedBool = prop.second->As>()) { ------------------ | Branch (944:40): [True: 1.37k, False: 8.92k] ------------------ 945| 1.37k| data->Set(index++, prop.first, interpretedBool->Value()); 946| 8.92k| } else if (const TypedProperty *interpretedInt = prop.second->As>()) { ------------------ | Branch (946:46): [True: 7.56k, False: 1.36k] ------------------ 947| 7.56k| data->Set(index++, prop.first, interpretedInt->Value()); 948| 7.56k| } else if (const TypedProperty *interpretedUInt = prop.second->As>()) { ------------------ | Branch (948:51): [True: 0, False: 1.36k] ------------------ 949| 0| data->Set(index++, prop.first, interpretedUInt->Value()); 950| 1.36k| } else if (const TypedProperty *interpretedUint64 = prop.second->As>()) { ------------------ | Branch (950:51): [True: 0, False: 1.36k] ------------------ 951| 0| data->Set(index++, prop.first, interpretedUint64->Value()); 952| 1.36k| } else if (const TypedProperty *interpretedint64 = prop.second->As>()) { ------------------ | Branch (952:50): [True: 0, False: 1.36k] ------------------ 953| 0| data->Set(index++, prop.first, interpretedint64->Value()); 954| 1.36k| } else if (const TypedProperty *interpretedFloat = prop.second->As>()) { ------------------ | Branch (954:48): [True: 1.11k, False: 250] ------------------ 955| 1.11k| data->Set(index++, prop.first, interpretedFloat->Value()); 956| 1.11k| } else if (const TypedProperty *interpretedString = prop.second->As>()) { ------------------ | Branch (956:54): [True: 10, False: 240] ------------------ 957| 10| data->Set(index++, prop.first, aiString(interpretedString->Value())); 958| 240| } else if (const TypedProperty *interpretedVec3 = prop.second->As>()) { ------------------ | Branch (958:53): [True: 240, False: 0] ------------------ 959| 240| data->Set(index++, prop.first, interpretedVec3->Value()); 960| 240| } else { 961| | ai_assert(false); 962| 0| } 963| 10.3k| } 964| 3.57k|} _ZN6Assimp3FBX12FBXConverter12ConvertModelERKNS0_5ModelEP6aiNodeS6_RK12aiMatrix4x4tIfE: 966| 3.56k|void FBXConverter::ConvertModel(const Model &model, aiNode *parent, aiNode *root_node, const aiMatrix4x4 &absolute_transform) { 967| 3.56k| const std::vector &geos = model.GetGeometry(); 968| | 969| 3.56k| std::vector meshes; 970| 3.56k| meshes.reserve(geos.size()); 971| | 972| 3.56k| for (const Geometry *geo : geos) { ------------------ | Branch (972:30): [True: 100, False: 3.56k] ------------------ 973| 100| const MeshGeometry *const mesh = dynamic_cast(geo); 974| 100| const LineGeometry *const line = dynamic_cast(geo); 975| 100| if (mesh) { ------------------ | Branch (975:13): [True: 100, False: 0] ------------------ 976| 100| const std::vector &indices = ConvertMesh(*mesh, model, parent, root_node, absolute_transform); 977| 100| std::copy(indices.begin(), indices.end(), std::back_inserter(meshes)); 978| 100| } else if (line) { ------------------ | Branch (978:20): [True: 0, False: 0] ------------------ 979| 0| const std::vector &indices = ConvertLine(*line, root_node); 980| 0| std::copy(indices.begin(), indices.end(), std::back_inserter(meshes)); 981| 0| } else if (geo) { ------------------ | Branch (981:20): [True: 0, False: 0] ------------------ 982| 0| FBXImporter::LogWarn("ignoring unrecognized geometry: ", geo->Name()); 983| 0| } else { 984| 0| FBXImporter::LogWarn("skipping null geometry"); 985| 0| } 986| 100| } 987| | 988| 3.56k| if (meshes.size()) { ------------------ | Branch (988:9): [True: 100, False: 3.46k] ------------------ 989| 100| parent->mMeshes = new unsigned int[meshes.size()](); 990| 100| parent->mNumMeshes = static_cast(meshes.size()); 991| | 992| 100| std::swap_ranges(meshes.begin(), meshes.end(), parent->mMeshes); 993| 100| } 994| 3.56k|} _ZN6Assimp3FBX12FBXConverter11ConvertMeshERKNS0_12MeshGeometryERKNS0_5ModelEP6aiNodeS9_RK12aiMatrix4x4tIfE: 997| 100|FBXConverter::ConvertMesh(const MeshGeometry &mesh, const Model &model, aiNode *parent, aiNode *root_node, const aiMatrix4x4 &absolute_transform) { 998| 100| std::vector temp; 999| | 1000| 100| MeshMap::const_iterator it = meshes_converted.find(&mesh); 1001| 100| if (it != meshes_converted.end()) { ------------------ | Branch (1001:9): [True: 5, False: 95] ------------------ 1002| 5| std::copy((*it).second.begin(), (*it).second.end(), std::back_inserter(temp)); 1003| 5| return temp; 1004| 5| } 1005| | 1006| 95| const std::vector &vertices = mesh.GetVertices(); 1007| 95| const std::vector &faces = mesh.GetFaceIndexCounts(); 1008| 95| if (vertices.empty() || faces.empty()) { ------------------ | Branch (1008:9): [True: 0, False: 95] | Branch (1008:29): [True: 0, False: 95] ------------------ 1009| 0| FBXImporter::LogWarn("ignoring empty geometry: ", mesh.Name()); 1010| 0| return temp; 1011| 0| } 1012| | 1013| | // one material per mesh maps easily to aiMesh. Multiple material 1014| | // meshes need to be split. 1015| 95| const MatIndexArray &mindices = mesh.GetMaterialIndices(); 1016| 95| if (doc.Settings().readMaterials && !mindices.empty()) { ------------------ | Branch (1016:9): [True: 95, False: 0] | Branch (1016:41): [True: 89, False: 6] ------------------ 1017| 89| const MatIndexArray::value_type base = mindices[0]; 1018| 347k| for (MatIndexArray::value_type index : mindices) { ------------------ | Branch (1018:46): [True: 347k, False: 89] ------------------ 1019| 347k| if (index != base) { ------------------ | Branch (1019:17): [True: 0, False: 347k] ------------------ 1020| 0| return ConvertMeshMultiMaterial(mesh, model, absolute_transform, parent, root_node); 1021| 0| } 1022| 347k| } 1023| 89| } 1024| | 1025| | // faster code-path, just copy the data 1026| 95| temp.push_back(ConvertMeshSingleMaterial(mesh, model, absolute_transform, parent, root_node)); 1027| 95| return temp; 1028| 95|} _ZN6Assimp3FBX12FBXConverter14SetupEmptyMeshERKNS0_8GeometryEP6aiNode: 1074| 95|aiMesh *FBXConverter::SetupEmptyMesh(const Geometry &mesh, aiNode *parent) { 1075| 95| aiMesh *const out_mesh = new aiMesh(); 1076| 95| mMeshes.push_back(out_mesh); 1077| 95| meshes_converted[&mesh].push_back(static_cast(mMeshes.size() - 1)); 1078| | 1079| | // set name 1080| 95| std::string name = mesh.Name(); 1081| 95| if (name.substr(0, 10) == "Geometry::") { ------------------ | Branch (1081:9): [True: 93, False: 2] ------------------ 1082| 93| name = name.substr(10); 1083| 93| } 1084| | 1085| 95| if (name.length()) { ------------------ | Branch (1085:9): [True: 86, False: 9] ------------------ 1086| 86| out_mesh->mName.Set(name); 1087| 86| } else { 1088| 9| out_mesh->mName = parent->mName; 1089| 9| } 1090| | 1091| 95| return out_mesh; 1092| 95|} _ZN6Assimp3FBX12FBXConverter25ConvertMeshSingleMaterialERKNS0_12MeshGeometryERKNS0_5ModelERK12aiMatrix4x4tIfEP6aiNodeSD_: 1123| 95| aiNode *parent, aiNode *) { 1124| 95| const MatIndexArray &mindices = mesh.GetMaterialIndices(); 1125| 95| aiMesh *const out_mesh = SetupEmptyMesh(mesh, parent); 1126| | 1127| 95| const std::vector &vertices = mesh.GetVertices(); 1128| 95| const std::vector &faces = mesh.GetFaceIndexCounts(); 1129| | 1130| | // copy vertices 1131| 95| out_mesh->mNumVertices = static_cast(vertices.size()); 1132| 95| out_mesh->mVertices = new aiVector3D[vertices.size()]; 1133| | 1134| 95| std::copy(vertices.begin(), vertices.end(), out_mesh->mVertices); 1135| | 1136| | // generate dummy faces 1137| 95| out_mesh->mNumFaces = static_cast(faces.size()); 1138| 95| aiFace *fac = out_mesh->mFaces = new aiFace[faces.size()](); 1139| | 1140| 95| unsigned int cursor = 0; 1141| 90.8k| for (unsigned int pcount : faces) { ------------------ | Branch (1141:30): [True: 90.8k, False: 95] ------------------ 1142| 90.8k| aiFace &f = *fac++; 1143| 90.8k| f.mNumIndices = pcount; 1144| 90.8k| f.mIndices = new unsigned int[pcount]; 1145| 90.8k| switch (pcount) { 1146| 0| case 1: ------------------ | Branch (1146:13): [True: 0, False: 90.8k] ------------------ 1147| 0| out_mesh->mPrimitiveTypes |= aiPrimitiveType_POINT; 1148| 0| break; 1149| 21| case 2: ------------------ | Branch (1149:13): [True: 21, False: 90.8k] ------------------ 1150| 21| out_mesh->mPrimitiveTypes |= aiPrimitiveType_LINE; 1151| 21| break; 1152| 11| case 3: ------------------ | Branch (1152:13): [True: 11, False: 90.8k] ------------------ 1153| 11| out_mesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE; 1154| 11| break; 1155| 90.8k| default: ------------------ | Branch (1155:13): [True: 90.8k, False: 32] ------------------ 1156| 90.8k| out_mesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON; 1157| 90.8k| break; 1158| 90.8k| } 1159| 615k| for (unsigned int i = 0; i < pcount; ++i) { ------------------ | Branch (1159:34): [True: 524k, False: 90.8k] ------------------ 1160| 524k| f.mIndices[i] = cursor++; 1161| 524k| } 1162| 90.8k| } 1163| | 1164| | // copy normals 1165| 95| const std::vector &normals = mesh.GetNormals(); 1166| 95| if (normals.size()) { ------------------ | Branch (1166:9): [True: 24, False: 71] ------------------ 1167| 24| ai_assert(normals.size() == vertices.size()); 1168| | 1169| 24| out_mesh->mNormals = new aiVector3D[vertices.size()]; 1170| 24| std::copy(normals.begin(), normals.end(), out_mesh->mNormals); 1171| 24| } 1172| | 1173| | // copy tangents - assimp requires both tangents and bitangents (binormals) 1174| | // to be present, or neither of them. Compute binormals from normals 1175| | // and tangents if needed. 1176| 95| const std::vector &tangents = mesh.GetTangents(); 1177| 95| const std::vector *binormals = &mesh.GetBinormals(); 1178| | 1179| 95| if (tangents.size()) { ------------------ | Branch (1179:9): [True: 5, False: 90] ------------------ 1180| 5| std::vector tempBinormals; 1181| 5| if (!binormals->size()) { ------------------ | Branch (1181:13): [True: 1, False: 4] ------------------ 1182| 1| if (normals.size()) { ------------------ | Branch (1182:17): [True: 0, False: 1] ------------------ 1183| 0| tempBinormals.resize(normals.size()); 1184| 0| for (unsigned int i = 0; i < tangents.size(); ++i) { ------------------ | Branch (1184:42): [True: 0, False: 0] ------------------ 1185| 0| tempBinormals[i] = normals[i] ^ tangents[i]; 1186| 0| } 1187| | 1188| 0| binormals = &tempBinormals; 1189| 1| } else { 1190| 1| binormals = nullptr; 1191| 1| } 1192| 1| } 1193| | 1194| 5| if (binormals) { ------------------ | Branch (1194:13): [True: 4, False: 1] ------------------ 1195| 4| ai_assert(tangents.size() == vertices.size()); 1196| 4| ai_assert(binormals->size() == vertices.size()); 1197| | 1198| 4| out_mesh->mTangents = new aiVector3D[vertices.size()]; 1199| 4| std::copy(tangents.begin(), tangents.end(), out_mesh->mTangents); 1200| | 1201| 4| out_mesh->mBitangents = new aiVector3D[vertices.size()]; 1202| 4| std::copy(binormals->begin(), binormals->end(), out_mesh->mBitangents); 1203| 4| } 1204| 5| } 1205| | 1206| | // copy texture coords 1207| 173| for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) { ------------------ | Branch (1207:30): [True: 173, False: 0] ------------------ 1208| 173| const std::vector &uvs = mesh.GetTextureCoords(i); 1209| 173| if (uvs.empty()) { ------------------ | Branch (1209:13): [True: 95, False: 78] ------------------ 1210| 95| break; 1211| 95| } 1212| | 1213| 78| aiVector3D *out_uv = out_mesh->mTextureCoords[i] = new aiVector3D[vertices.size()]; 1214| 305k| for (const aiVector2D &v : uvs) { ------------------ | Branch (1214:34): [True: 305k, False: 78] ------------------ 1215| 305k| *out_uv++ = aiVector3D(v.x, v.y, 0.0f); 1216| 305k| } 1217| | 1218| 78| out_mesh->SetTextureCoordsName(i, aiString(mesh.GetTextureCoordChannelName(i))); 1219| | 1220| 78| out_mesh->mNumUVComponents[i] = 2; 1221| 78| } 1222| | 1223| | // copy vertex colors 1224| 95| for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) { ------------------ | Branch (1224:30): [True: 95, False: 0] ------------------ 1225| 95| const std::vector &colors = mesh.GetVertexColors(i); 1226| 95| if (colors.empty()) { ------------------ | Branch (1226:13): [True: 95, False: 0] ------------------ 1227| 95| break; 1228| 95| } 1229| | 1230| 0| out_mesh->mColors[i] = new aiColor4D[vertices.size()]; 1231| 0| std::copy(colors.begin(), colors.end(), out_mesh->mColors[i]); 1232| 0| } 1233| | 1234| 95| if (!doc.Settings().readMaterials || mindices.empty()) { ------------------ | Branch (1234:9): [True: 0, False: 95] | Branch (1234:42): [True: 6, False: 89] ------------------ 1235| 6| FBXImporter::LogError("no material assigned to mesh, setting default material"); 1236| 6| out_mesh->mMaterialIndex = GetDefaultMaterial(); 1237| 89| } else { 1238| 89| ConvertMaterialForMesh(out_mesh, model, mesh, mindices[0]); 1239| 89| } 1240| | 1241| 95| if (doc.Settings().readWeights && mesh.DeformerSkin() != nullptr && !doc.Settings().useSkeleton) { ------------------ | Branch (1241:9): [True: 95, False: 0] | Branch (1241:39): [True: 84, False: 11] | Branch (1241:73): [True: 84, False: 0] ------------------ 1242| 84| ConvertWeights(out_mesh, mesh, absolute_transform, parent, NO_MATERIAL_SEPARATION, nullptr); 1243| 84| } else if (doc.Settings().readWeights && mesh.DeformerSkin() != nullptr && doc.Settings().useSkeleton) { ------------------ | Branch (1243:16): [True: 11, False: 0] | Branch (1243:46): [True: 0, False: 11] | Branch (1243:80): [True: 0, False: 0] ------------------ 1244| 0| SkeletonBoneContainer sbc; 1245| 0| ConvertWeightsToSkeleton(out_mesh, mesh, absolute_transform, parent, NO_MATERIAL_SEPARATION, nullptr, sbc); 1246| 0| aiSkeleton *skeleton = createAiSkeleton(sbc); 1247| 0| if (skeleton != nullptr) { ------------------ | Branch (1247:13): [True: 0, False: 0] ------------------ 1248| 0| mSkeletons.emplace_back(skeleton); 1249| 0| } 1250| 0| } 1251| | 1252| 95| std::vector animMeshes; 1253| 95| for (const BlendShape *blendShape : mesh.GetBlendShapes()) { ------------------ | Branch (1253:39): [True: 0, False: 95] ------------------ 1254| 0| for (const BlendShapeChannel *blendShapeChannel : blendShape->BlendShapeChannels()) { ------------------ | Branch (1254:57): [True: 0, False: 0] ------------------ 1255| 0| const auto& shapeGeometries = blendShapeChannel->GetShapeGeometries(); 1256| 0| for (const ShapeGeometry *shapeGeometry : shapeGeometries) { ------------------ | Branch (1256:53): [True: 0, False: 0] ------------------ 1257| 0| const auto &curNormals = shapeGeometry->GetNormals(); 1258| 0| aiAnimMesh *animMesh = aiCreateAnimMesh(out_mesh, true, !curNormals.empty()); 1259| 0| const auto &curVertices = shapeGeometry->GetVertices(); 1260| 0| const auto &curIndices = shapeGeometry->GetIndices(); 1261| | //losing channel name if using shapeGeometry->Name() 1262| | // if blendShapeChannel Name is empty or doesn't have a ".", add geoMetryName; 1263| 0| auto aniName = FixAnimMeshName(blendShapeChannel->Name()); 1264| 0| auto geoMetryName = FixAnimMeshName(shapeGeometry->Name()); 1265| 0| if (aniName.empty()) { ------------------ | Branch (1265:21): [True: 0, False: 0] ------------------ 1266| 0| aniName = geoMetryName; 1267| 0| } 1268| 0| else if (aniName.find('.') == aniName.npos) { ------------------ | Branch (1268:26): [True: 0, False: 0] ------------------ 1269| 0| aniName += "." + geoMetryName; 1270| 0| } 1271| 0| animMesh->mName.Set(aniName); 1272| 0| for (size_t j = 0; j < curIndices.size(); j++) { ------------------ | Branch (1272:36): [True: 0, False: 0] ------------------ 1273| 0| const unsigned int curIndex = curIndices.at(j); 1274| 0| aiVector3D vertex = curVertices.at(j); 1275| 0| aiVector3D normal = curNormals.empty() ? aiVector3D() : curNormals.at(j); ------------------ | Branch (1275:41): [True: 0, False: 0] ------------------ 1276| 0| unsigned int count = 0; 1277| 0| const unsigned int *outIndices = mesh.ToOutputVertexIndex(curIndex, count); 1278| 0| for (unsigned int k = 0; k < count; k++) { ------------------ | Branch (1278:46): [True: 0, False: 0] ------------------ 1279| 0| unsigned int index = outIndices[k]; 1280| 0| animMesh->mVertices[index] += vertex; 1281| 0| if (animMesh->mNormals != nullptr) { ------------------ | Branch (1281:29): [True: 0, False: 0] ------------------ 1282| 0| animMesh->mNormals[index] += normal; 1283| 0| animMesh->mNormals[index].NormalizeSafe(); 1284| 0| } 1285| 0| } 1286| 0| } 1287| 0| animMesh->mWeight = shapeGeometries.size() > 1 ? blendShapeChannel->DeformPercent() / 100.0f : 1.0f; ------------------ | Branch (1287:37): [True: 0, False: 0] ------------------ 1288| 0| animMeshes.push_back(animMesh); 1289| 0| } 1290| 0| } 1291| 0| } 1292| 95| const size_t numAnimMeshes = animMeshes.size(); 1293| 95| if (numAnimMeshes > 0) { ------------------ | Branch (1293:9): [True: 0, False: 95] ------------------ 1294| 0| out_mesh->mNumAnimMeshes = static_cast(numAnimMeshes); 1295| 0| out_mesh->mAnimMeshes = new aiAnimMesh *[numAnimMeshes]; 1296| 0| for (size_t i = 0; i < numAnimMeshes; i++) { ------------------ | Branch (1296:28): [True: 0, False: 0] ------------------ 1297| 0| out_mesh->mAnimMeshes[i] = animMeshes.at(i); 1298| 0| } 1299| 0| } 1300| 95| return static_cast(mMeshes.size() - 1); 1301| 95|} _ZN6Assimp3FBX12FBXConverter14ConvertWeightsEP6aiMeshRKNS0_12MeshGeometryERK12aiMatrix4x4tIfEP6aiNodejPNSt3__16vectorIjNSD_9allocatorIjEEEE: 1571| 84| std::vector *outputVertStartIndices) { 1572| 84| ai_assert(geo.DeformerSkin()); 1573| | 1574| 84| std::vector out_indices, index_out_indices, count_out_indices; 1575| | 1576| 84| const Skin &sk = *geo.DeformerSkin(); 1577| | 1578| 84| std::vector bones; 1579| 84| const bool no_mat_check = materialIndex == NO_MATERIAL_SEPARATION; 1580| 84| ai_assert(no_mat_check || outputVertStartIndices); 1581| | 1582| 84| try { 1583| | // iterate over the sub deformers 1584| 699| for (const Cluster *cluster : sk.Clusters()) { ------------------ | Branch (1584:37): [True: 699, False: 84] ------------------ 1585| 699| ai_assert(cluster); 1586| | 1587| 699| const WeightIndexArray &indices = cluster->GetIndices(); 1588| | 1589| 699| const MatIndexArray &mats = geo.GetMaterialIndices(); 1590| | 1591| 699| const size_t no_index_sentinel = std::numeric_limits::max(); 1592| | 1593| 699| count_out_indices.clear(); 1594| 699| index_out_indices.clear(); 1595| 699| out_indices.clear(); 1596| | 1597| | // now check if *any* of these weights is contained in the output mesh, 1598| | // taking notes so we don't need to do it twice. 1599| 243k| for (WeightIndexArray::value_type index : indices) { ------------------ | Branch (1599:53): [True: 243k, False: 699] ------------------ 1600| | 1601| 243k| unsigned int count = 0; 1602| 243k| const unsigned int *const out_idx = geo.ToOutputVertexIndex(index, count); 1603| | // ToOutputVertexIndex only returns nullptr if index is out of bounds 1604| | // which should never happen 1605| 243k| ai_assert(out_idx != nullptr); 1606| | 1607| 243k| index_out_indices.push_back(no_index_sentinel); 1608| 243k| count_out_indices.push_back(0); 1609| | 1610| 1.21M| for (unsigned int i = 0; i < count; ++i) { ------------------ | Branch (1610:42): [True: 974k, False: 243k] ------------------ 1611| 974k| if (no_mat_check || static_cast(mats[geo.FaceForVertexIndex(out_idx[i])]) == materialIndex) { ------------------ | Branch (1611:25): [True: 974k, False: 0] | Branch (1611:41): [True: 0, False: 0] ------------------ 1612| | 1613| 974k| if (index_out_indices.back() == no_index_sentinel) { ------------------ | Branch (1613:29): [True: 243k, False: 730k] ------------------ 1614| 243k| index_out_indices.back() = out_indices.size(); 1615| 243k| } 1616| | 1617| 974k| if (no_mat_check) { ------------------ | Branch (1617:29): [True: 974k, False: 0] ------------------ 1618| 974k| out_indices.push_back(out_idx[i]); 1619| 974k| } else { 1620| | // this extra lookup is in O(logn), so the entire algorithm becomes O(nlogn) 1621| 0| const std::vector::iterator it = std::lower_bound( 1622| 0| outputVertStartIndices->begin(), 1623| 0| outputVertStartIndices->end(), 1624| 0| out_idx[i]); 1625| | 1626| 0| out_indices.push_back(std::distance(outputVertStartIndices->begin(), it)); 1627| 0| } 1628| | 1629| 974k| ++count_out_indices.back(); 1630| 974k| } 1631| 974k| } 1632| 243k| } 1633| | 1634| | // if we found at least one, generate the output bones 1635| | // XXX this could be heavily simplified by collecting the bone 1636| | // data in a single step. 1637| 699| ConvertCluster(bones, cluster, out_indices, index_out_indices, 1638| 699| count_out_indices, absolute_transform, parent); 1639| 699| } 1640| | 1641| 84| bone_map.clear(); 1642| 84| } catch (std::exception &) { 1643| 0| std::for_each(bones.begin(), bones.end(), Util::delete_fun()); 1644| 0| throw; 1645| 0| } 1646| | 1647| 84| if (bones.empty()) { ------------------ | Branch (1647:9): [True: 1, False: 83] ------------------ 1648| 1| out->mBones = nullptr; 1649| 1| out->mNumBones = 0; 1650| 1| return; 1651| 1| } 1652| | 1653| 83| out->mBones = new aiBone *[bones.size()](); 1654| 83| out->mNumBones = static_cast(bones.size()); 1655| 83| std::swap_ranges(bones.begin(), bones.end(), out->mBones); 1656| 83|} _ZN6Assimp3FBX12FBXConverter14ConvertClusterERNSt3__16vectorIP6aiBoneNS2_9allocatorIS5_EEEEPKNS0_7ClusterERNS3_ImNS6_ImEEEESF_SF_RK12aiMatrix4x4tIfEP6aiNode: 1661| 699| aiNode *) { 1662| 699| ai_assert(cluster != nullptr); // make sure cluster valid 1663| | 1664| 699| std::string deformer_name = cluster->TargetNode()->Name(); 1665| 699| aiString bone_name = aiString(FixNodeName(deformer_name)); 1666| | 1667| 699| aiBone *bone = nullptr; 1668| | 1669| 699| if (bone_map.count(deformer_name)) { ------------------ | Branch (1669:9): [True: 0, False: 699] ------------------ 1670| 0| ASSIMP_LOG_VERBOSE_DEBUG("retrieved bone from lookup ", bone_name.C_Str(), ". Deformer:", deformer_name); 1671| 0| bone = bone_map[deformer_name]; 1672| 699| } else { 1673| 699| ASSIMP_LOG_VERBOSE_DEBUG("created new bone ", bone_name.C_Str(), ". Deformer: ", deformer_name); 1674| 699| bone = new aiBone(); 1675| 699| bone->mName = bone_name; 1676| | 1677| | //bone->mOffsetMatrix = cluster->Transform(); 1678| | // store local transform link for post processing 1679| | 1680| 699| bone->mOffsetMatrix = cluster->TransformLink(); 1681| 699| bone->mOffsetMatrix.Inverse(); 1682| | 1683| 699| const aiMatrix4x4 matrix = (aiMatrix4x4)absolute_transform; 1684| | 1685| 699| bone->mOffsetMatrix = bone->mOffsetMatrix * matrix; // * mesh_offset 1686| | 1687| | // 1688| | // Now calculate the aiVertexWeights 1689| | // 1690| | 1691| 699| aiVertexWeight *cursor = nullptr; 1692| | 1693| 699| bone->mNumWeights = static_cast(out_indices.size()); 1694| 699| cursor = bone->mWeights = new aiVertexWeight[out_indices.size()]; 1695| | 1696| 699| const size_t no_index_sentinel = std::numeric_limits::max(); 1697| 699| const WeightArray &weights = cluster->GetWeights(); 1698| | 1699| 699| const size_t c = index_out_indices.size(); 1700| 244k| for (size_t i = 0; i < c; ++i) { ------------------ | Branch (1700:28): [True: 243k, False: 699] ------------------ 1701| 243k| const size_t index_index = index_out_indices[i]; 1702| | 1703| 243k| if (index_index == no_index_sentinel) { ------------------ | Branch (1703:17): [True: 0, False: 243k] ------------------ 1704| 0| continue; 1705| 0| } 1706| | 1707| 243k| const size_t cc = count_out_indices[i]; 1708| 1.21M| for (size_t j = 0; j < cc; ++j) { ------------------ | Branch (1708:32): [True: 974k, False: 243k] ------------------ 1709| | // cursor runs from first element relative to the start 1710| | // or relative to the start of the next indexes. 1711| 974k| aiVertexWeight &out_weight = *cursor++; 1712| | 1713| 974k| out_weight.mVertexId = static_cast(out_indices[index_index + j]); 1714| 974k| out_weight.mWeight = weights[i]; 1715| 974k| } 1716| 243k| } 1717| | 1718| 699| bone_map.insert(std::pair(deformer_name, bone)); 1719| 699| } 1720| | 1721| 699| ASSIMP_LOG_DEBUG("bone research: Indices size: ", out_indices.size()); 1722| | 1723| | // lookup must be populated in case something goes wrong 1724| | // this also allocates bones to mesh instance outside 1725| 699| local_mesh_bones.push_back(bone); 1726| 699|} _ZN6Assimp3FBX12FBXConverter22ConvertMaterialForMeshEP6aiMeshRKNS0_5ModelERKNS0_12MeshGeometryEi: 1729| 89| MatIndexArray::value_type materialIndex) { 1730| | // locate source materials for this mesh 1731| 89| const std::vector &mats = model.GetMaterials(); 1732| 89| if (static_cast(materialIndex) >= mats.size() || materialIndex < 0) { ------------------ | Branch (1732:9): [True: 2, False: 87] | Branch (1732:68): [True: 0, False: 87] ------------------ 1733| 2| FBXImporter::LogError("material index out of bounds, setting default material"); 1734| 2| out->mMaterialIndex = GetDefaultMaterial(); 1735| 2| return; 1736| 2| } 1737| | 1738| 87| const Material *const mat = mats[materialIndex]; 1739| 87| MaterialMap::const_iterator it = materials_converted.find(mat); 1740| 87| if (it != materials_converted.end()) { ------------------ | Branch (1740:9): [True: 1, False: 86] ------------------ 1741| 1| out->mMaterialIndex = (*it).second; 1742| 1| return; 1743| 1| } 1744| | 1745| 86| out->mMaterialIndex = ConvertMaterial(*mat, &geo); 1746| 86| materials_converted[mat] = out->mMaterialIndex; 1747| 86|} _ZN6Assimp3FBX12FBXConverter18GetDefaultMaterialEv: 1749| 8|unsigned int FBXConverter::GetDefaultMaterial() { 1750| 8| if (defaultMaterialIndex) { ------------------ | Branch (1750:9): [True: 1, False: 7] ------------------ 1751| 1| return defaultMaterialIndex - 1; 1752| 1| } 1753| | 1754| 7| aiMaterial *out_mat = new aiMaterial(); 1755| 7| materials.push_back(out_mat); 1756| | 1757| 7| const aiColor3D diffuse = aiColor3D(0.8f, 0.8f, 0.8f); 1758| 7| out_mat->AddProperty(&diffuse, 1, AI_MATKEY_COLOR_DIFFUSE); 1759| | 1760| 7| aiString s; 1761| 7| s.Set(AI_DEFAULT_MATERIAL_NAME); 1762| | 1763| 7| out_mat->AddProperty(&s, AI_MATKEY_NAME); 1764| | 1765| 7| defaultMaterialIndex = static_cast(materials.size()); 1766| 7| return defaultMaterialIndex - 1; 1767| 8|} _ZN6Assimp3FBX12FBXConverter15ConvertMaterialERKNS0_8MaterialEPKNS0_12MeshGeometryE: 1769| 86|unsigned int FBXConverter::ConvertMaterial(const Material &material, const MeshGeometry *const mesh) { 1770| 86| const PropertyTable &props = material.Props(); 1771| | 1772| | // generate empty output material 1773| 86| aiMaterial *out_mat = new aiMaterial(); 1774| 86| materials_converted[&material] = static_cast(materials.size()); 1775| | 1776| 86| materials.push_back(out_mat); 1777| | 1778| 86| aiString str; 1779| | 1780| | // strip Material:: prefix 1781| 86| std::string name = material.Name(); 1782| 86| if (name.substr(0, 10) == "Material::") { ------------------ | Branch (1782:9): [True: 86, False: 0] ------------------ 1783| 86| name = name.substr(10); 1784| 86| } 1785| | 1786| | // set material name if not empty - this could happen 1787| | // and there should be no key for it in this case. 1788| 86| if (name.length()) { ------------------ | Branch (1788:9): [True: 86, False: 0] ------------------ 1789| 86| str.Set(name); 1790| 86| out_mat->AddProperty(&str, AI_MATKEY_NAME); 1791| 86| } 1792| | 1793| | // Set the shading mode as best we can: The FBX specification only mentions Lambert and Phong, and only Phong is mentioned in Assimp's aiShadingMode enum. 1794| 86| if (material.GetShadingModel() == "phong") { ------------------ | Branch (1794:9): [True: 85, False: 1] ------------------ 1795| 85| aiShadingMode shadingMode = aiShadingMode_Phong; 1796| 85| out_mat->AddProperty(&shadingMode, 1, AI_MATKEY_SHADING_MODEL); 1797| 85| } 1798| | 1799| | // shading stuff and colors 1800| 86| SetShadingPropertiesCommon(out_mat, props); 1801| 86| SetShadingPropertiesRaw(out_mat, props, material.Textures(), mesh); 1802| | 1803| | // texture assignments 1804| 86| SetTextureProperties(out_mat, material.Textures(), mesh); 1805| 86| SetTextureProperties(out_mat, material.LayeredTextures(), mesh); 1806| | 1807| 86| return static_cast(materials.size() - 1); 1808| 86|} _ZN6Assimp3FBX12FBXConverter12ConvertVideoERKNS0_5VideoE: 1810| 1|unsigned int FBXConverter::ConvertVideo(const Video &video) { 1811| | // generate empty output texture 1812| 1| aiTexture *out_tex = new aiTexture(); 1813| 1| textures.push_back(out_tex); 1814| | 1815| | // assuming the texture is compressed 1816| 1| out_tex->mWidth = static_cast(video.ContentLength()); // total data size 1817| 1| out_tex->mHeight = 0; // fixed to 0 1818| | 1819| | // steal the data from the Video to avoid an additional copy 1820| 1| out_tex->pcData = reinterpret_cast(const_cast