_ZN6Assimp19Discreet3DSImporterC2Ev: 104| 402| mStream(nullptr), mLastNodeIndex(), mCurrentNode(), mRootNode(), mScene(), mMasterScale(), bHasBG(), bIsPrj() { 105| | // empty 106| 402|} _ZNK6Assimp19Discreet3DSImporter7GetInfoEv: 117| 402|const aiImporterDesc *Discreet3DSImporter::GetInfo() const { 118| 402| return &desc; 119| 402|} _ZN6Assimp19Discreet3DSImporterD2Ev: 65| 402| ~Discreet3DSImporter() override = default; _ZNK6Assimp12D3MFImporter7GetInfoEv: 101| 402|const aiImporterDesc *D3MFImporter::GetInfo() const { 102| 402| return &desc; 103| 402|} _ZN6Assimp12D3MFImporterC2Ev: 59| 402| D3MFImporter() = default; _ZN6Assimp12AC3DImporterC2Ev: 161| 402| mBuffer(), 162| | configSplitBFCull(), 163| | configEvalSubdivision(), 164| | mNumMeshes(), 165| | mLights(), 166| 402| mLightsCounter(0), 167| 402| mGroupsCounter(0), 168| 402| mPolysCounter(0), 169| 402| mWorldsCounter(0) { 170| | // nothing to be done here 171| 402|} _ZNK6Assimp12AC3DImporter7GetInfoEv: 182| 402|const aiImporterDesc *AC3DImporter::GetInfo() const { 183| 402| return &desc; 184| 402|} _ZN6Assimp11AMFImporter5ClearEv: 69| 402|void AMFImporter::Clear() { 70| 402| mNodeElement_Cur = nullptr; 71| 402| mUnit.clear(); 72| 402| mMaterial_Converted.clear(); 73| 402| mTexture_Converted.clear(); 74| | // Delete all elements 75| 402| if (!mNodeElement_List.empty()) { ------------------ | Branch (75:9): [True: 0, False: 402] ------------------ 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| 402|} _ZN6Assimp11AMFImporterC2Ev: 85| 402| mNodeElement_Cur(nullptr), 86| 402| mXmlParser(nullptr) { 87| | // empty 88| 402|} _ZN6Assimp11AMFImporterD2Ev: 90| 402|AMFImporter::~AMFImporter() { 91| 402| delete mXmlParser; 92| | // Clear() is accounting if data already is deleted. So, just check again if all data is deleted. 93| 402| Clear(); 94| 402|} _ZNK6Assimp11AMFImporter7GetInfoEv: 487| 402|const aiImporterDesc *AMFImporter::GetInfo() const { 488| 402| return &Description; 489| 402|} _ZN6Assimp11ASEImporterC2Ev: 85| 402| mParser(), mBuffer(), pcScene(), configRecomputeNormals(), noSkeletonMesh() { 86| | // empty 87| 402|} _ZNK6Assimp11ASEImporter7GetInfoEv: 98| 402|const aiImporterDesc *ASEImporter::GetInfo() const { 99| 402| return &desc; 100| 402|} _ZNK6Assimp14AssbinImporter7GetInfoEv: 82| 402|const aiImporterDesc *AssbinImporter::GetInfo() const { 83| 402| return &desc; 84| 402|} _ZN6Assimp11B3DImporterD2Ev: 91| 402|B3DImporter::~B3DImporter() = default; _ZNK6Assimp11B3DImporter7GetInfoEv: 110| 402|const aiImporterDesc *B3DImporter::GetInfo() const { 111| 402| return &desc; 112| 402|} _ZN6Assimp11B3DImporterC2Ev: 66| 402| B3DImporter() = default; _ZN6Assimp9BVHLoaderC2Ev: 86| 402| noSkeletonMesh() { 87| | // empty 88| 402|} _ZNK6Assimp9BVHLoader7GetInfoEv: 104| 402|const aiImporterDesc *BVHLoader::GetInfo() const { 105| 402| return &desc; 106| 402|} _ZN6Assimp9BVHLoaderD2Ev: 88| 402| ~BVHLoader() override = default; _ZN6Assimp7Blender25CustomDataTypeDescriptionC2EPFbPNS0_8ElemBaseEmRKNS0_12FileDatabaseEEPFS3_mEPFvS3_E: 77| 84| Read(read), Create(create), Destroy(destroy) {} _ZN6Assimp7Blender9TempArrayINSt3__16vectorENS0_15BlenderModifierEEC2Ev: 67| 402| TempArray() = default; _ZN6Assimp7Blender9TempArrayINSt3__16vectorENS0_15BlenderModifierEED2Ev: 69| 402| ~TempArray () { 70| 402| for(T* elem : arr) { ------------------ | Branch (70:25): [True: 0, False: 402] ------------------ 71| 0| delete elem; 72| 0| } 73| 402| } _ZN6Assimp15BlenderImporterC2Ev: 101| 402| modifier_cache(new BlenderModifierShowcase()) { 102| | // empty 103| 402|} _ZN6Assimp15BlenderImporterD2Ev: 107| 402|BlenderImporter::~BlenderImporter() { 108| 402| delete modifier_cache; 109| 402|} _ZNK6Assimp15BlenderImporter7GetInfoEv: 121| 402|const aiImporterDesc *BlenderImporter::GetInfo() const { 122| 402| return &blenderDesc; 123| 402|} _ZNK6Assimp11COBImporter7GetInfoEv: 102| 402|const aiImporterDesc *COBImporter::GetInfo() const { 103| 402| return &desc; 104| 402|} _ZN6Assimp11COBImporterC2Ev: 77| 402| COBImporter() = default; _ZN6Assimp11CSMImporterC2Ev: 76| 402|CSMImporter::CSMImporter() : noSkeletonMesh() { 77| | // empty 78| 402|} _ZNK6Assimp11CSMImporter7GetInfoEv: 89| 402|const aiImporterDesc* CSMImporter::GetInfo () const { 90| 402| return &desc; 91| 402|} _ZN6Assimp13ColladaLoaderC2Ev: 103| 402| noSkeletonMesh(false), 104| 402| removeEmptyBones(false), 105| 402| ignoreUpDirection(false), 106| 402| ignoreUnitSize(false), 107| 402| useColladaName(false), 108| 402| mNodeNameCounter(0) { 109| | // empty 110| 402|} _ZNK6Assimp13ColladaLoader7GetInfoEv: 136| 402|const aiImporterDesc *ColladaLoader::GetInfo() const { 137| 402| return &desc; 138| 402|} _ZN6Assimp13ColladaLoaderD2Ev: 91| 402| ~ColladaLoader() override = default; _ZNK6Assimp11DXFImporter7GetInfoEv: 363| 402|const aiImporterDesc* DXFImporter::GetInfo () const { 364| 402| return &desc; 365| 402|} _ZN6Assimp11DXFImporterC2Ev: 71| 402| DXFImporter() = default; _ZN6Assimp3FBX14AnimationCurveC2EmRKNS0_7ElementERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERKNS0_8DocumentE: 61| 26.6k| Object(id, element, name) { 62| 26.6k| const Scope &sc = GetRequiredScope(element); 63| 26.6k| const Element &KeyTime = GetRequiredElement(sc, "KeyTime"); 64| 26.6k| const Element &KeyValueFloat = GetRequiredElement(sc, "KeyValueFloat"); 65| | 66| 26.6k| ParseVectorDataArray(keys, KeyTime); 67| 26.6k| ParseVectorDataArray(values, KeyValueFloat); 68| | 69| 26.6k| if (keys.size() != values.size()) { ------------------ | Branch (69:9): [True: 0, False: 26.6k] ------------------ 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| 26.6k| if (!std::equal(keys.begin(), keys.end() - 1, keys.begin() + 1, std::less())) { ------------------ | Branch (74:9): [True: 172, False: 26.4k] ------------------ 75| 172| DOMError("the keyframes are not in ascending order", &KeyTime); 76| 172| } 77| | 78| 26.4k| const Element *KeyAttrDataFloat = sc["KeyAttrDataFloat"]; 79| 26.4k| if (KeyAttrDataFloat) { ------------------ | Branch (79:9): [True: 26.2k, False: 237] ------------------ 80| 26.2k| ParseVectorDataArray(attributes, *KeyAttrDataFloat); 81| 26.2k| } 82| | 83| 26.4k| const Element *KeyAttrFlags = sc["KeyAttrFlags"]; 84| 26.4k| if (KeyAttrFlags) { ------------------ | Branch (84:9): [True: 26.2k, False: 247] ------------------ 85| 26.2k| ParseVectorDataArray(flags, *KeyAttrFlags); 86| 26.2k| } 87| 26.4k|} _ZN6Assimp3FBX18AnimationCurveNodeC2EmRKNS0_7ElementERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERKNS0_8DocumentEPKPKcm: 93| 10.0k| Object(id, element, name), target(), doc(doc) { 94| 10.0k| const Scope &sc = GetRequiredScope(element); 95| | 96| | // find target node 97| 10.0k| const char *whitelist[] = { "Model", "NodeAttribute", "Deformer" }; 98| 10.0k| const std::vector &conns = doc.GetConnectionsBySourceSequenced(ID(), whitelist, 3); 99| | 100| 10.0k| for (const Connection *con : conns) { ------------------ | Branch (100:32): [True: 9.49k, False: 548] ------------------ 101| | 102| | // link should go for a property 103| 9.49k| if (!con->PropertyName().length()) { ------------------ | Branch (103:13): [True: 12, False: 9.47k] ------------------ 104| 12| continue; 105| 12| } 106| | 107| 9.47k| if (target_prop_whitelist) { ------------------ | Branch (107:13): [True: 0, False: 9.47k] ------------------ 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| 9.47k| const Object *const ob = con->DestinationObject(); 123| 9.47k| if (!ob) { ------------------ | Branch (123:13): [True: 15, False: 9.46k] ------------------ 124| 15| DOMWarning("failed to read destination object for AnimationCurveNode->Model link, ignoring", &element); 125| 15| continue; 126| 15| } 127| | 128| 9.46k| target = ob; 129| 9.46k| if (!target) { ------------------ | Branch (129:13): [True: 0, False: 9.46k] ------------------ 130| 0| continue; 131| 0| } 132| | 133| 9.46k| prop = con->PropertyName(); 134| 9.46k| break; 135| 9.46k| } 136| | 137| 10.0k| if (!target) { ------------------ | Branch (137:9): [True: 548, False: 9.46k] ------------------ 138| 548| DOMWarning("failed to resolve target Model/NodeAttribute/Constraint for AnimationCurveNode", &element); 139| 548| } 140| | 141| 10.0k| props = GetPropertyTable(doc, "AnimationCurveNode.FbxAnimCurveNode", element, sc, false); 142| 10.0k|} _ZNK6Assimp3FBX18AnimationCurveNode6CurvesEv: 145| 26.7k|const AnimationCurveMap &AnimationCurveNode::Curves() const { 146| 26.7k| if (!curves.empty()) { ------------------ | Branch (146:9): [True: 17.6k, False: 9.03k] ------------------ 147| 17.6k| return curves; 148| 17.6k| } 149| | 150| | // resolve attached animation curves 151| 9.03k| const std::vector &conns = doc.GetConnectionsByDestinationSequenced(ID(), "AnimationCurve"); 152| | 153| 26.6k| for (const Connection *con : conns) { ------------------ | Branch (153:32): [True: 26.6k, False: 9.03k] ------------------ 154| | 155| | // link should go for a property 156| 26.6k| if (!con->PropertyName().length()) { ------------------ | Branch (156:13): [True: 6, False: 26.6k] ------------------ 157| 6| continue; 158| 6| } 159| | 160| 26.6k| const Object *const ob = con->SourceObject(); 161| 26.6k| if (nullptr == ob) { ------------------ | Branch (161:13): [True: 358, False: 26.2k] ------------------ 162| 358| DOMWarning("failed to read source object for AnimationCurve->AnimationCurveNode link, ignoring", &element); 163| 358| continue; 164| 358| } 165| | 166| 26.2k| const AnimationCurve *const anim = dynamic_cast(ob); 167| 26.2k| if (nullptr == anim) { ------------------ | Branch (167:13): [True: 0, False: 26.2k] ------------------ 168| 0| DOMWarning("source object for ->AnimationCurveNode link is not an AnimationCurve", &element); 169| 0| continue; 170| 0| } 171| | 172| 26.2k| curves[con->PropertyName()] = anim; 173| 26.2k| } 174| | 175| 9.03k| return curves; 176| 26.7k|} _ZN6Assimp3FBX14AnimationLayerC2EmRKNS0_7ElementERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERKNS0_8DocumentE: 180| 231| Object(id, element, name), doc(doc) { 181| 231| const Scope &sc = GetRequiredScope(element); 182| | 183| | // note: the props table here bears little importance and is usually absent 184| 231| props = GetPropertyTable(doc, "AnimationLayer.FbxAnimLayer", element, sc, true); 185| 231|} _ZNK6Assimp3FBX14AnimationLayer5NodesEPKPKcm: 189| 231| size_t whitelist_size /*= 0*/) const { 190| 231| AnimationCurveNodeList nodes; 191| | 192| | // resolve attached animation nodes 193| 231| const std::vector &conns = doc.GetConnectionsByDestinationSequenced(ID(), "AnimationCurveNode"); 194| 231| nodes.reserve(conns.size()); 195| | 196| 10.0k| for (const Connection *con : conns) { ------------------ | Branch (196:32): [True: 10.0k, False: 231] ------------------ 197| | 198| | // link should not go to a property 199| 10.0k| if (con->PropertyName().length()) { ------------------ | Branch (199:13): [True: 0, False: 10.0k] ------------------ 200| 0| continue; 201| 0| } 202| | 203| 10.0k| const Object *const ob = con->SourceObject(); 204| 10.0k| if (!ob) { ------------------ | Branch (204:13): [True: 0, False: 10.0k] ------------------ 205| 0| DOMWarning("failed to read source object for AnimationCurveNode->AnimationLayer link, ignoring", &element); 206| 0| continue; 207| 0| } 208| | 209| 10.0k| const AnimationCurveNode *const anim = dynamic_cast(ob); 210| 10.0k| if (!anim) { ------------------ | Branch (210:13): [True: 0, False: 10.0k] ------------------ 211| 0| DOMWarning("source object for ->AnimationLayer link is not an AnimationCurveNode", &element); 212| 0| continue; 213| 0| } 214| | 215| 10.0k| if (target_prop_whitelist) { ------------------ | Branch (215:13): [True: 10.0k, False: 4] ------------------ 216| 10.0k| const char *s = anim->TargetProperty().c_str(); 217| 10.0k| bool ok = false; 218| 22.3k| for (size_t i = 0; i < whitelist_size; ++i) { ------------------ | Branch (218:32): [True: 21.5k, False: 805] ------------------ 219| 21.5k| if (!strcmp(s, target_prop_whitelist[i])) { ------------------ | Branch (219:21): [True: 9.20k, False: 12.3k] ------------------ 220| 9.20k| ok = true; 221| 9.20k| break; 222| 9.20k| } 223| 21.5k| } 224| 10.0k| if (!ok) { ------------------ | Branch (224:17): [True: 805, False: 9.20k] ------------------ 225| 805| continue; 226| 805| } 227| 10.0k| } 228| 9.21k| nodes.push_back(anim); 229| 9.21k| } 230| | 231| 231| return nodes; // pray for NRVO 232| 231|} _ZN6Assimp3FBX14AnimationStackC2EmRKNS0_7ElementERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERKNS0_8DocumentE: 236| 247| Object(id, element, name) { 237| 247| 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| 247| props = GetPropertyTable(doc, "AnimationStack.FbxAnimStack", element, sc, true); 241| | 242| | // resolve attached animation layers 243| 247| const std::vector &conns = doc.GetConnectionsByDestinationSequenced(ID(), "AnimationLayer"); 244| 247| layers.reserve(conns.size()); 245| | 246| 247| for (const Connection *con : conns) { ------------------ | Branch (246:32): [True: 231, False: 247] ------------------ 247| | 248| | // link should not go to a property 249| 231| if (con->PropertyName().length()) { ------------------ | Branch (249:13): [True: 0, False: 231] ------------------ 250| 0| continue; 251| 0| } 252| | 253| 231| const Object *const ob = con->SourceObject(); 254| 231| if (!ob) { ------------------ | Branch (254:13): [True: 0, False: 231] ------------------ 255| 0| DOMWarning("failed to read source object for AnimationLayer->AnimationStack link, ignoring", &element); 256| 0| continue; 257| 0| } 258| | 259| 231| const AnimationLayer *const anim = dynamic_cast(ob); 260| 231| if (!anim) { ------------------ | Branch (260:13): [True: 0, False: 231] ------------------ 261| 0| DOMWarning("source object for ->AnimationStack link is not an AnimationLayer", &element); 262| 0| continue; 263| 0| } 264| 231| layers.push_back(anim); 265| 231| } 266| 247|} _ZN6Assimp3FBX5TokenC2EPKcS3_NS0_9TokenTypeEm: 67| 3.67M| sbegin(sbegin), 68| 3.67M| send(send), 69| 3.67M| type(type), 70| 3.67M| line(offset), 71| 3.67M| column(BINARY_MARKER) { 72| 3.67M| ai_assert(sbegin); ------------------ | | 67| 3.67M|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 3.67M, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 73| 3.67M| ai_assert(send); ------------------ | | 67| 3.67M|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 3.67M, 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.67M| ai_assert(send >= sbegin); ------------------ | | 67| 3.67M|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 3.67M, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 78| 3.67M|} _ZN6Assimp3FBX14TokenizeBinaryERNSt3__16vectorIPKNS0_5TokenENS1_9allocatorIS5_EEEEPKcmRNS_14StackAllocatorE: 394| 325|void TokenizeBinary(TokenList &output_tokens, const char *input, size_t length, StackAllocator &token_allocator) { 395| 325| ai_assert(input); ------------------ | | 67| 325|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 325, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 396| 325| ASSIMP_LOG_DEBUG("Tokenizing binary FBX file"); 397| | 398| 325| if(length < 0x1b) { ------------------ | Branch (398:8): [True: 0, False: 325] ------------------ 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| 325| if (strncmp(input,"Kaydara FBX Binary",18)) { ------------------ | Branch (410:9): [True: 0, False: 325] ------------------ 411| 0| TokenizeError("magic bytes not found",0); 412| 0| } 413| | 414| 325| const char* cursor = input + 18; 415| 325| /*Result ignored*/ ReadByte(input, cursor, input + length); 416| 325| /*Result ignored*/ ReadByte(input, cursor, input + length); 417| 325| /*Result ignored*/ ReadByte(input, cursor, input + length); 418| 325| /*Result ignored*/ ReadByte(input, cursor, input + length); 419| 325| /*Result ignored*/ ReadByte(input, cursor, input + length); 420| 325| const uint32_t version = ReadWord(input, cursor, input + length); 421| 325| ASSIMP_LOG_DEBUG("FBX version: ", version); 422| 325| const bool is64bits = version >= 7500; 423| 325| const char *end = input + length; 424| 325| try 425| 325| { 426| 3.83k| while (cursor < end ) { ------------------ | Branch (426:16): [True: 3.81k, False: 16] ------------------ 427| 3.81k| if (!ReadScope(output_tokens, token_allocator, input, cursor, input + length, is64bits)) { ------------------ | Branch (427:17): [True: 309, False: 3.50k] ------------------ 428| 309| break; 429| 309| } 430| 3.81k| } 431| 325| } 432| 325| catch (const DeadlyImportError& e) 433| 325| { 434| 16| if (!is64bits && (length > std::numeric_limits::max())) { ------------------ | Branch (434:13): [True: 15, False: 1] | Branch (434:26): [True: 0, False: 15] ------------------ 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| 16| throw; 438| 16| } 439| 325|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_113TokenizeErrorERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEm: 87| 16|{ 88| 16| throw DeadlyImportError("FBX-Tokenize", Util::GetOffsetText(offset), message); 89| 16|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_18ReadByteEPKcRS3_S3_: 140| 711k|uint8_t ReadByte(const char* input, const char*& cursor, const char* end) { 141| 711k| if(Offset(cursor, end) < sizeof( uint8_t ) ) { ------------------ | Branch (141:8): [True: 0, False: 711k] ------------------ 142| 0| TokenizeError("cannot ReadByte, out of bounds",input, cursor); 143| 0| } 144| | 145| 711k| uint8_t word;/* = *reinterpret_cast< const uint8_t* >( cursor )*/ 146| 711k| ::memcpy( &word, cursor, sizeof( uint8_t ) ); 147| 711k| ++cursor; 148| | 149| 711k| return word; 150| 711k|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_16OffsetEPKcS3_: 93| 17.5M|size_t Offset(const char* begin, const char* cursor) { 94| 17.5M| if (begin > cursor) { ------------------ | Branch (94:9): [True: 0, False: 17.5M] ------------------ 95| 0| return 0; 96| 0| } 97| | 98| 17.5M| return cursor - begin; 99| 17.5M|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_113TokenizeErrorERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKcSC_: 103| 16|void TokenizeError(const std::string& message, const char* begin, const char* cursor) { 104| 16| TokenizeError(message, Offset(begin, cursor)); 105| 16|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_18ReadWordEPKcRS3_S3_: 108| 3.65M|uint32_t ReadWord(const char* input, const char*& cursor, const char* end) { 109| 3.65M| const size_t k_to_read = sizeof( uint32_t ); 110| 3.65M| if(Offset(cursor, end) < k_to_read ) { ------------------ | Branch (110:8): [True: 0, False: 3.65M] ------------------ 111| 0| TokenizeError("cannot ReadWord, out of bounds",input, cursor); 112| 0| } 113| | 114| 3.65M| uint32_t word; 115| 3.65M| ::memcpy(&word, cursor, 4); 116| 3.65M| AI_SWAP4(word); 117| | 118| 3.65M| cursor += k_to_read; 119| | 120| 3.65M| return word; 121| 3.65M|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_19ReadScopeERNSt3__16vectorIPKNS0_5TokenENS2_9allocatorIS6_EEEERNS_14StackAllocatorEPKcRSE_SE_b: 305| 710k|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| 710k| const uint64_t end_offset = is64bits ? ReadDoubleWord(input, cursor, end) : ReadWord(input, cursor, end); ------------------ | Branch (307:30): [True: 1, False: 710k] ------------------ 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| 710k| if(!end_offset) { ------------------ | Branch (313:8): [True: 309, False: 709k] ------------------ 314| 309| return false; 315| 309| } 316| | 317| 709k| if(end_offset > Offset(input, end)) { ------------------ | Branch (317:8): [True: 4, False: 709k] ------------------ 318| 4| TokenizeError("block offset is out of range",input, cursor); 319| 4| } 320| 709k| else if(end_offset < Offset(input, cursor)) { ------------------ | Branch (320:13): [True: 0, False: 709k] ------------------ 321| 0| TokenizeError("block offset is negative out of range",input, cursor); 322| 0| } 323| | 324| | // the second data word contains the number of properties in the scope 325| 709k| const uint64_t prop_count = is64bits ? ReadDoubleWord(input, cursor, end) : ReadWord(input, cursor, end); ------------------ | Branch (325:30): [True: 0, False: 709k] ------------------ 326| | 327| | // the third data word contains the length of the property list 328| 709k| const uint64_t prop_length = is64bits ? ReadDoubleWord(input, cursor, end) : ReadWord(input, cursor, end); ------------------ | Branch (328:31): [True: 0, False: 709k] ------------------ 329| | 330| | // now comes the name of the scope/key 331| 709k| const char* sbeg, *send; 332| 709k| ReadString(sbeg, send, input, cursor, end); 333| | 334| 709k| output_tokens.push_back(new_Token(sbeg, send, TokenType_KEY, Offset(input, cursor) )); ------------------ | | 160| 1.41M|#define new_Token new (token_allocator.Allocate(sizeof(Token))) Token ------------------ 335| | 336| | // now come the individual properties 337| 709k| const char* begin_cursor = cursor; 338| | 339| 709k| if ((begin_cursor + prop_length) > end) { ------------------ | Branch (339:9): [True: 0, False: 709k] ------------------ 340| 0| TokenizeError("property length out of bounds reading length ", input, cursor); 341| 0| } 342| | 343| 2.41M| for (unsigned int i = 0; i < prop_count; ++i) { ------------------ | Branch (343:30): [True: 1.70M, False: 709k] ------------------ 344| 1.70M| ReadData(sbeg, send, input, cursor, begin_cursor + prop_length); 345| | 346| 1.70M| output_tokens.push_back(new_Token(sbeg, send, TokenType_DATA, Offset(input, cursor) )); ------------------ | | 160| 3.41M|#define new_Token new (token_allocator.Allocate(sizeof(Token))) Token ------------------ 347| | 348| 1.70M| if(i != prop_count-1) { ------------------ | Branch (348:12): [True: 1.03M, False: 669k] ------------------ 349| 1.03M| output_tokens.push_back(new_Token(cursor, cursor + 1, TokenType_COMMA, Offset(input, cursor) )); ------------------ | | 160| 2.07M|#define new_Token new (token_allocator.Allocate(sizeof(Token))) Token ------------------ 350| 1.03M| } 351| 1.70M| } 352| | 353| 709k| if (Offset(begin_cursor, cursor) != prop_length) { ------------------ | Branch (353:9): [True: 1, False: 709k] ------------------ 354| 1| TokenizeError("property length not reached, something is wrong",input, cursor); 355| 1| } 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| 709k| const size_t sentinel_block_length = is64bits ? (sizeof(uint64_t)* 3 + 1) : (sizeof(uint32_t)* 3 + 1); ------------------ | Branch (360:39): [True: 0, False: 709k] ------------------ 361| | 362| 709k| if (Offset(input, cursor) < end_offset) { ------------------ | Branch (362:9): [True: 113k, False: 596k] ------------------ 363| 113k| if (end_offset - Offset(input, cursor) < sentinel_block_length) { ------------------ | Branch (363:13): [True: 0, False: 113k] ------------------ 364| 0| TokenizeError("insufficient padding bytes at block end",input, cursor); 365| 0| } 366| | 367| 113k| output_tokens.push_back(new_Token(cursor, cursor + 1, TokenType_OPEN_BRACKET, Offset(input, cursor) )); ------------------ | | 160| 227k|#define new_Token new (token_allocator.Allocate(sizeof(Token))) Token ------------------ 368| | 369| | // XXX this is vulnerable to stack overflowing .. 370| 819k| while(Offset(input, cursor) < end_offset - sentinel_block_length) { ------------------ | Branch (370:15): [True: 706k, False: 113k] ------------------ 371| 706k| ReadScope(output_tokens, token_allocator, input, cursor, input + end_offset - sentinel_block_length, is64bits); 372| 706k| } 373| 113k| output_tokens.push_back(new_Token(cursor, cursor + 1, TokenType_CLOSE_BRACKET, Offset(input, cursor) )); ------------------ | | 160| 227k|#define new_Token new (token_allocator.Allocate(sizeof(Token))) Token ------------------ 374| | 375| 1.59M| for (unsigned int i = 0; i < sentinel_block_length; ++i) { ------------------ | Branch (375:34): [True: 1.47M, False: 113k] ------------------ 376| 1.47M| if(cursor[i] != '\0') { ------------------ | Branch (376:16): [True: 2, False: 1.47M] ------------------ 377| 2| TokenizeError("failed to read nested block sentinel, expected all bytes to be 0",input, cursor); 378| 2| } 379| 1.47M| } 380| 113k| cursor += sentinel_block_length; 381| 113k| } 382| | 383| 709k| if (Offset(input, cursor) != end_offset) { ------------------ | Branch (383:9): [True: 0, False: 709k] ------------------ 384| 0| TokenizeError("scope length not reached, something is wrong",input, cursor); 385| 0| } 386| | 387| 709k| return true; 388| 709k|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_114ReadDoubleWordEPKcRS3_S3_: 124| 1|uint64_t ReadDoubleWord(const char* input, const char*& cursor, const char* end) { 125| 1| const size_t k_to_read = sizeof(uint64_t); 126| 1| if(Offset(cursor, end) < k_to_read) { ------------------ | Branch (126:8): [True: 0, False: 1] ------------------ 127| 0| TokenizeError("cannot ReadDoubleWord, out of bounds",input, cursor); 128| 0| } 129| | 130| 1| uint64_t dword /*= *reinterpret_cast(cursor)*/; 131| 1| ::memcpy( &dword, cursor, sizeof( uint64_t ) ); 132| 1| AI_SWAP8(dword); 133| | 134| 1| cursor += k_to_read; 135| | 136| 1| return dword; 137| 1|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_110ReadStringERPKcS4_S3_S4_S3_bb: 154| 1.65M| const char*& cursor, const char* end, bool long_length = false, bool allow_null = false) { 155| 1.65M| const uint32_t len_len = long_length ? 4 : 1; ------------------ | Branch (155:30): [True: 945k, False: 709k] ------------------ 156| 1.65M| if(Offset(cursor, end) < len_len) { ------------------ | Branch (156:8): [True: 0, False: 1.65M] ------------------ 157| 0| TokenizeError("cannot ReadString, out of bounds reading length",input, cursor); 158| 0| } 159| | 160| 1.65M| const uint32_t length = long_length ? ReadWord(input, cursor, end) : ReadByte(input, cursor, end); ------------------ | Branch (160:29): [True: 945k, False: 709k] ------------------ 161| | 162| 1.65M| if (Offset(cursor, end) < length) { ------------------ | Branch (162:9): [True: 1, False: 1.65M] ------------------ 163| 1| TokenizeError("cannot ReadString, length is out of bounds",input, cursor); 164| 1| } 165| | 166| 1.65M| sbegin_out = cursor; 167| 1.65M| cursor += length; 168| | 169| 1.65M| send_out = cursor; 170| | 171| 1.65M| if(!allow_null) { ------------------ | Branch (171:8): [True: 709k, False: 945k] ------------------ 172| 6.04M| for (unsigned int i = 0; i < length; ++i) { ------------------ | Branch (172:34): [True: 5.33M, False: 709k] ------------------ 173| 5.33M| if(sbegin_out[i] == '\0') { ------------------ | Branch (173:16): [True: 3, False: 5.33M] ------------------ 174| 3| TokenizeError("failed ReadString, unexpected NUL character in string",input, cursor); 175| 3| } 176| 5.33M| } 177| 709k| } 178| | 179| 1.65M| return length; 180| 1.65M|} FBXBinaryTokenizer.cpp:_ZN6Assimp3FBX12_GLOBAL__N_18ReadDataERPKcS4_S3_S4_S3_: 183| 1.70M|void ReadData(const char*& sbegin_out, const char*& send_out, const char* input, const char*& cursor, const char* end) { 184| 1.70M| if(Offset(cursor, end) < 1) { ------------------ | Branch (184:8): [True: 1, False: 1.70M] ------------------ 185| 1| TokenizeError("cannot ReadData, out of bounds reading length",input, cursor); 186| 1| } 187| | 188| 1.70M| const char type = *cursor; 189| 1.70M| sbegin_out = cursor++; 190| | 191| 1.70M| switch(type) 192| 1.70M| { 193| | // 16 bit int 194| 0| case 'Y': ------------------ | Branch (194:5): [True: 0, False: 1.70M] ------------------ 195| 0| cursor += 2; 196| 0| break; 197| | 198| | // 1 bit bool flag (yes/no) 199| 6.37k| case 'C': ------------------ | Branch (199:5): [True: 6.37k, False: 1.69M] ------------------ 200| 6.37k| cursor += 1; 201| 6.37k| break; 202| | 203| | // 32 bit int 204| 136k| case 'I': ------------------ | Branch (204:5): [True: 136k, False: 1.56M] ------------------ 205| | // <- fall through 206| | 207| | // float 208| 136k| case 'F': ------------------ | Branch (208:5): [True: 0, False: 1.70M] ------------------ 209| 136k| cursor += 4; 210| 136k| break; 211| | 212| | // double 213| 206k| case 'D': ------------------ | Branch (213:5): [True: 206k, False: 1.49M] ------------------ 214| 206k| cursor += 8; 215| 206k| break; 216| | 217| | // 64 bit int 218| 218k| case 'L': ------------------ | Branch (218:5): [True: 218k, False: 1.48M] ------------------ 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| 333| case 'R': ------------------ | Branch (225:5): [True: 333, False: 1.70M] ------------------ 226| 333| { 227| 333| const uint32_t length = ReadWord(input, cursor, end); 228| 333| cursor += length; 229| 333| break; 230| 136k| } 231| | 232| 18| case 'b': ------------------ | Branch (232:5): [True: 18, False: 1.70M] ------------------ 233| | // TODO: what is the 'b' type code? Right now we just skip over it / 234| | // take the full range we could get 235| 18| cursor = end; 236| 18| break; 237| | 238| | // array of * 239| 63.6k| case 'f': ------------------ | Branch (239:5): [True: 63.6k, False: 1.64M] ------------------ 240| 85.8k| case 'd': ------------------ | Branch (240:5): [True: 22.1k, False: 1.68M] ------------------ 241| 117k| case 'l': ------------------ | Branch (241:5): [True: 31.8k, False: 1.67M] ------------------ 242| 191k| case 'i': ------------------ | Branch (242:5): [True: 73.9k, False: 1.63M] ------------------ 243| 191k| case 'c': { ------------------ | Branch (243:5): [True: 1, False: 1.70M] ------------------ 244| 191k| const uint32_t length = ReadWord(input, cursor, end); 245| 191k| const uint32_t encoding = ReadWord(input, cursor, end); 246| | 247| 191k| const uint32_t comp_len = ReadWord(input, cursor, end); 248| | 249| | // compute length based on type and check against the stored value 250| 191k| if(encoding == 0) { ------------------ | Branch (250:12): [True: 174k, False: 16.9k] ------------------ 251| 174k| uint32_t stride = 0; 252| 174k| switch(type) 253| 174k| { 254| 63.6k| case 'f': ------------------ | Branch (254:13): [True: 63.6k, False: 110k] ------------------ 255| 129k| case 'i': ------------------ | Branch (255:13): [True: 65.4k, False: 109k] ------------------ 256| 129k| stride = 4; 257| 129k| break; 258| | 259| 13.6k| case 'd': ------------------ | Branch (259:13): [True: 13.6k, False: 160k] ------------------ 260| 45.5k| case 'l': ------------------ | Branch (260:13): [True: 31.8k, False: 142k] ------------------ 261| 45.5k| stride = 8; 262| 45.5k| break; 263| | 264| 0| case 'c': ------------------ | Branch (264:13): [True: 0, False: 174k] ------------------ 265| 0| stride = 1; 266| 0| break; 267| | 268| 0| default: ------------------ | Branch (268:13): [True: 0, False: 174k] ------------------ 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| 174k| }; 271| 174k| ai_assert(stride > 0); ------------------ | | 67| 174k|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 174k, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 272| 174k| if(length * stride != comp_len) { ------------------ | Branch (272:16): [True: 0, False: 174k] ------------------ 273| 0| TokenizeError("cannot ReadData, calculated data stride differs from what the file claims",input, cursor); 274| 0| } 275| 174k| } 276| | // zip/deflate algorithm (encoding==1)? take given length. anything else? die 277| 16.9k| else if (encoding != 1) { ------------------ | Branch (277:18): [True: 0, False: 16.9k] ------------------ 278| 0| TokenizeError("cannot ReadData, unknown encoding",input, cursor); 279| 0| } 280| 191k| cursor += comp_len; 281| 191k| break; 282| 191k| } 283| | 284| | // string 285| 945k| case 'S': { ------------------ | Branch (285:5): [True: 945k, False: 759k] ------------------ 286| 945k| const char* sb, *se; 287| | // 0 characters can legally happen in such strings 288| 945k| ReadString(sb, se, input, cursor, end, true, true); 289| 945k| break; 290| 191k| } 291| 4| default: ------------------ | Branch (291:5): [True: 4, False: 1.70M] ------------------ 292| 4| TokenizeError("cannot ReadData, unexpected type code: " + std::string(&type, 1),input, cursor); 293| 1.70M| } 294| | 295| 1.70M| if(cursor > end) { ------------------ | Branch (295:8): [True: 0, False: 1.70M] ------------------ 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.70M| send_out = cursor; 301| 1.70M|} _ZN6Assimp3FBX12FBXConverterC2EP7aiSceneRKNS0_8DocumentEb: 128| 355| mMeshes(), 129| 355| lights(), 130| 355| cameras(), 131| 355| textures(), 132| 355| materials_converted(), 133| 355| textures_converted(), 134| 355| meshes_converted(), 135| 355| node_anim_chain_bits(), 136| 355| mNodeNames(), 137| | anim_fps(), 138| 355| mSceneOut(out), 139| 355| doc(doc), 140| 355| 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| 355| 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| 355| if (doc.Settings().readTextures) { ------------------ | Branch (151:9): [True: 344, False: 11] ------------------ 152| 344| ConvertOrphanedEmbeddedTextures(); 153| 344| } 154| 355| ConvertRootNode(); 155| | 156| 355| if (doc.Settings().readAllMaterials) { ------------------ | Branch (156:9): [True: 0, False: 355] ------------------ 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| 355| ConvertGlobalSettings(); 176| 355| 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| 355| if (out->mNumMeshes == 0) { ------------------ | Branch (181:9): [True: 178, False: 177] ------------------ 182| 178| out->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; 183| 178| } else { 184| | // Apply the FBX axis metadata unless requested not to 185| 177| if (!doc.Settings().ignoreUpDirection) ------------------ | Branch (185:13): [True: 159, False: 18] ------------------ 186| 159| correctRootTransform(mSceneOut); 187| 177| } 188| 355|} _ZN6Assimp3FBX12FBXConverterD2Ev: 190| 337|FBXConverter::~FBXConverter() { 191| 337| std::for_each(mMeshes.begin(), mMeshes.end(), Util::delete_fun()); 192| 337| std::for_each(materials.begin(), materials.end(), Util::delete_fun()); 193| 337| std::for_each(animations.begin(), animations.end(), Util::delete_fun()); 194| 337| std::for_each(lights.begin(), lights.end(), Util::delete_fun()); 195| 337| std::for_each(cameras.begin(), cameras.end(), Util::delete_fun()); 196| 337| std::for_each(textures.begin(), textures.end(), Util::delete_fun()); 197| 337|} _ZN6Assimp3FBX12FBXConverter15ConvertRootNodeEv: 199| 344|void FBXConverter::ConvertRootNode() { 200| 344| mSceneOut->mRootNode = new aiNode(); 201| 344| std::string unique_name; 202| 344| GetUniqueName("RootNode", unique_name); 203| 344| mSceneOut->mRootNode->mName.Set(unique_name); 204| | 205| | // root has ID 0 206| 344| ConvertNodes(0L, mSceneOut->mRootNode, mSceneOut->mRootNode); 207| 344|} _ZN6Assimp3FBX12FBXConverter12ConvertNodesEmP6aiNodeS3_RK12aiMatrix4x4tIfE: 250| 5.25k|void FBXConverter::ConvertNodes(uint64_t id, aiNode *parent, aiNode *root_node, const aiMatrix4x4& parent_transform) { 251| 5.25k| const std::vector &conns = doc.GetConnectionsByDestinationSequenced(id, "Model"); 252| | 253| 5.25k| std::vector nodes; 254| 5.25k| nodes.reserve(conns.size()); 255| | 256| 5.25k| std::vector nodes_chain; 257| 5.25k| std::vector post_nodes_chain; 258| | 259| 5.25k| for (const Connection *con : conns) { ------------------ | Branch (259:32): [True: 4.92k, False: 5.25k] ------------------ 260| | // ignore object-property links 261| 4.92k| if (con->PropertyName().length()) { ------------------ | Branch (261:13): [True: 0, False: 4.92k] ------------------ 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| 4.92k| const Object *const object = con->SourceObject(); 269| 4.92k| if (nullptr == object) { ------------------ | Branch (269:13): [True: 9, False: 4.91k] ------------------ 270| 9| FBXImporter::LogError("failed to convert source object for Model link"); 271| 9| continue; 272| 9| } 273| | 274| | // FBX Model::Cube, Model::Bone001, etc elements 275| | // This detects if we can cast the object into this model structure. 276| 4.91k| const Model *const model = dynamic_cast(object); 277| | 278| 4.91k| if (nullptr != model) { ------------------ | Branch (278:13): [True: 4.91k, False: 0] ------------------ 279| 4.91k| nodes_chain.clear(); 280| 4.91k| post_nodes_chain.clear(); 281| 4.91k| aiMatrix4x4 new_abs_transform = parent_transform; 282| 4.91k| 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| 4.91k| 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| 4.91k| ai_assert(nodes_chain.size()); 294| | 295| 4.91k| if (need_additional_node) { ------------------ | Branch (295:17): [True: 416, False: 4.49k] ------------------ 296| 416| nodes_chain.emplace_back(node_name); 297| 416| } 298| | 299| | //setup metadata on newest node 300| 4.91k| SetupNodeMetadata(*model, *nodes_chain.back().mNode); 301| | 302| | // link all nodes in a row 303| 4.91k| aiNode *last_parent = parent; 304| 6.51k| for (PotentialNode& child : nodes_chain) { ------------------ | Branch (304:39): [True: 6.51k, False: 4.91k] ------------------ 305| 6.51k| ai_assert(child.mNode); 306| | 307| 6.51k| if (last_parent != parent) { ------------------ | Branch (307:21): [True: 1.60k, False: 4.90k] ------------------ 308| 1.60k| last_parent->mNumChildren = 1; 309| 1.60k| last_parent->mChildren = new aiNode *[1]; 310| 1.60k| last_parent->mChildren[0] = child.mOwnership.release(); 311| 1.60k| } 312| | 313| 6.51k| child->mParent = last_parent; 314| 6.51k| last_parent = child.mNode; 315| | 316| 6.51k| new_abs_transform *= child->mTransformation; 317| 6.51k| } 318| | 319| | // attach geometry 320| 4.91k| ConvertModel(*model, nodes_chain.back().mNode, root_node, new_abs_transform); 321| | 322| | // check if there will be any child nodes 323| 4.91k| 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| 4.91k| if (child_conns.size()) { ------------------ | Branch (327:17): [True: 2.23k, False: 2.68k] ------------------ 328| 2.23k| for (PotentialNode& postnode : post_nodes_chain) { ------------------ | Branch (328:46): [True: 184, False: 2.23k] ------------------ 329| 184| ai_assert(postnode.mNode); 330| | 331| 184| if (last_parent != parent) { ------------------ | Branch (331:25): [True: 184, False: 0] ------------------ 332| 184| last_parent->mNumChildren = 1; 333| 184| last_parent->mChildren = new aiNode *[1]; 334| 184| last_parent->mChildren[0] = postnode.mOwnership.release(); 335| 184| } 336| | 337| 184| postnode->mParent = last_parent; 338| 184| last_parent = postnode.mNode; 339| | 340| 184| new_abs_transform *= postnode->mTransformation; 341| 184| } 342| 2.68k| } else { 343| | // free the nodes we allocated as we don't need them 344| 2.68k| post_nodes_chain.clear(); 345| 2.68k| } 346| | 347| | // recursion call - child nodes 348| 4.91k| ConvertNodes(model->ID(), last_parent, root_node, new_abs_transform); 349| | 350| 4.91k| if (doc.Settings().readLights) { ------------------ | Branch (350:17): [True: 4.89k, False: 21] ------------------ 351| 4.89k| ConvertLights(*model, node_name); 352| 4.89k| } 353| | 354| 4.91k| if (doc.Settings().readCameras) { ------------------ | Branch (354:17): [True: 4.89k, False: 22] ------------------ 355| 4.89k| ConvertCameras(*model, node_name); 356| 4.89k| } 357| | 358| 4.91k| nodes.push_back(std::move(nodes_chain.front())); 359| 4.91k| nodes_chain.clear(); 360| 4.91k| } 361| 4.91k| } 362| | 363| 5.25k| if (nodes.empty()) { ------------------ | Branch (363:9): [True: 2.68k, False: 2.57k] ------------------ 364| 2.68k| parent->mNumChildren = 0; 365| 2.68k| parent->mChildren = nullptr; 366| 2.68k| } else { 367| 2.57k| parent->mChildren = new aiNode *[nodes.size()](); 368| 2.57k| parent->mNumChildren = static_cast(nodes.size()); 369| 7.41k| for (unsigned int i = 0; i < nodes.size(); ++i) { ------------------ | Branch (369:34): [True: 4.84k, False: 2.57k] ------------------ 370| 4.84k| parent->mChildren[i] = nodes[i].mOwnership.release(); 371| 4.84k| } 372| 2.57k| } 373| 5.25k|} _ZN6Assimp3FBX12FBXConverter13ConvertLightsERKNS0_5ModelERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 375| 4.89k|void FBXConverter::ConvertLights(const Model &model, const std::string &orig_name) { 376| 4.89k| const std::vector &node_attrs = model.GetAttributes(); 377| 4.89k| for (const NodeAttribute *attr : node_attrs) { ------------------ | Branch (377:36): [True: 3.05k, False: 4.89k] ------------------ 378| 3.05k| const Light *const light = dynamic_cast(attr); 379| 3.05k| if (light) { ------------------ | Branch (379:13): [True: 277, False: 2.77k] ------------------ 380| 277| ConvertLight(*light, orig_name); 381| 277| } 382| 3.05k| } 383| 4.89k|} _ZN6Assimp3FBX12FBXConverter14ConvertCamerasERKNS0_5ModelERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 385| 4.89k|void FBXConverter::ConvertCameras(const Model &model, const std::string &orig_name) { 386| 4.89k| const std::vector &node_attrs = model.GetAttributes(); 387| 4.89k| for (const NodeAttribute *attr : node_attrs) { ------------------ | Branch (387:36): [True: 3.05k, False: 4.89k] ------------------ 388| 3.05k| const Camera *const cam = dynamic_cast(attr); 389| 3.05k| if (cam) { ------------------ | Branch (389:13): [True: 290, False: 2.76k] ------------------ 390| 290| ConvertCamera(*cam, orig_name); 391| 290| } 392| 3.05k| } 393| 4.89k|} _ZN6Assimp3FBX12FBXConverter12ConvertLightERKNS0_5LightERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 395| 277|void FBXConverter::ConvertLight(const Light &light, const std::string &orig_name) { 396| 277| lights.push_back(new aiLight()); 397| 277| aiLight *const out_light = lights.back(); 398| | 399| 277| out_light->mName.Set(orig_name); 400| | 401| 277| const float intensity = light.Intensity() / 100.0f; 402| 277| const aiVector3D &col = light.Color(); 403| | 404| 277| out_light->mColorDiffuse = aiColor3D(col.x, col.y, col.z); 405| 277| out_light->mColorDiffuse.r *= intensity; 406| 277| out_light->mColorDiffuse.g *= intensity; 407| 277| out_light->mColorDiffuse.b *= intensity; 408| | 409| 277| out_light->mColorSpecular = out_light->mColorDiffuse; 410| | 411| | //lights are defined along negative y direction 412| 277| out_light->mPosition = aiVector3D(0.0f); 413| 277| out_light->mDirection = aiVector3D(0.0f, -1.0f, 0.0f); 414| 277| out_light->mUp = aiVector3D(0.0f, 0.0f, -1.0f); 415| | 416| 277| switch (light.LightType()) { 417| 276| case Light::Type_Point: ------------------ | Branch (417:9): [True: 276, False: 1] ------------------ 418| 276| out_light->mType = aiLightSource_POINT; 419| 276| break; 420| | 421| 0| case Light::Type_Directional: ------------------ | Branch (421:9): [True: 0, False: 277] ------------------ 422| 0| out_light->mType = aiLightSource_DIRECTIONAL; 423| 0| break; 424| | 425| 0| case Light::Type_Spot: ------------------ | Branch (425:9): [True: 0, False: 277] ------------------ 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: 277] ------------------ 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: 277] ------------------ 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: 277] ------------------ 441| 0| FBXImporter::LogError("Not handled light type: ", light.LightType()); 442| 0| break; 443| 277| } 444| | 445| 276| float decay = light.DecayStart(); 446| 276| switch (light.DecayType()) { 447| 0| case Light::Decay_None: ------------------ | Branch (447:9): [True: 0, False: 276] ------------------ 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: 276] ------------------ 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| 276| case Light::Decay_Quadratic: ------------------ | Branch (457:9): [True: 276, False: 0] ------------------ 458| 276| out_light->mAttenuationConstant = 0.0f; 459| 276| out_light->mAttenuationLinear = 0.0f; 460| 276| out_light->mAttenuationQuadratic = 2.0f / (decay * decay); 461| 276| break; 462| 0| case Light::Decay_Cubic: ------------------ | Branch (462:9): [True: 0, False: 276] ------------------ 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: 276] ------------------ 467| 0| FBXImporter::LogError("Not handled light decay type: ", light.DecayType()); 468| 0| break; 469| 276| } 470| 276|} _ZN6Assimp3FBX12FBXConverter13ConvertCameraERKNS0_6CameraERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 472| 290|void FBXConverter::ConvertCamera(const Camera &cam, const std::string &orig_name) { 473| 290| cameras.push_back(new aiCamera()); 474| 290| aiCamera *const out_camera = cameras.back(); 475| | 476| 290| out_camera->mName.Set(orig_name); 477| | 478| 290| 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| 290| out_camera->mPosition = aiVector3D(0.0f); 483| 290| out_camera->mLookAt = aiVector3D(1.0f, 0.0f, 0.0f); 484| 290| 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| 290| float fov_deg = cam.FieldOfView(); 494| | // If FOV not specified in file, compute using FilmWidth and FocalLength. 495| 290| if (fov_deg == kFovUnknown) { ------------------ | Branch (495:9): [True: 0, False: 290] ------------------ 496| 0| float film_width_inches = cam.FilmWidth(); 497| 0| float focal_length_mm = cam.FocalLength(); 498| 0| ASSIMP_LOG_VERBOSE_DEBUG("FBX FOV unspecified. Computing from FilmWidth (", film_width_inches, "inches) and FocalLength (", focal_length_mm, "mm)."); 499| 0| double half_fov_rad = std::atan2(film_width_inches * 25.4 * 0.5, focal_length_mm); 500| 0| out_camera->mHorizontalFOV = static_cast(half_fov_rad); 501| 290| } else { 502| | // FBX fov is full-view degrees. We want half-view radians. 503| 290| out_camera->mHorizontalFOV = AI_DEG_TO_RAD(fov_deg) * 0.5f; 504| 290| } 505| | 506| 290| out_camera->mClipPlaneNear = cam.NearPlane(); 507| 290| out_camera->mClipPlaneFar = cam.FarPlane(); 508| 290|} _ZN6Assimp3FBX12FBXConverter13GetUniqueNameERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERS8_: 510| 344|void FBXConverter::GetUniqueName(const std::string &name, std::string &uniqueName) { 511| 344| uniqueName = name; 512| 344| auto it_pair = mNodeNames.insert({ name, 0 }); // duplicate node name instance count 513| 344| unsigned int &i = it_pair.first->second; 514| 344| while (!it_pair.second) { ------------------ | Branch (514:12): [True: 0, False: 344] ------------------ 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| 344|} _ZN6Assimp3FBX12FBXConverter22NameTransformationCompENS1_18TransformationCompE: 523| 3.08k|const char *FBXConverter::NameTransformationComp(TransformationComp comp) { 524| 3.08k| switch (comp) { 525| 801| case TransformationComp_Translation: ------------------ | Branch (525:9): [True: 801, False: 2.28k] ------------------ 526| 801| return "Translation"; 527| 58| case TransformationComp_RotationOffset: ------------------ | Branch (527:9): [True: 58, False: 3.03k] ------------------ 528| 58| return "RotationOffset"; 529| 50| case TransformationComp_RotationPivot: ------------------ | Branch (529:9): [True: 50, False: 3.03k] ------------------ 530| 50| return "RotationPivot"; 531| 5| case TransformationComp_PreRotation: ------------------ | Branch (531:9): [True: 5, False: 3.08k] ------------------ 532| 5| return "PreRotation"; 533| 768| case TransformationComp_Rotation: ------------------ | Branch (533:9): [True: 768, False: 2.32k] ------------------ 534| 768| return "Rotation"; 535| 42| case TransformationComp_PostRotation: ------------------ | Branch (535:9): [True: 42, False: 3.04k] ------------------ 536| 42| return "PostRotation"; 537| 50| case TransformationComp_RotationPivotInverse: ------------------ | Branch (537:9): [True: 50, False: 3.03k] ------------------ 538| 50| return "RotationPivotInverse"; 539| 0| case TransformationComp_ScalingOffset: ------------------ | Branch (539:9): [True: 0, False: 3.08k] ------------------ 540| 0| return "ScalingOffset"; 541| 0| case TransformationComp_ScalingPivot: ------------------ | Branch (541:9): [True: 0, False: 3.08k] ------------------ 542| 0| return "ScalingPivot"; 543| 739| case TransformationComp_Scaling: ------------------ | Branch (543:9): [True: 739, False: 2.35k] ------------------ 544| 739| return "Scaling"; 545| 0| case TransformationComp_ScalingPivotInverse: ------------------ | Branch (545:9): [True: 0, False: 3.08k] ------------------ 546| 0| return "ScalingPivotInverse"; 547| 278| case TransformationComp_GeometricScaling: ------------------ | Branch (547:9): [True: 278, False: 2.81k] ------------------ 548| 278| return "GeometricScaling"; 549| 20| case TransformationComp_GeometricRotation: ------------------ | Branch (549:9): [True: 20, False: 3.06k] ------------------ 550| 20| return "GeometricRotation"; 551| 0| case TransformationComp_GeometricTranslation: ------------------ | Branch (551:9): [True: 0, False: 3.08k] ------------------ 552| 0| return "GeometricTranslation"; 553| 258| case TransformationComp_GeometricScalingInverse: ------------------ | Branch (553:9): [True: 258, False: 2.83k] ------------------ 554| 258| return "GeometricScalingInverse"; 555| 20| case TransformationComp_GeometricRotationInverse: ------------------ | Branch (555:9): [True: 20, False: 3.06k] ------------------ 556| 20| return "GeometricRotationInverse"; 557| 0| case TransformationComp_GeometricTranslationInverse: ------------------ | Branch (557:9): [True: 0, False: 3.08k] ------------------ 558| 0| return "GeometricTranslationInverse"; 559| 0| case TransformationComp_MAXIMUM: // this is to silence compiler warnings ------------------ | Branch (559:9): [True: 0, False: 3.08k] ------------------ 560| 0| default: ------------------ | Branch (560:9): [True: 0, False: 3.08k] ------------------ 561| 0| break; 562| 3.08k| } 563| | 564| 3.08k| ai_assert(false); 565| | 566| 0| return nullptr; 567| 3.08k|} _ZN6Assimp3FBX12FBXConverter30NameTransformationCompPropertyENS1_18TransformationCompE: 569| 87.5k|const char *FBXConverter::NameTransformationCompProperty(TransformationComp comp) { 570| 87.5k| switch (comp) { ------------------ | Branch (570:13): [True: 87.5k, False: 0] ------------------ 571| 3.07k| case TransformationComp_Translation: ------------------ | Branch (571:9): [True: 3.07k, False: 84.4k] ------------------ 572| 3.07k| return "Lcl Translation"; 573| 6.15k| case TransformationComp_RotationOffset: ------------------ | Branch (573:9): [True: 6.15k, False: 81.3k] ------------------ 574| 6.15k| return "RotationOffset"; 575| 6.07k| case TransformationComp_RotationPivot: ------------------ | Branch (575:9): [True: 6.07k, False: 81.4k] ------------------ 576| 6.07k| return "RotationPivot"; 577| 5.99k| case TransformationComp_PreRotation: ------------------ | Branch (577:9): [True: 5.99k, False: 81.5k] ------------------ 578| 5.99k| return "PreRotation"; 579| 3.07k| case TransformationComp_Rotation: ------------------ | Branch (579:9): [True: 3.07k, False: 84.4k] ------------------ 580| 3.07k| return "Lcl Rotation"; 581| 5.99k| case TransformationComp_PostRotation: ------------------ | Branch (581:9): [True: 5.99k, False: 81.5k] ------------------ 582| 5.99k| return "PostRotation"; 583| 2.88k| case TransformationComp_RotationPivotInverse: ------------------ | Branch (583:9): [True: 2.88k, False: 84.6k] ------------------ 584| 2.88k| return "RotationPivotInverse"; 585| 5.96k| case TransformationComp_ScalingOffset: ------------------ | Branch (585:9): [True: 5.96k, False: 81.5k] ------------------ 586| 5.96k| return "ScalingOffset"; 587| 5.96k| case TransformationComp_ScalingPivot: ------------------ | Branch (587:9): [True: 5.96k, False: 81.5k] ------------------ 588| 5.96k| return "ScalingPivot"; 589| 3.07k| case TransformationComp_Scaling: ------------------ | Branch (589:9): [True: 3.07k, False: 84.4k] ------------------ 590| 3.07k| return "Lcl Scaling"; 591| 2.88k| case TransformationComp_ScalingPivotInverse: ------------------ | Branch (591:9): [True: 2.88k, False: 84.6k] ------------------ 592| 2.88k| return "ScalingPivotInverse"; 593| 5.94k| case TransformationComp_GeometricScaling: ------------------ | Branch (593:9): [True: 5.94k, False: 81.5k] ------------------ 594| 5.94k| return "GeometricScaling"; 595| 5.96k| case TransformationComp_GeometricRotation: ------------------ | Branch (595:9): [True: 5.96k, False: 81.5k] ------------------ 596| 5.96k| return "GeometricRotation"; 597| 5.96k| case TransformationComp_GeometricTranslation: ------------------ | Branch (597:9): [True: 5.96k, False: 81.5k] ------------------ 598| 5.96k| return "GeometricTranslation"; 599| 6.15k| case TransformationComp_GeometricScalingInverse: ------------------ | Branch (599:9): [True: 6.15k, False: 81.3k] ------------------ 600| 6.15k| return "GeometricScalingInverse"; 601| 6.15k| case TransformationComp_GeometricRotationInverse: ------------------ | Branch (601:9): [True: 6.15k, False: 81.3k] ------------------ 602| 6.15k| return "GeometricRotationInverse"; 603| 6.15k| case TransformationComp_GeometricTranslationInverse: ------------------ | Branch (603:9): [True: 6.15k, False: 81.3k] ------------------ 604| 6.15k| return "GeometricTranslationInverse"; 605| 0| case TransformationComp_MAXIMUM: ------------------ | Branch (605:9): [True: 0, False: 87.5k] ------------------ 606| 0| break; 607| 87.5k| } 608| | 609| 87.5k| ai_assert(false); 610| | 611| 0| return nullptr; 612| 87.5k|} _ZN6Assimp3FBX12FBXConverter17GetRotationMatrixENS0_5Model8RotOrderERK10aiVector3tIfER12aiMatrix4x4tIfE: 620| 4.38M|void FBXConverter::GetRotationMatrix(Model::RotOrder mode, const aiVector3D &rotation, aiMatrix4x4 &out) { 621| 4.38M| if (mode == Model::RotOrder_SphericXYZ) { ------------------ | Branch (621:9): [True: 0, False: 4.38M] ------------------ 622| 0| FBXImporter::LogError("Unsupported RotationMode: SphericXYZ"); 623| 0| out = aiMatrix4x4(); 624| 0| return; 625| 0| } 626| | 627| 4.38M| const float angle_epsilon = Math::getEpsilon(); 628| | 629| 4.38M| out = aiMatrix4x4(); 630| | 631| 4.38M| bool is_id[3] = { true, true, true }; 632| | 633| 4.38M| aiMatrix4x4 temp[3]; 634| 4.38M| const auto rot = AI_DEG_TO_RAD(rotation); 635| 4.38M| if (std::fabs(rot.z) > angle_epsilon) { ------------------ | Branch (635:9): [True: 782k, False: 3.59M] ------------------ 636| 782k| aiMatrix4x4::RotationZ(rot.z, temp[2]); 637| 782k| is_id[2] = false; 638| 782k| } 639| 4.38M| if (std::fabs(rot.y) > angle_epsilon) { ------------------ | Branch (639:9): [True: 782k, False: 3.59M] ------------------ 640| 782k| aiMatrix4x4::RotationY(rot.y, temp[1]); 641| 782k| is_id[1] = false; 642| 782k| } 643| 4.38M| if (std::fabs(rot.x) > angle_epsilon) { ------------------ | Branch (643:9): [True: 4.21M, False: 164k] ------------------ 644| 4.21M| aiMatrix4x4::RotationX(rot.x, temp[0]); 645| 4.21M| is_id[0] = false; 646| 4.21M| } 647| | 648| 4.38M| 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.38M| switch (mode) { 652| 4.38M| case Model::RotOrder_EulerXYZ: ------------------ | Branch (652:9): [True: 4.38M, False: 0] ------------------ 653| 4.38M| order[0] = 2; 654| 4.38M| order[1] = 1; 655| 4.38M| order[2] = 0; 656| 4.38M| break; 657| | 658| 0| case Model::RotOrder_EulerXZY: ------------------ | Branch (658:9): [True: 0, False: 4.38M] ------------------ 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.38M] ------------------ 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.38M] ------------------ 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.38M] ------------------ 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.38M] ------------------ 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.38M] ------------------ 689| 0| ai_assert(false); 690| 0| break; 691| 4.38M| } 692| | 693| 4.38M| ai_assert(order[0] >= 0); 694| 4.38M| ai_assert(order[0] <= 2); 695| 4.38M| ai_assert(order[1] >= 0); 696| 4.38M| ai_assert(order[1] <= 2); 697| 4.38M| ai_assert(order[2] >= 0); 698| 4.38M| ai_assert(order[2] <= 2); 699| | 700| 4.38M| if (!is_id[order[0]]) { ------------------ | Branch (700:9): [True: 782k, False: 3.59M] ------------------ 701| 782k| out = temp[order[0]]; 702| 782k| } 703| | 704| 4.38M| if (!is_id[order[1]]) { ------------------ | Branch (704:9): [True: 782k, False: 3.59M] ------------------ 705| 782k| out = out * temp[order[1]]; 706| 782k| } 707| | 708| 4.38M| if (!is_id[order[2]]) { ------------------ | Branch (708:9): [True: 4.21M, False: 164k] ------------------ 709| 4.21M| out = out * temp[order[2]]; 710| 4.21M| } 711| 4.38M|} _ZN6Assimp3FBX12FBXConverter31NeedsComplexTransformationChainERKNS0_5ModelE: 713| 3.07k|bool FBXConverter::NeedsComplexTransformationChain(const Model &model) { 714| 3.07k| const PropertyTable &props = model.Props(); 715| | 716| 3.07k| const auto zero_epsilon = Math::getEpsilon(); 717| 3.07k| const aiVector3D all_ones(1.0f, 1.0f, 1.0f); 718| 52.8k| for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i) { ------------------ | Branch (718:24): [True: 50.1k, False: 2.63k] ------------------ 719| 50.1k| const TransformationComp comp = static_cast(i); 720| | 721| 50.1k| if (comp == TransformationComp_Rotation || comp == TransformationComp_Scaling || comp == TransformationComp_Translation) { ------------------ | Branch (721:13): [True: 2.91k, False: 47.2k] | Branch (721:52): [True: 2.88k, False: 44.3k] | Branch (721:90): [True: 3.07k, False: 41.3k] ------------------ 722| 8.87k| continue; 723| 8.87k| } 724| | 725| 41.3k| bool scale_compare = (comp == TransformationComp_GeometricScaling || comp == TransformationComp_Scaling); ------------------ | Branch (725:31): [True: 2.87k, False: 38.4k] | Branch (725:78): [True: 0, False: 38.4k] ------------------ 726| | 727| 41.3k| bool ok = true; 728| 41.3k| const aiVector3D &v = PropertyGet(props, NameTransformationCompProperty(comp), ok); 729| 41.3k| if (ok && scale_compare) { ------------------ | Branch (729:13): [True: 24.7k, False: 16.5k] | Branch (729:19): [True: 2.71k, False: 22.0k] ------------------ 730| 2.71k| if ((v - all_ones).SquareLength() > zero_epsilon) { ------------------ | Branch (730:17): [True: 234, False: 2.47k] ------------------ 731| 234| return true; 732| 234| } 733| 38.6k| } else if (ok) { ------------------ | Branch (733:20): [True: 22.0k, False: 16.5k] ------------------ 734| 22.0k| if (v.SquareLength() > zero_epsilon) { ------------------ | Branch (734:17): [True: 209, False: 21.8k] ------------------ 735| 209| return true; 736| 209| } 737| 22.0k| } 738| 41.3k| } 739| | 740| 2.63k| return false; 741| 3.07k|} _ZN6Assimp3FBX12FBXConverter27NameTransformationChainNodeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS1_18TransformationCompE: 743| 3.08k|std::string FBXConverter::NameTransformationChainNode(const std::string &name, TransformationComp comp) { 744| 3.08k| return name + std::string(MAGIC_NODE_TAG) + "_" + NameTransformationComp(comp); ------------------ | | 75| 3.08k|#define MAGIC_NODE_TAG "_$AssimpFbx$" ------------------ 745| 3.08k|} _ZN6Assimp3FBX12FBXConverter31GenerateTransformationNodeChainERKNS0_5ModelERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERNS5_6vectorINS1_13PotentialNodeENS9_ISF_EEEESI_: 748| 4.91k| std::vector &post_output_nodes) { 749| 4.91k| const PropertyTable &props = model.Props(); 750| 4.91k| const Model::RotOrder rot = model.RotationOrder(); 751| | 752| 4.91k| bool ok; 753| | 754| 4.91k| aiMatrix4x4 chain[TransformationComp_MAXIMUM]; 755| | 756| 4.91k| ai_assert(TransformationComp_MAXIMUM < 32); 757| 4.91k| std::uint32_t chainBits = 0; 758| | // A node won't need a node chain if it only has these. 759| 4.91k| 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| 4.91k| const std::uint32_t chainMaskComplex = ((1 << (TransformationComp_MAXIMUM)) - 1) - chainMaskSimple; 762| | 763| 4.91k| std::fill_n(chain, static_cast(TransformationComp_MAXIMUM), aiMatrix4x4()); 764| | 765| | // generate transformation matrices for all the different transformation components 766| 4.91k| const float zero_epsilon = Math::getEpsilon(); 767| 4.91k| const aiVector3D all_ones(1.0f, 1.0f, 1.0f); 768| | 769| 4.91k| const aiVector3D &PreRotation = PropertyGet(props, "PreRotation", ok); 770| 4.91k| if (ok && PreRotation.SquareLength() > zero_epsilon) { ------------------ | Branch (770:9): [True: 4.70k, False: 210] | Branch (770:15): [True: 5, False: 4.69k] ------------------ 771| 5| chainBits = chainBits | (1 << TransformationComp_PreRotation); 772| | 773| 5| GetRotationMatrix(Model::RotOrder::RotOrder_EulerXYZ, PreRotation, chain[TransformationComp_PreRotation]); 774| 5| } 775| | 776| 4.91k| const aiVector3D &PostRotation = PropertyGet(props, "PostRotation", ok); 777| 4.91k| if (ok && PostRotation.SquareLength() > zero_epsilon) { ------------------ | Branch (777:9): [True: 4.69k, False: 217] | Branch (777:15): [True: 42, False: 4.65k] ------------------ 778| 42| chainBits = chainBits | (1 << TransformationComp_PostRotation); 779| | 780| 42| GetRotationMatrix(Model::RotOrder::RotOrder_EulerXYZ, PostRotation, chain[TransformationComp_PostRotation]); 781| 42| } 782| | 783| 4.91k| const aiVector3D &RotationPivot = PropertyGet(props, "RotationPivot", ok); 784| 4.91k| if (ok && RotationPivot.SquareLength() > zero_epsilon) { ------------------ | Branch (784:9): [True: 4.70k, False: 208] | Branch (784:15): [True: 50, False: 4.65k] ------------------ 785| 50| chainBits = chainBits | (1 << TransformationComp_RotationPivot) | (1 << TransformationComp_RotationPivotInverse); 786| | 787| 50| aiMatrix4x4::Translation(RotationPivot, chain[TransformationComp_RotationPivot]); 788| 50| aiMatrix4x4::Translation(-RotationPivot, chain[TransformationComp_RotationPivotInverse]); 789| 50| } 790| | 791| 4.91k| const aiVector3D &RotationOffset = PropertyGet(props, "RotationOffset", ok); 792| 4.91k| if (ok && RotationOffset.SquareLength() > zero_epsilon) { ------------------ | Branch (792:9): [True: 4.70k, False: 210] | Branch (792:15): [True: 59, False: 4.64k] ------------------ 793| 59| chainBits = chainBits | (1 << TransformationComp_RotationOffset); 794| | 795| 59| aiMatrix4x4::Translation(RotationOffset, chain[TransformationComp_RotationOffset]); 796| 59| } 797| | 798| 4.91k| const aiVector3D &ScalingOffset = PropertyGet(props, "ScalingOffset", ok); 799| 4.91k| if (ok && ScalingOffset.SquareLength() > zero_epsilon) { ------------------ | Branch (799:9): [True: 4.60k, False: 310] | Branch (799:15): [True: 0, False: 4.60k] ------------------ 800| 0| chainBits = chainBits | (1 << TransformationComp_ScalingOffset); 801| | 802| 0| aiMatrix4x4::Translation(ScalingOffset, chain[TransformationComp_ScalingOffset]); 803| 0| } 804| | 805| 4.91k| const aiVector3D &ScalingPivot = PropertyGet(props, "ScalingPivot", ok); 806| 4.91k| if (ok && ScalingPivot.SquareLength() > zero_epsilon) { ------------------ | Branch (806:9): [True: 4.63k, False: 277] | Branch (806:15): [True: 0, False: 4.63k] ------------------ 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| 4.91k| const aiVector3D &Translation = PropertyGet(props, "Lcl Translation", ok); 814| 4.91k| if (ok && Translation.SquareLength() > zero_epsilon) { ------------------ | Branch (814:9): [True: 4.85k, False: 61] | Branch (814:15): [True: 3.33k, False: 1.52k] ------------------ 815| 3.33k| chainBits = chainBits | (1 << TransformationComp_Translation); 816| | 817| 3.33k| aiMatrix4x4::Translation(Translation, chain[TransformationComp_Translation]); 818| 3.33k| } 819| | 820| 4.91k| const aiVector3D &Scaling = PropertyGet(props, "Lcl Scaling", ok); 821| 4.91k| if (ok && (Scaling - all_ones).SquareLength() > zero_epsilon) { ------------------ | Branch (821:9): [True: 4.85k, False: 55] | Branch (821:9): [True: 2.45k, False: 2.46k] | Branch (821:15): [True: 2.45k, False: 2.40k] ------------------ 822| 2.45k| chainBits = chainBits | (1 << TransformationComp_Scaling); 823| | 824| 2.45k| aiMatrix4x4::Scaling(Scaling, chain[TransformationComp_Scaling]); 825| 2.45k| } 826| | 827| 4.91k| const aiVector3D &Rotation = PropertyGet(props, "Lcl Rotation", ok); 828| 4.91k| if (ok && Rotation.SquareLength() > zero_epsilon) { ------------------ | Branch (828:9): [True: 4.83k, False: 76] | Branch (828:15): [True: 2.75k, False: 2.08k] ------------------ 829| 2.75k| chainBits = chainBits | (1 << TransformationComp_Rotation); 830| | 831| 2.75k| GetRotationMatrix(rot, Rotation, chain[TransformationComp_Rotation]); 832| 2.75k| } 833| | 834| 4.91k| const aiVector3D &GeometricScaling = PropertyGet(props, "GeometricScaling", ok); 835| 4.91k| if (ok && (GeometricScaling - all_ones).SquareLength() > zero_epsilon) { ------------------ | Branch (835:9): [True: 4.69k, False: 216] | Branch (835:9): [True: 278, False: 4.63k] | Branch (835:15): [True: 278, False: 4.42k] ------------------ 836| 278| chainBits = chainBits | (1 << TransformationComp_GeometricScaling); 837| 278| aiMatrix4x4::Scaling(GeometricScaling, chain[TransformationComp_GeometricScaling]); 838| 278| aiVector3D GeometricScalingInverse = GeometricScaling; 839| 278| bool canscale = true; 840| 1.07k| for (unsigned int i = 0; i < 3; ++i) { ------------------ | Branch (840:34): [True: 814, False: 258] ------------------ 841| 814| if (std::fabs(GeometricScalingInverse[i]) > zero_epsilon) { ------------------ | Branch (841:17): [True: 794, False: 20] ------------------ 842| 794| GeometricScalingInverse[i] = 1.0f / GeometricScaling[i]; 843| 794| } else { 844| 20| FBXImporter::LogError("cannot invert geometric scaling matrix with a 0.0 scale component"); 845| 20| canscale = false; 846| 20| break; 847| 20| } 848| 814| } 849| 278| if (canscale) { ------------------ | Branch (849:13): [True: 258, False: 20] ------------------ 850| 258| chainBits = chainBits | (1 << TransformationComp_GeometricScalingInverse); 851| 258| aiMatrix4x4::Scaling(GeometricScalingInverse, chain[TransformationComp_GeometricScalingInverse]); 852| 258| } 853| 278| } 854| | 855| 4.91k| const aiVector3D &GeometricRotation = PropertyGet(props, "GeometricRotation", ok); 856| 4.91k| if (ok && GeometricRotation.SquareLength() > zero_epsilon) { ------------------ | Branch (856:9): [True: 4.69k, False: 222] | Branch (856:15): [True: 20, False: 4.67k] ------------------ 857| 20| chainBits = chainBits | (1 << TransformationComp_GeometricRotation) | (1 << TransformationComp_GeometricRotationInverse); 858| 20| GetRotationMatrix(rot, GeometricRotation, chain[TransformationComp_GeometricRotation]); 859| 20| GetRotationMatrix(rot, GeometricRotation, chain[TransformationComp_GeometricRotationInverse]); 860| 20| chain[TransformationComp_GeometricRotationInverse].Inverse(); 861| 20| } 862| | 863| 4.91k| const aiVector3D &GeometricTranslation = PropertyGet(props, "GeometricTranslation", ok); 864| 4.91k| if (ok && GeometricTranslation.SquareLength() > zero_epsilon) { ------------------ | Branch (864:9): [True: 4.64k, False: 271] | Branch (864:15): [True: 0, False: 4.64k] ------------------ 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| 4.91k| if ((chainBits & chainMaskComplex) && doc.Settings().preservePivots) { ------------------ | Branch (873:9): [True: 416, False: 4.49k] | Branch (873:43): [True: 416, False: 0] ------------------ 874| 416| 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| 416| NodeAnimBitMap::const_iterator it = node_anim_chain_bits.find(name); 880| 416| const unsigned int anim_chain_bitmask = (it == node_anim_chain_bits.end() ? 0 : (*it).second); ------------------ | Branch (880:50): [True: 140, False: 276] ------------------ 881| | 882| 416| unsigned int bit = 0x1; 883| 7.48k| for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i, bit <<= 1) { ------------------ | Branch (883:28): [True: 7.07k, False: 416] ------------------ 884| 7.07k| const TransformationComp comp = static_cast(i); 885| | 886| 7.07k| if ((chainBits & bit) == 0 && (anim_chain_bitmask & bit) == 0) { ------------------ | Branch (886:17): [True: 5.46k, False: 1.61k] | Branch (886:43): [True: 5.18k, False: 274] ------------------ 887| 5.18k| continue; 888| 5.18k| } 889| | 890| 1.88k| if (comp == TransformationComp_PostRotation) { ------------------ | Branch (890:17): [True: 42, False: 1.84k] ------------------ 891| 42| chain[i] = chain[i].Inverse(); 892| 42| } 893| | 894| 1.88k| PotentialNode nd; 895| 1.88k| nd->mName.Set(NameTransformationChainNode(name, comp)); 896| 1.88k| nd->mTransformation = chain[i]; 897| | 898| | // geometric inverses go in a post-node chain 899| 1.88k| if (comp == TransformationComp_GeometricScalingInverse || ------------------ | Branch (899:17): [True: 258, False: 1.62k] ------------------ 900| 1.62k| comp == TransformationComp_GeometricRotationInverse || ------------------ | Branch (900:21): [True: 20, False: 1.60k] ------------------ 901| 1.60k| comp == TransformationComp_GeometricTranslationInverse) { ------------------ | Branch (901:21): [True: 0, False: 1.60k] ------------------ 902| 278| post_output_nodes.emplace_back(std::move(nd)); 903| 1.60k| } else { 904| 1.60k| output_nodes.emplace_back(std::move(nd)); 905| 1.60k| } 906| 1.88k| } 907| | 908| 416| ai_assert(output_nodes.size()); 909| 416| return true; 910| 416| } 911| | 912| | // else, we can just multiply the matrices together 913| 4.49k| PotentialNode nd; 914| | 915| | // name passed to the method is already unique 916| 4.49k| nd->mName.Set(name); 917| | // for (const auto &transform : chain) { 918| | // skip inverse chain for no preservePivots 919| 67.4k| for (unsigned int i = TransformationComp_Translation; i < TransformationComp_MAXIMUM; i++) { ------------------ | Branch (919:59): [True: 62.9k, False: 4.49k] ------------------ 920| 62.9k| nd->mTransformation = nd->mTransformation * chain[i]; 921| 62.9k| } 922| 4.49k| output_nodes.push_back(std::move(nd)); 923| 4.49k| return false; 924| 4.91k|} _ZN6Assimp3FBX12FBXConverter17SetupNodeMetadataERKNS0_5ModelER6aiNode: 926| 4.91k|void FBXConverter::SetupNodeMetadata(const Model &model, aiNode &nd) { 927| 4.91k| const PropertyTable &props = model.Props(); 928| 4.91k| DirectPropertyMap unparsedProperties = props.GetUnparsedProperties(); 929| | 930| | // create metadata on node 931| 4.91k| const std::size_t numStaticMetaData = 2; 932| 4.91k| aiMetadata *data = aiMetadata::Alloc(static_cast(unparsedProperties.size() + numStaticMetaData)); 933| 4.91k| nd.mMetaData = data; 934| 4.91k| int index = 0; 935| | 936| | // find user defined properties (3ds Max) 937| 4.91k| 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| 4.91k| data->Set(index++, "IsNull", model.IsNull() ? true : false); ------------------ | Branch (939:34): [True: 178, False: 4.73k] ------------------ 940| | 941| | // add unparsed properties to the node's metadata 942| 14.8k| for (const DirectPropertyMap::value_type &prop : unparsedProperties) { ------------------ | Branch (942:52): [True: 14.8k, False: 4.91k] ------------------ 943| | // Interpret the property as a concrete type 944| 14.8k| if (const TypedProperty *interpretedBool = prop.second->As>()) { ------------------ | Branch (944:40): [True: 2.24k, False: 12.6k] ------------------ 945| 2.24k| data->Set(index++, prop.first, interpretedBool->Value()); 946| 12.6k| } else if (const TypedProperty *interpretedInt = prop.second->As>()) { ------------------ | Branch (946:46): [True: 10.4k, False: 2.21k] ------------------ 947| 10.4k| data->Set(index++, prop.first, interpretedInt->Value()); 948| 10.4k| } else if (const TypedProperty *interpretedUInt = prop.second->As>()) { ------------------ | Branch (948:51): [True: 0, False: 2.21k] ------------------ 949| 0| data->Set(index++, prop.first, interpretedUInt->Value()); 950| 2.21k| } else if (const TypedProperty *interpretedUint64 = prop.second->As>()) { ------------------ | Branch (950:51): [True: 9, False: 2.20k] ------------------ 951| 9| data->Set(index++, prop.first, interpretedUint64->Value()); 952| 2.20k| } else if (const TypedProperty *interpretedint64 = prop.second->As>()) { ------------------ | Branch (952:50): [True: 0, False: 2.20k] ------------------ 953| 0| data->Set(index++, prop.first, interpretedint64->Value()); 954| 2.20k| } else if (const TypedProperty *interpretedFloat = prop.second->As>()) { ------------------ | Branch (954:48): [True: 1.75k, False: 446] ------------------ 955| 1.75k| data->Set(index++, prop.first, interpretedFloat->Value()); 956| 1.75k| } else if (const TypedProperty *interpretedString = prop.second->As>()) { ------------------ | Branch (956:54): [True: 25, False: 421] ------------------ 957| 25| data->Set(index++, prop.first, aiString(interpretedString->Value())); 958| 421| } else if (const TypedProperty *interpretedVec3 = prop.second->As>()) { ------------------ | Branch (958:53): [True: 421, False: 0] ------------------ 959| 421| data->Set(index++, prop.first, interpretedVec3->Value()); 960| 421| } else { 961| | ai_assert(false); 962| 0| } 963| 14.8k| } 964| 4.91k|} _ZN6Assimp3FBX12FBXConverter12ConvertModelERKNS0_5ModelEP6aiNodeS6_RK12aiMatrix4x4tIfE: 966| 4.90k|void FBXConverter::ConvertModel(const Model &model, aiNode *parent, aiNode *root_node, const aiMatrix4x4 &absolute_transform) { 967| 4.90k| const std::vector &geos = model.GetGeometry(); 968| | 969| 4.90k| std::vector meshes; 970| 4.90k| meshes.reserve(geos.size()); 971| | 972| 4.90k| for (const Geometry *geo : geos) { ------------------ | Branch (972:30): [True: 788, False: 4.90k] ------------------ 973| 788| const MeshGeometry *const mesh = dynamic_cast(geo); 974| 788| const LineGeometry *const line = dynamic_cast(geo); 975| 788| if (mesh) { ------------------ | Branch (975:13): [True: 788, False: 0] ------------------ 976| 788| const std::vector &indices = ConvertMesh(*mesh, model, parent, root_node, absolute_transform); 977| 788| std::copy(indices.begin(), indices.end(), std::back_inserter(meshes)); 978| 788| } 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| 788| } 987| | 988| 4.90k| if (meshes.size()) { ------------------ | Branch (988:9): [True: 788, False: 4.12k] ------------------ 989| 788| parent->mMeshes = new unsigned int[meshes.size()](); 990| 788| parent->mNumMeshes = static_cast(meshes.size()); 991| | 992| 788| std::swap_ranges(meshes.begin(), meshes.end(), parent->mMeshes); 993| 788| } 994| 4.90k|} _ZN6Assimp3FBX12FBXConverter11ConvertMeshERKNS0_12MeshGeometryERKNS0_5ModelEP6aiNodeS9_RK12aiMatrix4x4tIfE: 997| 788|FBXConverter::ConvertMesh(const MeshGeometry &mesh, const Model &model, aiNode *parent, aiNode *root_node, const aiMatrix4x4 &absolute_transform) { 998| 788| std::vector temp; 999| | 1000| 788| MeshMap::const_iterator it = meshes_converted.find(&mesh); 1001| 788| if (it != meshes_converted.end()) { ------------------ | Branch (1001:9): [True: 2, False: 786] ------------------ 1002| 2| std::copy((*it).second.begin(), (*it).second.end(), std::back_inserter(temp)); 1003| 2| return temp; 1004| 2| } 1005| | 1006| 786| const std::vector &vertices = mesh.GetVertices(); 1007| 786| const std::vector &faces = mesh.GetFaceIndexCounts(); 1008| 786| if (vertices.empty() || faces.empty()) { ------------------ | Branch (1008:9): [True: 0, False: 786] | Branch (1008:29): [True: 0, False: 786] ------------------ 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| 786| const MatIndexArray &mindices = mesh.GetMaterialIndices(); 1016| 786| if (doc.Settings().readMaterials && !mindices.empty()) { ------------------ | Branch (1016:9): [True: 786, False: 0] | Branch (1016:41): [True: 761, False: 25] ------------------ 1017| 761| const MatIndexArray::value_type base = mindices[0]; 1018| 24.4M| for (MatIndexArray::value_type index : mindices) { ------------------ | Branch (1018:46): [True: 24.4M, False: 761] ------------------ 1019| 24.4M| if (index != base) { ------------------ | Branch (1019:17): [True: 0, False: 24.4M] ------------------ 1020| 0| return ConvertMeshMultiMaterial(mesh, model, absolute_transform, parent, root_node); 1021| 0| } 1022| 24.4M| } 1023| 761| } 1024| | 1025| | // faster code-path, just copy the data 1026| 786| temp.push_back(ConvertMeshSingleMaterial(mesh, model, absolute_transform, parent, root_node)); 1027| 786| return temp; 1028| 786|} _ZN6Assimp3FBX12FBXConverter14SetupEmptyMeshERKNS0_8GeometryEP6aiNode: 1074| 786|aiMesh *FBXConverter::SetupEmptyMesh(const Geometry &mesh, aiNode *parent) { 1075| 786| aiMesh *const out_mesh = new aiMesh(); 1076| 786| mMeshes.push_back(out_mesh); 1077| 786| meshes_converted[&mesh].push_back(static_cast(mMeshes.size() - 1)); 1078| | 1079| | // set name 1080| 786| std::string name = mesh.Name(); 1081| 786| if (name.substr(0, 10) == "Geometry::") { ------------------ | Branch (1081:9): [True: 785, False: 1] ------------------ 1082| 785| name = name.substr(10); 1083| 785| } 1084| | 1085| 786| if (name.length()) { ------------------ | Branch (1085:9): [True: 764, False: 22] ------------------ 1086| 764| out_mesh->mName.Set(name); 1087| 764| } else { 1088| 22| out_mesh->mName = parent->mName; 1089| 22| } 1090| | 1091| 786| return out_mesh; 1092| 786|} _ZN6Assimp3FBX12FBXConverter25ConvertMeshSingleMaterialERKNS0_12MeshGeometryERKNS0_5ModelERK12aiMatrix4x4tIfEP6aiNodeSD_: 1123| 786| aiNode *parent, aiNode *) { 1124| 786| const MatIndexArray &mindices = mesh.GetMaterialIndices(); 1125| 786| aiMesh *const out_mesh = SetupEmptyMesh(mesh, parent); 1126| | 1127| 786| const std::vector &vertices = mesh.GetVertices(); 1128| 786| const std::vector &faces = mesh.GetFaceIndexCounts(); 1129| | 1130| | // copy vertices 1131| 786| out_mesh->mNumVertices = static_cast(vertices.size()); 1132| 786| out_mesh->mVertices = new aiVector3D[vertices.size()]; 1133| | 1134| 786| std::copy(vertices.begin(), vertices.end(), out_mesh->mVertices); 1135| | 1136| | // generate dummy faces 1137| 786| out_mesh->mNumFaces = static_cast(faces.size()); 1138| 786| aiFace *fac = out_mesh->mFaces = new aiFace[faces.size()](); 1139| | 1140| 786| unsigned int cursor = 0; 1141| 119k| for (unsigned int pcount : faces) { ------------------ | Branch (1141:30): [True: 119k, False: 786] ------------------ 1142| 119k| aiFace &f = *fac++; 1143| 119k| f.mNumIndices = pcount; 1144| 119k| f.mIndices = new unsigned int[pcount]; 1145| 119k| switch (pcount) { 1146| 0| case 1: ------------------ | Branch (1146:13): [True: 0, False: 119k] ------------------ 1147| 0| out_mesh->mPrimitiveTypes |= aiPrimitiveType_POINT; 1148| 0| break; 1149| 0| case 2: ------------------ | Branch (1149:13): [True: 0, False: 119k] ------------------ 1150| 0| out_mesh->mPrimitiveTypes |= aiPrimitiveType_LINE; 1151| 0| break; 1152| 47.7k| case 3: ------------------ | Branch (1152:13): [True: 47.7k, False: 72.0k] ------------------ 1153| 47.7k| out_mesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE; 1154| 47.7k| break; 1155| 72.0k| default: ------------------ | Branch (1155:13): [True: 72.0k, False: 47.7k] ------------------ 1156| 72.0k| out_mesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON; 1157| 72.0k| break; 1158| 119k| } 1159| 551k| for (unsigned int i = 0; i < pcount; ++i) { ------------------ | Branch (1159:34): [True: 431k, False: 119k] ------------------ 1160| 431k| f.mIndices[i] = cursor++; 1161| 431k| } 1162| 119k| } 1163| | 1164| | // copy normals 1165| 786| const std::vector &normals = mesh.GetNormals(); 1166| 786| if (normals.size()) { ------------------ | Branch (1166:9): [True: 710, False: 76] ------------------ 1167| 710| ai_assert(normals.size() == vertices.size()); 1168| | 1169| 710| out_mesh->mNormals = new aiVector3D[vertices.size()]; 1170| 710| std::copy(normals.begin(), normals.end(), out_mesh->mNormals); 1171| 710| } 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| 786| const std::vector &tangents = mesh.GetTangents(); 1177| 786| const std::vector *binormals = &mesh.GetBinormals(); 1178| | 1179| 786| if (tangents.size()) { ------------------ | Branch (1179:9): [True: 13, False: 773] ------------------ 1180| 13| std::vector tempBinormals; 1181| 13| if (!binormals->size()) { ------------------ | Branch (1181:13): [True: 1, False: 12] ------------------ 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| 13| if (binormals) { ------------------ | Branch (1194:13): [True: 12, False: 1] ------------------ 1195| 12| ai_assert(tangents.size() == vertices.size()); 1196| 12| ai_assert(binormals->size() == vertices.size()); 1197| | 1198| 12| out_mesh->mTangents = new aiVector3D[vertices.size()]; 1199| 12| std::copy(tangents.begin(), tangents.end(), out_mesh->mTangents); 1200| | 1201| 12| out_mesh->mBitangents = new aiVector3D[vertices.size()]; 1202| 12| std::copy(binormals->begin(), binormals->end(), out_mesh->mBitangents); 1203| 12| } 1204| 13| } 1205| | 1206| | // copy texture coords 1207| 1.53k| for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) { ------------------ | Branch (1207:30): [True: 1.53k, False: 0] ------------------ 1208| 1.53k| const std::vector &uvs = mesh.GetTextureCoords(i); 1209| 1.53k| if (uvs.empty()) { ------------------ | Branch (1209:13): [True: 786, False: 746] ------------------ 1210| 786| break; 1211| 786| } 1212| | 1213| 746| aiVector3D *out_uv = out_mesh->mTextureCoords[i] = new aiVector3D[vertices.size()]; 1214| 387k| for (const aiVector2D &v : uvs) { ------------------ | Branch (1214:34): [True: 387k, False: 746] ------------------ 1215| 387k| *out_uv++ = aiVector3D(v.x, v.y, 0.0f); 1216| 387k| } 1217| | 1218| 746| out_mesh->SetTextureCoordsName(i, aiString(mesh.GetTextureCoordChannelName(i))); 1219| | 1220| 746| out_mesh->mNumUVComponents[i] = 2; 1221| 746| } 1222| | 1223| | // copy vertex colors 1224| 786| for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) { ------------------ | Branch (1224:30): [True: 786, False: 0] ------------------ 1225| 786| const std::vector &colors = mesh.GetVertexColors(i); 1226| 786| if (colors.empty()) { ------------------ | Branch (1226:13): [True: 786, False: 0] ------------------ 1227| 786| break; 1228| 786| } 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| 786| if (!doc.Settings().readMaterials || mindices.empty()) { ------------------ | Branch (1234:9): [True: 0, False: 786] | Branch (1234:42): [True: 25, False: 761] ------------------ 1235| 25| FBXImporter::LogError("no material assigned to mesh, setting default material"); 1236| 25| out_mesh->mMaterialIndex = GetDefaultMaterial(); 1237| 761| } else { 1238| 761| ConvertMaterialForMesh(out_mesh, model, mesh, mindices[0]); 1239| 761| } 1240| | 1241| 786| if (doc.Settings().readWeights && mesh.DeformerSkin() != nullptr && !doc.Settings().useSkeleton) { ------------------ | Branch (1241:9): [True: 786, False: 0] | Branch (1241:39): [True: 68, False: 718] | Branch (1241:73): [True: 68, False: 0] ------------------ 1242| 68| ConvertWeights(out_mesh, mesh, absolute_transform, parent, NO_MATERIAL_SEPARATION, nullptr); 1243| 718| } else if (doc.Settings().readWeights && mesh.DeformerSkin() != nullptr && doc.Settings().useSkeleton) { ------------------ | Branch (1243:16): [True: 718, False: 0] | Branch (1243:46): [True: 0, False: 718] | 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| 786| std::vector animMeshes; 1253| 786| for (const BlendShape *blendShape : mesh.GetBlendShapes()) { ------------------ | Branch (1253:39): [True: 0, False: 786] ------------------ 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| 786| const size_t numAnimMeshes = animMeshes.size(); 1293| 786| if (numAnimMeshes > 0) { ------------------ | Branch (1293:9): [True: 0, False: 786] ------------------ 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| 786| return static_cast(mMeshes.size() - 1); 1301| 786|} _ZN6Assimp3FBX12FBXConverter14ConvertWeightsEP6aiMeshRKNS0_12MeshGeometryERK12aiMatrix4x4tIfEP6aiNodejPNSt3__16vectorIjNSD_9allocatorIjEEEE: 1571| 68| std::vector *outputVertStartIndices) { 1572| 68| ai_assert(geo.DeformerSkin()); 1573| | 1574| 68| std::vector out_indices, index_out_indices, count_out_indices; 1575| | 1576| 68| const Skin &sk = *geo.DeformerSkin(); 1577| | 1578| 68| std::vector bones; 1579| 68| const bool no_mat_check = materialIndex == NO_MATERIAL_SEPARATION; 1580| 68| ai_assert(no_mat_check || outputVertStartIndices); 1581| | 1582| 68| try { 1583| | // iterate over the sub deformers 1584| 627| for (const Cluster *cluster : sk.Clusters()) { ------------------ | Branch (1584:37): [True: 627, False: 68] ------------------ 1585| 627| ai_assert(cluster); 1586| | 1587| 627| const WeightIndexArray &indices = cluster->GetIndices(); 1588| | 1589| 627| const MatIndexArray &mats = geo.GetMaterialIndices(); 1590| | 1591| 627| const size_t no_index_sentinel = std::numeric_limits::max(); 1592| | 1593| 627| count_out_indices.clear(); 1594| 627| index_out_indices.clear(); 1595| 627| 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| 220k| for (WeightIndexArray::value_type index : indices) { ------------------ | Branch (1599:53): [True: 220k, False: 627] ------------------ 1600| | 1601| 220k| unsigned int count = 0; 1602| 220k| 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| 220k| ai_assert(out_idx != nullptr); 1606| | 1607| 220k| index_out_indices.push_back(no_index_sentinel); 1608| 220k| count_out_indices.push_back(0); 1609| | 1610| 1.09M| for (unsigned int i = 0; i < count; ++i) { ------------------ | Branch (1610:42): [True: 879k, False: 220k] ------------------ 1611| 879k| if (no_mat_check || static_cast(mats[geo.FaceForVertexIndex(out_idx[i])]) == materialIndex) { ------------------ | Branch (1611:25): [True: 879k, False: 0] | Branch (1611:41): [True: 0, False: 0] ------------------ 1612| | 1613| 879k| if (index_out_indices.back() == no_index_sentinel) { ------------------ | Branch (1613:29): [True: 220k, False: 659k] ------------------ 1614| 220k| index_out_indices.back() = out_indices.size(); 1615| 220k| } 1616| | 1617| 879k| if (no_mat_check) { ------------------ | Branch (1617:29): [True: 879k, False: 0] ------------------ 1618| 879k| out_indices.push_back(out_idx[i]); 1619| 879k| } 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| 879k| ++count_out_indices.back(); 1630| 879k| } 1631| 879k| } 1632| 220k| } 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| 627| ConvertCluster(bones, cluster, out_indices, index_out_indices, 1638| 627| count_out_indices, absolute_transform, parent); 1639| 627| } 1640| | 1641| 68| bone_map.clear(); 1642| 68| } catch (std::exception &) { 1643| 0| std::for_each(bones.begin(), bones.end(), Util::delete_fun()); 1644| 0| throw; 1645| 0| } 1646| | 1647| 68| if (bones.empty()) { ------------------ | Branch (1647:9): [True: 1, False: 67] ------------------ 1648| 1| out->mBones = nullptr; 1649| 1| out->mNumBones = 0; 1650| 1| return; 1651| 1| } 1652| | 1653| 67| out->mBones = new aiBone *[bones.size()](); 1654| 67| out->mNumBones = static_cast(bones.size()); 1655| 67| std::swap_ranges(bones.begin(), bones.end(), out->mBones); 1656| 67|} _ZN6Assimp3FBX12FBXConverter14ConvertClusterERNSt3__16vectorIP6aiBoneNS2_9allocatorIS5_EEEEPKNS0_7ClusterERNS3_ImNS6_ImEEEESF_SF_RK12aiMatrix4x4tIfEP6aiNode: 1661| 627| aiNode *) { 1662| 627| ai_assert(cluster != nullptr); // make sure cluster valid 1663| | 1664| 627| std::string deformer_name = cluster->TargetNode()->Name(); 1665| 627| aiString bone_name = aiString(FixNodeName(deformer_name)); 1666| | 1667| 627| aiBone *bone = nullptr; 1668| | 1669| 627| if (bone_map.count(deformer_name)) { ------------------ | Branch (1669:9): [True: 0, False: 627] ------------------ 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| 627| } else { 1673| 627| ASSIMP_LOG_VERBOSE_DEBUG("created new bone ", bone_name.C_Str(), ". Deformer: ", deformer_name); 1674| 627| bone = new aiBone(); 1675| 627| bone->mName = bone_name; 1676| | 1677| | //bone->mOffsetMatrix = cluster->Transform(); 1678| | // store local transform link for post processing 1679| | 1680| 627| bone->mOffsetMatrix = cluster->TransformLink(); 1681| 627| bone->mOffsetMatrix.Inverse(); 1682| | 1683| 627| const aiMatrix4x4 matrix = (aiMatrix4x4)absolute_transform; 1684| | 1685| 627| bone->mOffsetMatrix = bone->mOffsetMatrix * matrix; // * mesh_offset 1686| | 1687| | // 1688| | // Now calculate the aiVertexWeights 1689| | // 1690| | 1691| 627| aiVertexWeight *cursor = nullptr; 1692| | 1693| 627| bone->mNumWeights = static_cast(out_indices.size()); 1694| 627| cursor = bone->mWeights = new aiVertexWeight[out_indices.size()]; 1695| | 1696| 627| const size_t no_index_sentinel = std::numeric_limits::max(); 1697| 627| const WeightArray &weights = cluster->GetWeights(); 1698| | 1699| 627| const size_t c = index_out_indices.size(); 1700| 220k| for (size_t i = 0; i < c; ++i) { ------------------ | Branch (1700:28): [True: 220k, False: 627] ------------------ 1701| 220k| const size_t index_index = index_out_indices[i]; 1702| | 1703| 220k| if (index_index == no_index_sentinel) { ------------------ | Branch (1703:17): [True: 0, False: 220k] ------------------ 1704| 0| continue; 1705| 0| } 1706| | 1707| 220k| const size_t cc = count_out_indices[i]; 1708| 1.09M| for (size_t j = 0; j < cc; ++j) { ------------------ | Branch (1708:32): [True: 879k, False: 220k] ------------------ 1709| | // cursor runs from first element relative to the start 1710| | // or relative to the start of the next indexes. 1711| 879k| aiVertexWeight &out_weight = *cursor++; 1712| | 1713| 879k| out_weight.mVertexId = static_cast(out_indices[index_index + j]); 1714| 879k| out_weight.mWeight = weights[i]; 1715| 879k| } 1716| 220k| } 1717| | 1718| 627| bone_map.insert(std::pair(deformer_name, bone)); 1719| 627| } 1720| | 1721| 627| 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| 627| local_mesh_bones.push_back(bone); 1726| 627|} _ZN6Assimp3FBX12FBXConverter22ConvertMaterialForMeshEP6aiMeshRKNS0_5ModelERKNS0_12MeshGeometryEi: 1729| 761| MatIndexArray::value_type materialIndex) { 1730| | // locate source materials for this mesh 1731| 761| const std::vector &mats = model.GetMaterials(); 1732| 761| if (static_cast(materialIndex) >= mats.size() || materialIndex < 0) { ------------------ | Branch (1732:9): [True: 25, False: 736] | Branch (1732:68): [True: 0, False: 736] ------------------ 1733| 25| FBXImporter::LogError("material index out of bounds, setting default material"); 1734| 25| out->mMaterialIndex = GetDefaultMaterial(); 1735| 25| return; 1736| 25| } 1737| | 1738| 736| const Material *const mat = mats[materialIndex]; 1739| 736| MaterialMap::const_iterator it = materials_converted.find(mat); 1740| 736| if (it != materials_converted.end()) { ------------------ | Branch (1740:9): [True: 423, False: 313] ------------------ 1741| 423| out->mMaterialIndex = (*it).second; 1742| 423| return; 1743| 423| } 1744| | 1745| 313| out->mMaterialIndex = ConvertMaterial(*mat, &geo); 1746| 313| materials_converted[mat] = out->mMaterialIndex; 1747| 313|} _ZN6Assimp3FBX12FBXConverter18GetDefaultMaterialEv: 1749| 50|unsigned int FBXConverter::GetDefaultMaterial() { 1750| 50| if (defaultMaterialIndex) { ------------------ | Branch (1750:9): [True: 19, False: 31] ------------------ 1751| 19| return defaultMaterialIndex - 1; 1752| 19| } 1753| | 1754| 31| aiMaterial *out_mat = new aiMaterial(); 1755| 31| materials.push_back(out_mat); 1756| | 1757| 31| const aiColor3D diffuse = aiColor3D(0.8f, 0.8f, 0.8f); 1758| 31| out_mat->AddProperty(&diffuse, 1, AI_MATKEY_COLOR_DIFFUSE); 1759| | 1760| 31| aiString s; 1761| 31| s.Set(AI_DEFAULT_MATERIAL_NAME); 1762| | 1763| 31| out_mat->AddProperty(&s, AI_MATKEY_NAME); 1764| | 1765| 31| defaultMaterialIndex = static_cast(materials.size()); 1766| 31| return defaultMaterialIndex - 1; 1767| 50|} _ZN6Assimp3FBX12FBXConverter15ConvertMaterialERKNS0_8MaterialEPKNS0_12MeshGeometryE: 1769| 313|unsigned int FBXConverter::ConvertMaterial(const Material &material, const MeshGeometry *const mesh) { 1770| 313| const PropertyTable &props = material.Props(); 1771| | 1772| | // generate empty output material 1773| 313| aiMaterial *out_mat = new aiMaterial(); 1774| 313| materials_converted[&material] = static_cast(materials.size()); 1775| | 1776| 313| materials.push_back(out_mat); 1777| | 1778| 313| aiString str; 1779| | 1780| | // strip Material:: prefix 1781| 313| std::string name = material.Name(); 1782| 313| if (name.substr(0, 10) == "Material::") { ------------------ | Branch (1782:9): [True: 313, False: 0] ------------------ 1783| 313| name = name.substr(10); 1784| 313| } 1785| | 1786| | // set material name if not empty - this could happen 1787| | // and there should be no key for it in this case. 1788| 313| if (name.length()) { ------------------ | Branch (1788:9): [True: 313, False: 0] ------------------ 1789| 313| str.Set(name); 1790| 313| out_mat->AddProperty(&str, AI_MATKEY_NAME); 1791| 313| } 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| 313| if (material.GetShadingModel() == "phong") { ------------------ | Branch (1794:9): [True: 305, False: 8] ------------------ 1795| 305| aiShadingMode shadingMode = aiShadingMode_Phong; 1796| 305| out_mat->AddProperty(&shadingMode, 1, AI_MATKEY_SHADING_MODEL); 1797| 305| } 1798| | 1799| | // shading stuff and colors 1800| 313| SetShadingPropertiesCommon(out_mat, props); 1801| 313| SetShadingPropertiesRaw(out_mat, props, material.Textures(), mesh); 1802| | 1803| | // texture assignments 1804| 313| SetTextureProperties(out_mat, material.Textures(), mesh); 1805| 313| SetTextureProperties(out_mat, material.LayeredTextures(), mesh); 1806| | 1807| 313| return static_cast(materials.size() - 1); 1808| 313|} _ZN6Assimp3FBX12FBXConverter12ConvertVideoERKNS0_5VideoE: 1810| 6|unsigned int FBXConverter::ConvertVideo(const Video &video) { 1811| | // generate empty output texture 1812| 6| aiTexture *out_tex = new aiTexture(); 1813| 6| textures.push_back(out_tex); 1814| | 1815| | // assuming the texture is compressed 1816| 6| out_tex->mWidth = static_cast(video.ContentLength()); // total data size 1817| 6| out_tex->mHeight = 0; // fixed to 0 1818| | 1819| | // steal the data from the Video to avoid an additional copy 1820| 6| out_tex->pcData = reinterpret_cast(const_cast