_ZN6Assimp19Discreet3DSImporter22ReplaceDefaultMaterialEv: 63| 3|void Discreet3DSImporter::ReplaceDefaultMaterial() { 64| | // Try to find an existing material that matches the 65| | // typical default material setting: 66| | // - no textures 67| | // - diffuse color (in grey!) 68| | // NOTE: This is here to work-around the fact that some 69| | // exporters are writing a default material, too. 70| 3| unsigned int idx(NotSet); 71| 9| for (unsigned int i = 0; i < mScene->mMaterials.size(); ++i) { ------------------ | Branch (71:30): [True: 6, False: 3] ------------------ 72| 6| auto s = mScene->mMaterials[i].mName; 73| 58| for (char &it : s) { ------------------ | Branch (73:23): [True: 58, False: 6] ------------------ 74| 58| it = static_cast(::tolower(static_cast(it))); 75| 58| } 76| | 77| 6| if (std::string::npos == s.find("default")) { ------------------ | Branch (77:13): [True: 4, False: 2] ------------------ 78| 4| continue; 79| 4| } 80| | 81| 2| if (mScene->mMaterials[i].mDiffuse.r != ------------------ | Branch (81:13): [True: 0, False: 2] ------------------ 82| 2| mScene->mMaterials[i].mDiffuse.g || 83| 2| mScene->mMaterials[i].mDiffuse.r != ------------------ | Branch (83:17): [True: 0, False: 2] ------------------ 84| 2| mScene->mMaterials[i].mDiffuse.b) continue; 85| | 86| 2| if (ContainsTextures(i)) { ------------------ | Branch (86:13): [True: 0, False: 2] ------------------ 87| 0| continue; 88| 0| } 89| 2| idx = i; 90| 2| } 91| 3| if (NotSet == idx) { ------------------ | Branch (91:9): [True: 1, False: 2] ------------------ 92| 1| idx = static_cast(mScene->mMaterials.size()); 93| 1| } 94| | 95| | // now iterate through all meshes and through all faces and 96| | // find all faces that are using the default material 97| 3| unsigned int cnt = 0; 98| 6| for (auto i = mScene->mMeshes.begin(); i != mScene->mMeshes.end(); ++i) { ------------------ | Branch (98:44): [True: 3, False: 3] ------------------ 99| 2.90k| for (auto a = i->mFaceMaterials.begin(); a != i->mFaceMaterials.end(); ++a) { ------------------ | Branch (99:50): [True: 2.90k, False: 3] ------------------ 100| | // NOTE: The additional check seems to be necessary, 101| | // some exporters seem to generate invalid data here 102| | 103| 2.90k| if (NotSet == *a) { ------------------ | Branch (103:17): [True: 3, False: 2.90k] ------------------ 104| 3| *a = idx; 105| 3| ++cnt; 106| 2.90k| } else if ((*a) >= mScene->mMaterials.size()) { ------------------ | Branch (106:24): [True: 0, False: 2.90k] ------------------ 107| 0| *a = idx; 108| 0| ASSIMP_LOG_WARN("Material index overflow in 3DS file. Using default material"); 109| 0| ++cnt; 110| 0| } 111| 2.90k| } 112| 3| } 113| 3| if (cnt && idx == mScene->mMaterials.size()) { ------------------ | Branch (113:9): [True: 1, False: 2] | Branch (113:16): [True: 0, False: 1] ------------------ 114| | // We need to create our own default material 115| 0| Material sMat("%%%DEFAULT"); 116| 0| sMat.mDiffuse = aiColor3D(0.3f, 0.3f, 0.3f); 117| 0| mScene->mMaterials.push_back(sMat); 118| | 119| | ASSIMP_LOG_INFO("3DS: Generating default material"); 120| 0| } 121| 3|} _ZN6Assimp19Discreet3DSImporter12CheckIndicesERNS_4D3DS4MeshE: 125| 3|void Discreet3DSImporter::CheckIndices(Mesh &sMesh) { 126| 2.90k| for (auto i = sMesh.mFaces.begin(); i != sMesh.mFaces.end(); ++i) { ------------------ | Branch (126:41): [True: 2.90k, False: 3] ------------------ 127| | // check whether all indices are in range 128| 11.6k| for (unsigned int a = 0; a < 3; ++a) { ------------------ | Branch (128:34): [True: 8.71k, False: 2.90k] ------------------ 129| 8.71k| if ((*i).mIndices[a] >= sMesh.mPositions.size()) { ------------------ | Branch (129:17): [True: 0, False: 8.71k] ------------------ 130| 0| ASSIMP_LOG_WARN("3DS: Vertex index overflow)"); 131| 0| (*i).mIndices[a] = static_cast(sMesh.mPositions.size() - 1); 132| 0| } 133| 8.71k| if (!sMesh.mTexCoords.empty() && (*i).mIndices[a] >= sMesh.mTexCoords.size()) { ------------------ | Branch (133:17): [True: 0, False: 8.71k] | Branch (133:46): [True: 0, False: 0] ------------------ 134| | ASSIMP_LOG_WARN("3DS: Texture coordinate index overflow)"); 135| 0| (*i).mIndices[a] = static_cast(sMesh.mTexCoords.size() - 1); 136| 0| } 137| 8.71k| } 138| 2.90k| } 139| 3|} _ZN6Assimp19Discreet3DSImporter10MakeUniqueERNS_4D3DS4MeshE: 143| 3|void Discreet3DSImporter::MakeUnique(Mesh &sMesh) { 144| | // TODO: really necessary? I don't think. Just a waste of memory and time 145| | // to do it now in a separate buffer. 146| | 147| | // Allocate output storage 148| 3| std::vector vNew(sMesh.mFaces.size() * 3); 149| 3| std::vector vNew2; 150| 3| if (sMesh.mTexCoords.size()) ------------------ | Branch (150:9): [True: 0, False: 3] ------------------ 151| 0| vNew2.resize(sMesh.mFaces.size() * 3); 152| | 153| 2.90k| for (unsigned int i = 0, base = 0; i < sMesh.mFaces.size(); ++i) { ------------------ | Branch (153:40): [True: 2.90k, False: 3] ------------------ 154| 2.90k| Face &face = sMesh.mFaces[i]; 155| | 156| | // Positions 157| 11.6k| for (unsigned int a = 0; a < 3; ++a, ++base) { ------------------ | Branch (157:34): [True: 8.71k, False: 2.90k] ------------------ 158| 8.71k| vNew[base] = sMesh.mPositions[face.mIndices[a]]; 159| 8.71k| if (sMesh.mTexCoords.size()) ------------------ | Branch (159:17): [True: 0, False: 8.71k] ------------------ 160| 0| vNew2[base] = sMesh.mTexCoords[face.mIndices[a]]; 161| | 162| 8.71k| face.mIndices[a] = base; 163| 8.71k| } 164| 2.90k| } 165| 3| sMesh.mPositions = vNew; 166| 3| sMesh.mTexCoords = vNew2; 167| 3|} _ZN6Assimp19Discreet3DSImporter15ConvertMaterialERNS_4D3DS8MaterialER10aiMaterial: 200| 6|void Discreet3DSImporter::ConvertMaterial(Material &oldMat, aiMaterial &mat) { 201| | // NOTE: Pass the background image to the viewer by bypassing the 202| | // material system. This is an evil hack, never do it again! 203| 6| if (mBackgroundImage.empty() && bHasBG) { ------------------ | Branch (203:9): [True: 6, False: 0] | Branch (203:37): [True: 0, False: 6] ------------------ 204| 0| aiString tex(mBackgroundImage); 205| 0| mat.AddProperty(&tex, AI_MATKEY_GLOBAL_BACKGROUND_IMAGE); 206| | 207| | // Be sure this is only done for the first material 208| 0| mBackgroundImage = std::string(); 209| 0| } 210| | 211| | // At first add the base ambient color of the scene to the material 212| 6| oldMat.mAmbient.r += mClrAmbient.r; 213| 6| oldMat.mAmbient.g += mClrAmbient.g; 214| 6| oldMat.mAmbient.b += mClrAmbient.b; 215| | 216| 6| aiString name(oldMat.mName); 217| 6| mat.AddProperty(&name, AI_MATKEY_NAME); 218| | 219| | // Material colors 220| 6| mat.AddProperty(&oldMat.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT); 221| 6| mat.AddProperty(&oldMat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE); 222| 6| mat.AddProperty(&oldMat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR); 223| 6| mat.AddProperty(&oldMat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE); 224| | 225| | // Phong shininess and shininess strength 226| 6| if (Discreet3DS::Phong == oldMat.mShading || Discreet3DS::Metal == oldMat.mShading) { ------------------ | Branch (226:9): [True: 6, False: 0] | Branch (226:50): [True: 0, False: 0] ------------------ 227| 6| if (!oldMat.mSpecularExponent || !oldMat.mShininessStrength) { ------------------ | Branch (227:13): [True: 0, False: 6] | Branch (227:42): [True: 0, False: 6] ------------------ 228| 0| oldMat.mShading = Discreet3DS::Gouraud; 229| 6| } else { 230| 6| mat.AddProperty(&oldMat.mSpecularExponent, 1, AI_MATKEY_SHININESS); 231| 6| mat.AddProperty(&oldMat.mShininessStrength, 1, AI_MATKEY_SHININESS_STRENGTH); 232| 6| } 233| 6| } 234| | 235| | // Opacity 236| 6| mat.AddProperty(&oldMat.mTransparency, 1, AI_MATKEY_OPACITY); 237| | 238| | // Bump height scaling 239| 6| mat.AddProperty(&oldMat.mBumpHeight, 1, AI_MATKEY_BUMPSCALING); 240| | 241| | // Two sided rendering? 242| 6| if (oldMat.mTwoSided) { ------------------ | Branch (242:9): [True: 0, False: 6] ------------------ 243| 0| int i = 1; 244| 0| mat.AddProperty(&i, 1, AI_MATKEY_TWOSIDED); 245| 0| } 246| | 247| | // Shading mode 248| 6| aiShadingMode eShading = aiShadingMode_NoShading; 249| 6| switch (oldMat.mShading) { ------------------ | Branch (249:13): [True: 6, False: 0] ------------------ 250| 0| case Discreet3DS::Flat: ------------------ | Branch (250:5): [True: 0, False: 6] ------------------ 251| 0| eShading = aiShadingMode_Flat; 252| 0| break; 253| | 254| | // I don't know what "Wire" shading should be, 255| | // assume it is simple lambertian diffuse shading 256| 0| case Discreet3DS::Wire: { ------------------ | Branch (256:5): [True: 0, False: 6] ------------------ 257| | // Set the wireframe flag 258| 0| unsigned int iWire = 1; 259| 0| mat.AddProperty((int *)&iWire, 1, AI_MATKEY_ENABLE_WIREFRAME); 260| 0| } 261| 0| [[fallthrough]]; 262| | 263| 0| case Discreet3DS::Gouraud: ------------------ | Branch (263:5): [True: 0, False: 6] ------------------ 264| 0| eShading = aiShadingMode_Gouraud; 265| 0| break; 266| | 267| | // assume cook-torrance shading for metals. 268| 6| case Discreet3DS::Phong: ------------------ | Branch (268:5): [True: 6, False: 0] ------------------ 269| 6| eShading = aiShadingMode_Phong; 270| 6| break; 271| | 272| 0| case Discreet3DS::Metal: ------------------ | Branch (272:5): [True: 0, False: 6] ------------------ 273| 0| eShading = aiShadingMode_CookTorrance; 274| 0| break; 275| | 276| | // FIX to workaround a warning with GCC 4 who complained 277| | // about a missing case Blinn: here - Blinn isn't a valid 278| | // value in the 3DS Loader, it is just needed for ASE 279| 0| case Discreet3DS::Blinn: ------------------ | Branch (279:5): [True: 0, False: 6] ------------------ 280| 0| eShading = aiShadingMode_Blinn; 281| 0| break; 282| 6| } 283| | 284| 6| const int eShading_ = eShading; 285| 6| mat.AddProperty(&eShading_, 1, AI_MATKEY_SHADING_MODEL); 286| | 287| | // DIFFUSE texture 288| 6| if (oldMat.sTexDiffuse.mMapName.length() > 0) ------------------ | Branch (288:9): [True: 0, False: 6] ------------------ 289| 0| CopyTexture(mat, oldMat.sTexDiffuse, aiTextureType_DIFFUSE); 290| | 291| | // SPECULAR texture 292| 6| if (oldMat.sTexSpecular.mMapName.length() > 0) ------------------ | Branch (292:9): [True: 0, False: 6] ------------------ 293| 0| CopyTexture(mat, oldMat.sTexSpecular, aiTextureType_SPECULAR); 294| | 295| | // OPACITY texture 296| 6| if (oldMat.sTexOpacity.mMapName.length() > 0) ------------------ | Branch (296:9): [True: 0, False: 6] ------------------ 297| 0| CopyTexture(mat, oldMat.sTexOpacity, aiTextureType_OPACITY); 298| | 299| | // EMISSIVE texture 300| 6| if (oldMat.sTexEmissive.mMapName.length() > 0) ------------------ | Branch (300:9): [True: 0, False: 6] ------------------ 301| 0| CopyTexture(mat, oldMat.sTexEmissive, aiTextureType_EMISSIVE); 302| | 303| | // BUMP texture 304| 6| if (oldMat.sTexBump.mMapName.length() > 0) ------------------ | Branch (304:9): [True: 0, False: 6] ------------------ 305| 0| CopyTexture(mat, oldMat.sTexBump, aiTextureType_HEIGHT); 306| | 307| | // SHININESS texture 308| 6| if (oldMat.sTexShininess.mMapName.length() > 0) ------------------ | Branch (308:9): [True: 0, False: 6] ------------------ 309| 0| CopyTexture(mat, oldMat.sTexShininess, aiTextureType_SHININESS); 310| | 311| | // REFLECTION texture 312| 6| if (oldMat.sTexReflective.mMapName.length() > 0) ------------------ | Branch (312:9): [True: 0, False: 6] ------------------ 313| 0| CopyTexture(mat, oldMat.sTexReflective, aiTextureType_REFLECTION); 314| | 315| | // Store the name of the material itself, too 316| 6| if (oldMat.mName.length()) { ------------------ | Branch (316:9): [True: 6, False: 0] ------------------ 317| 6| aiString tex; 318| 6| tex.Set(oldMat.mName); 319| | mat.AddProperty(&tex, AI_MATKEY_NAME); 320| 6| } 321| 6|} _ZN6Assimp19Discreet3DSImporter13ConvertMeshesEP7aiScene: 325| 3|void Discreet3DSImporter::ConvertMeshes(aiScene *pcOut) { 326| 3| std::vector avOutMeshes; 327| 3| avOutMeshes.reserve(mScene->mMeshes.size() * 2); 328| | 329| 3| unsigned int iFaceCnt = 0, num = 0; 330| 3| aiString name; 331| | 332| | // we need to split all meshes by their materials 333| 6| for (auto i = mScene->mMeshes.begin(); i != mScene->mMeshes.end(); ++i) { ------------------ | Branch (333:44): [True: 3, False: 3] ------------------ 334| 3| std::unique_ptr[]> aiSplit(new std::vector[mScene->mMaterials.size()]); 335| | 336| 3| name.length = ASSIMP_itoa10(name.data, num); 337| 3| ++num; 338| | 339| 3| unsigned int iNum = 0; 340| 3| for (std::vector::const_iterator a = (*i).mFaceMaterials.begin(); 341| 2.90k| a != (*i).mFaceMaterials.end(); ++a, ++iNum) { ------------------ | Branch (341:17): [True: 2.90k, False: 3] ------------------ 342| 2.90k| aiSplit[*a].push_back(iNum); 343| 2.90k| } 344| | // now generate submeshes 345| 9| for (unsigned int p = 0; p < mScene->mMaterials.size(); ++p) { ------------------ | Branch (345:34): [True: 6, False: 3] ------------------ 346| 6| if (aiSplit[p].empty()) { ------------------ | Branch (346:17): [True: 0, False: 6] ------------------ 347| 0| continue; 348| 0| } 349| 6| auto *meshOut = new aiMesh(); 350| 6| meshOut->mName = name; 351| 6| meshOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; 352| | 353| | // be sure to setup the correct material index 354| 6| meshOut->mMaterialIndex = p; 355| | 356| | // use the color data as temporary storage 357| 6| meshOut->mColors[0] = (aiColor4D *)(&*i); 358| 6| avOutMeshes.push_back(meshOut); 359| | 360| | // convert vertices 361| 6| meshOut->mNumFaces = static_cast(aiSplit[p].size()); 362| 6| meshOut->mNumVertices = meshOut->mNumFaces * 3; 363| | 364| | // allocate enough storage for faces 365| 6| meshOut->mFaces = new aiFace[meshOut->mNumFaces]; 366| 6| iFaceCnt += meshOut->mNumFaces; 367| | 368| 6| meshOut->mVertices = new aiVector3D[meshOut->mNumVertices]; 369| 6| meshOut->mNormals = new aiVector3D[meshOut->mNumVertices]; 370| 6| if ((*i).mTexCoords.size()) { ------------------ | Branch (370:17): [True: 0, False: 6] ------------------ 371| 0| meshOut->mTextureCoords[0] = new aiVector3D[meshOut->mNumVertices]; 372| 0| } 373| 2.91k| for (unsigned int q = 0, base = 0; q < aiSplit[p].size(); ++q) { ------------------ | Branch (373:48): [True: 2.90k, False: 6] ------------------ 374| 2.90k| unsigned int index = aiSplit[p][q]; 375| 2.90k| aiFace &face = meshOut->mFaces[q]; 376| | 377| 2.90k| face.mIndices = new unsigned int[3]; 378| 2.90k| face.mNumIndices = 3; 379| | 380| 11.6k| for (unsigned int a = 0; a < 3; ++a, ++base) { ------------------ | Branch (380:42): [True: 8.71k, False: 2.90k] ------------------ 381| 8.71k| unsigned int idx = (*i).mFaces[index].mIndices[a]; 382| 8.71k| meshOut->mVertices[base] = (*i).mPositions[idx]; 383| 8.71k| meshOut->mNormals[base] = (*i).mNormals[idx]; 384| | 385| 8.71k| if ((*i).mTexCoords.size()) ------------------ | Branch (385:25): [True: 0, False: 8.71k] ------------------ 386| 0| meshOut->mTextureCoords[0][base] = (*i).mTexCoords[idx]; 387| | 388| 8.71k| face.mIndices[a] = base; 389| 8.71k| } 390| 2.90k| } 391| 6| } 392| 3| } 393| | 394| | // Copy them to the output array 395| 3| pcOut->mNumMeshes = (unsigned int)avOutMeshes.size(); 396| 3| pcOut->mMeshes = new aiMesh *[pcOut->mNumMeshes](); 397| 9| for (unsigned int a = 0; a < pcOut->mNumMeshes; ++a) { ------------------ | Branch (397:30): [True: 6, False: 3] ------------------ 398| 6| pcOut->mMeshes[a] = avOutMeshes[a]; 399| 6| } 400| | 401| | // We should have at least one face here 402| 3| if (!iFaceCnt) { ------------------ | Branch (402:9): [True: 0, False: 3] ------------------ 403| 0| throw DeadlyImportError("No faces loaded. The mesh is empty"); 404| 0| } 405| 3|} _ZN6Assimp19Discreet3DSImporter14AddNodeToGraphEP7aiSceneP6aiNodePNS_4D3DS4NodeER12aiMatrix4x4tIfE: 409| 2|void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut, D3DS::Node *pcIn, aiMatrix4x4 & /*absTrafo*/) { 410| 2| std::vector iArray; 411| 2| iArray.reserve(3); 412| | 413| 2| aiMatrix4x4 abs; 414| | 415| | // Find all meshes with the same name as the node 416| 10| for (unsigned int a = 0; a < pcSOut->mNumMeshes; ++a) { ------------------ | Branch (416:30): [True: 8, False: 2] ------------------ 417| 8| const auto *pcMesh = (const D3DS::Mesh *)pcSOut->mMeshes[a]->mColors[0]; 418| 8| ai_assert(nullptr != pcMesh); 419| | 420| 8| if (pcIn->mName == pcMesh->mName) ------------------ | Branch (420:13): [True: 4, False: 4] ------------------ 421| 4| iArray.push_back(a); 422| 8| } 423| 2| if (!iArray.empty()) { ------------------ | Branch (423:9): [True: 1, False: 1] ------------------ 424| | // The matrix should be identical for all meshes with the 425| | // same name. It HAS to be identical for all meshes ..... 426| 1| auto *imesh = ((D3DS::Mesh *)pcSOut->mMeshes[iArray[0]]->mColors[0]); 427| | 428| | // Compute the inverse of the transformation matrix to move the 429| | // vertices back to their relative and local space 430| 1| aiMatrix4x4 mInv = imesh->mMat, mInvTransposed = imesh->mMat; 431| 1| mInv.Inverse(); 432| 1| mInvTransposed.Transpose(); 433| 1| aiVector3D pivot = pcIn->vPivot; 434| | 435| 1| pcOut->mNumMeshes = static_cast(iArray.size()); 436| 1| pcOut->mMeshes = new unsigned int[iArray.size()]; 437| 5| for (unsigned int i = 0; i < iArray.size(); ++i) { ------------------ | Branch (437:34): [True: 4, False: 1] ------------------ 438| 4| const unsigned int iIndex = iArray[i]; 439| 4| aiMesh *const mesh = pcSOut->mMeshes[iIndex]; 440| | 441| 4| if (mesh->mColors[1] == nullptr) { ------------------ | Branch (441:17): [True: 4, False: 0] ------------------ 442| | // Transform the vertices back into their local space 443| | // fixme: consider computing normals after this, so we don't need to transform them 444| 4| const aiVector3D *const pvEnd = mesh->mVertices + mesh->mNumVertices; 445| 4| aiVector3D *pvCurrent = mesh->mVertices, *t2 = mesh->mNormals; 446| | 447| 4.10k| for (; pvCurrent != pvEnd; ++pvCurrent, ++t2) { ------------------ | Branch (447:24): [True: 4.10k, False: 4] ------------------ 448| 4.10k| *pvCurrent = mInv * (*pvCurrent); 449| 4.10k| *t2 = mInvTransposed * (*t2); 450| 4.10k| } 451| | 452| | // Handle negative transformation matrix determinant -> invert vertex x 453| 4| if (imesh->mMat.Determinant() < 0.0f) { ------------------ | Branch (453:21): [True: 0, False: 4] ------------------ 454| | // we *must* have normals 455| 0| for (pvCurrent = mesh->mVertices, t2 = mesh->mNormals; pvCurrent != pvEnd; ++pvCurrent, ++t2) { ------------------ | Branch (455:76): [True: 0, False: 0] ------------------ 456| 0| pvCurrent->x *= -1.f; 457| 0| t2->x *= -1.f; 458| 0| } 459| 0| ASSIMP_LOG_INFO("3DS: Flipping mesh X-Axis"); 460| 0| } 461| | 462| | // Handle pivot point 463| 4| if (pivot.x || pivot.y || pivot.z) { ------------------ | Branch (463:21): [True: 0, False: 4] | Branch (463:32): [True: 0, False: 4] | Branch (463:43): [True: 0, False: 4] ------------------ 464| 0| for (pvCurrent = mesh->mVertices; pvCurrent != pvEnd; ++pvCurrent) { ------------------ | Branch (464:55): [True: 0, False: 0] ------------------ 465| 0| *pvCurrent -= pivot; 466| 0| } 467| 0| } 468| | 469| 4| mesh->mColors[1] = (aiColor4D *)1; 470| 4| } else 471| 0| mesh->mColors[1] = (aiColor4D *)1; 472| | 473| | // Setup the mesh index 474| 4| pcOut->mMeshes[i] = iIndex; 475| 4| } 476| 1| } 477| | 478| | // Setup the name of the node 479| | // First instance keeps its name otherwise something might break, all others will be postfixed with their instance number 480| 2| if (pcIn->mInstanceNumber > 1) { ------------------ | Branch (480:9): [True: 0, False: 2] ------------------ 481| 0| char tmp[12] = {'\0'}; 482| 0| ASSIMP_itoa10(tmp, pcIn->mInstanceNumber); 483| 0| std::string tempStr = pcIn->mName + "_inst_"; 484| 0| tempStr += tmp; 485| 0| pcOut->mName.Set(tempStr); 486| 0| } else 487| 2| pcOut->mName.Set(pcIn->mName); 488| | 489| | // Now build the transformation matrix of the node 490| | // ROTATION 491| 2| if (pcIn->aRotationKeys.size()) { ------------------ | Branch (491:9): [True: 1, False: 1] ------------------ 492| | 493| | // FIX to get to Assimp's quaternion conventions 494| 2| for (auto it = pcIn->aRotationKeys.begin(); it != pcIn->aRotationKeys.end(); ++it) { ------------------ | Branch (494:53): [True: 1, False: 1] ------------------ 495| 1| (*it).mValue.w *= -1.f; 496| 1| } 497| | 498| 1| pcOut->mTransformation = aiMatrix4x4(pcIn->aRotationKeys[0].mValue.GetMatrix()); 499| 1| } else if (pcIn->aCameraRollKeys.size()) { ------------------ | Branch (499:16): [True: 0, False: 1] ------------------ 500| 0| aiMatrix4x4::RotationZ(AI_DEG_TO_RAD(-pcIn->aCameraRollKeys[0].mValue), 501| 0| pcOut->mTransformation); 502| 0| } 503| | 504| | // SCALING 505| 2| aiMatrix4x4 &m = pcOut->mTransformation; 506| 2| if (pcIn->aScalingKeys.size()) { ------------------ | Branch (506:9): [True: 1, False: 1] ------------------ 507| 1| const aiVector3D &v = pcIn->aScalingKeys[0].mValue; 508| 1| m.a1 *= v.x; 509| 1| m.b1 *= v.x; 510| 1| m.c1 *= v.x; 511| 1| m.a2 *= v.y; 512| 1| m.b2 *= v.y; 513| 1| m.c2 *= v.y; 514| 1| m.a3 *= v.z; 515| 1| m.b3 *= v.z; 516| 1| m.c3 *= v.z; 517| 1| } 518| | 519| | // TRANSLATION 520| 2| if (pcIn->aPositionKeys.size()) { ------------------ | Branch (520:9): [True: 1, False: 1] ------------------ 521| 1| const aiVector3D &v = pcIn->aPositionKeys[0].mValue; 522| 1| m.a4 += v.x; 523| 1| m.b4 += v.y; 524| 1| m.c4 += v.z; 525| 1| } 526| | 527| | // Generate animation channels for the node 528| 2| if (pcIn->aPositionKeys.size() > 1 || pcIn->aRotationKeys.size() > 1 || ------------------ | Branch (528:9): [True: 0, False: 2] | Branch (528:43): [True: 0, False: 2] ------------------ 529| 2| pcIn->aScalingKeys.size() > 1 || pcIn->aCameraRollKeys.size() > 1 || ------------------ | Branch (529:13): [True: 0, False: 2] | Branch (529:46): [True: 0, False: 2] ------------------ 530| 2| pcIn->aTargetPositionKeys.size() > 1) { ------------------ | Branch (530:13): [True: 0, False: 2] ------------------ 531| 0| aiAnimation *anim = pcSOut->mAnimations[0]; 532| 0| ai_assert(nullptr != anim); 533| | 534| 0| if (pcIn->aCameraRollKeys.size() > 1) { ------------------ | Branch (534:13): [True: 0, False: 0] ------------------ 535| 0| ASSIMP_LOG_VERBOSE_DEBUG("3DS: Converting camera roll track ..."); 536| | 537| | // Camera roll keys - in fact they're just rotations 538| | // around the camera's z axis. The angles are given 539| | // in degrees (and they're clockwise). 540| 0| pcIn->aRotationKeys.resize(pcIn->aCameraRollKeys.size()); 541| 0| for (unsigned int i = 0; i < pcIn->aCameraRollKeys.size(); ++i) { ------------------ | Branch (541:38): [True: 0, False: 0] ------------------ 542| 0| aiQuatKey &q = pcIn->aRotationKeys[i]; 543| 0| aiFloatKey &f = pcIn->aCameraRollKeys[i]; 544| | 545| 0| q.mTime = f.mTime; 546| | 547| | // FIX to get to Assimp quaternion conventions 548| 0| q.mValue = aiQuaternion(0.f, 0.f, AI_DEG_TO_RAD(/*-*/ f.mValue)); 549| 0| } 550| 0| } 551| |#if 0 552| | if (pcIn->aTargetPositionKeys.size() > 1) 553| | { 554| | ASSIMP_LOG_VERBOSE_DEBUG("3DS: Converting target track ..."); 555| | 556| | // Camera or spot light - need to convert the separate 557| | // target position channel to our representation 558| | TargetAnimationHelper helper; 559| | 560| | if (pcIn->aPositionKeys.empty()) 561| | { 562| | // We can just pass zero here ... 563| | helper.SetFixedMainAnimationChannel(aiVector3D()); 564| | } 565| | else helper.SetMainAnimationChannel(&pcIn->aPositionKeys); 566| | helper.SetTargetAnimationChannel(&pcIn->aTargetPositionKeys); 567| | 568| | // Do the conversion 569| | std::vector distanceTrack; 570| | helper.Process(&distanceTrack); 571| | 572| | // Now add a new node as child, name it .Target 573| | // and assign the distance track to it. This is that the 574| | // information where the target is and how it moves is 575| | // not lost 576| | D3DS::Node* nd = new D3DS::Node(); 577| | pcIn->push_back(nd); 578| | 579| | nd->mName = pcIn->mName + ".Target"; 580| | 581| | aiNodeAnim* nda = anim->mChannels[anim->mNumChannels++] = new aiNodeAnim(); 582| | nda->mNodeName.Set(nd->mName); 583| | 584| | nda->mNumPositionKeys = (unsigned int)distanceTrack.size(); 585| | nda->mPositionKeys = new aiVectorKey[nda->mNumPositionKeys]; 586| | ::memcpy(nda->mPositionKeys,&distanceTrack[0], 587| | sizeof(aiVectorKey)*nda->mNumPositionKeys); 588| | } 589| |#endif 590| | 591| | // Cameras or lights define their transformation in their parent node and in the 592| | // corresponding light or camera chunks. However, we read and process the latter 593| | // to be able to return valid cameras/lights even if no scenegraph is given. 594| 0| for (unsigned int n = 0; n < pcSOut->mNumCameras; ++n) { ------------------ | Branch (594:34): [True: 0, False: 0] ------------------ 595| 0| if (pcSOut->mCameras[n]->mName == pcOut->mName) { ------------------ | Branch (595:17): [True: 0, False: 0] ------------------ 596| 0| pcSOut->mCameras[n]->mLookAt = aiVector3D(0.f, 0.f, 1.f); 597| 0| } 598| 0| } 599| 0| for (unsigned int n = 0; n < pcSOut->mNumLights; ++n) { ------------------ | Branch (599:34): [True: 0, False: 0] ------------------ 600| 0| if (pcSOut->mLights[n]->mName == pcOut->mName) { ------------------ | Branch (600:17): [True: 0, False: 0] ------------------ 601| 0| pcSOut->mLights[n]->mDirection = aiVector3D(0.f, 0.f, 1.f); 602| 0| } 603| 0| } 604| | 605| | // Allocate a new node anim and setup its name 606| 0| auto *nda = anim->mChannels[anim->mNumChannels++] = new aiNodeAnim(); 607| 0| nda->mNodeName.Set(pcIn->mName); 608| | 609| | // POSITION keys 610| 0| if (!pcIn->aPositionKeys.empty()) { ------------------ | Branch (610:13): [True: 0, False: 0] ------------------ 611| 0| nda->mNumPositionKeys = (unsigned int)pcIn->aPositionKeys.size(); 612| 0| nda->mPositionKeys = new aiVectorKey[nda->mNumPositionKeys]; 613| 0| ::memcpy(nda->mPositionKeys, &pcIn->aPositionKeys[0], 614| 0| sizeof(aiVectorKey) * nda->mNumPositionKeys); 615| 0| } 616| | 617| | // ROTATION keys 618| 0| if (!pcIn->aRotationKeys.empty()) { ------------------ | Branch (618:13): [True: 0, False: 0] ------------------ 619| 0| nda->mNumRotationKeys = (unsigned int)pcIn->aRotationKeys.size(); 620| 0| nda->mRotationKeys = new aiQuatKey[nda->mNumRotationKeys]; 621| | 622| | // Rotations are quaternion offsets 623| 0| aiQuaternion abs1; 624| 0| for (unsigned int n = 0; n < nda->mNumRotationKeys; ++n) { ------------------ | Branch (624:38): [True: 0, False: 0] ------------------ 625| 0| const aiQuatKey &q = pcIn->aRotationKeys[n]; 626| | 627| 0| abs1 = (n ? abs1 * q.mValue : q.mValue); ------------------ | Branch (627:25): [True: 0, False: 0] ------------------ 628| 0| nda->mRotationKeys[n].mTime = q.mTime; 629| 0| nda->mRotationKeys[n].mValue = abs1.Normalize(); 630| 0| } 631| 0| } 632| | 633| | // SCALING keys 634| 0| if (!pcIn->aScalingKeys.empty()) { ------------------ | Branch (634:13): [True: 0, False: 0] ------------------ 635| 0| nda->mNumScalingKeys = (unsigned int)pcIn->aScalingKeys.size(); 636| 0| nda->mScalingKeys = new aiVectorKey[nda->mNumScalingKeys]; 637| 0| ::memcpy(nda->mScalingKeys, &pcIn->aScalingKeys[0], 638| 0| sizeof(aiVectorKey) * nda->mNumScalingKeys); 639| 0| } 640| 0| } 641| | 642| | // Allocate storage for children 643| 2| const auto size = static_cast(pcIn->mChildren.size()); 644| | 645| 2| pcOut->mNumChildren = size; 646| 2| if (size == 0) { ------------------ | Branch (646:9): [True: 1, False: 1] ------------------ 647| 1| return; 648| 1| } 649| | 650| 1| pcOut->mChildren = new aiNode *[pcIn->mChildren.size()]; 651| | 652| | // Recursively process all children 653| | 654| 2| for (unsigned int i = 0; i < size; ++i) { ------------------ | Branch (654:30): [True: 1, False: 1] ------------------ 655| 1| pcOut->mChildren[i] = new aiNode(); 656| 1| pcOut->mChildren[i]->mParent = pcOut; 657| 1| AddNodeToGraph(pcSOut, pcOut->mChildren[i], pcIn->mChildren[i], abs); 658| 1| } 659| 1|} _ZN6Assimp11CountTracksEPNS_4D3DS4NodeERj: 663| 2|void CountTracks(D3DS::Node *node, unsigned int &cnt) { 664| | ////////////////////////////////////////////////////////////////////////////// 665| | // We will never generate more than one channel for a node, so 666| | // this is rather easy here. 667| | 668| 2| if (node->aPositionKeys.size() > 1 || node->aRotationKeys.size() > 1 || ------------------ | Branch (668:9): [True: 0, False: 2] | Branch (668:43): [True: 0, False: 2] ------------------ 669| 2| node->aScalingKeys.size() > 1 || node->aCameraRollKeys.size() > 1 || ------------------ | Branch (669:13): [True: 0, False: 2] | Branch (669:46): [True: 0, False: 2] ------------------ 670| 2| node->aTargetPositionKeys.size() > 1) { ------------------ | Branch (670:13): [True: 0, False: 2] ------------------ 671| 0| ++cnt; 672| | 673| | // account for the additional channel for the camera/spotlight target position 674| 0| if (node->aTargetPositionKeys.size() > 1) ++cnt; ------------------ | Branch (674:13): [True: 0, False: 0] ------------------ 675| 0| } 676| | 677| | // Recursively process all children 678| 3| for (unsigned int i = 0; i < node->mChildren.size(); ++i) ------------------ | Branch (678:30): [True: 1, False: 2] ------------------ 679| 1| CountTracks(node->mChildren[i], cnt); 680| 2|} _ZN6Assimp19Discreet3DSImporter17GenerateNodeGraphEP7aiScene: 684| 3|void Discreet3DSImporter::GenerateNodeGraph(aiScene *pcOut) { 685| 3| pcOut->mRootNode = new aiNode(); 686| 3| if (mRootNode->mChildren.empty()) { ------------------ | Branch (686:9): [True: 2, False: 1] ------------------ 687| | ////////////////////////////////////////////////////////////////////////////// 688| | // It seems the file is so messed up that it has not even a hierarchy. 689| | // generate a flat hiearachy which looks like this: 690| | // 691| | // ROOT_NODE 692| | // | 693| | // ---------------------------------------- 694| | // | | | | | 695| | // MESH_0 MESH_1 MESH_2 ... MESH_N CAMERA_0 .... 696| | // 697| 2| ASSIMP_LOG_WARN("No hierarchy information has been found in the file. "); 698| | 699| 2| pcOut->mRootNode->mNumChildren = pcOut->mNumMeshes + 700| 2| static_cast(mScene->mCameras.size() + mScene->mLights.size()); 701| | 702| 2| pcOut->mRootNode->mChildren = new aiNode *[pcOut->mRootNode->mNumChildren]; 703| 2| pcOut->mRootNode->mName.Set("<3DSDummyRoot>"); 704| | 705| | // Build dummy nodes for all meshes 706| 2| unsigned int a = 0; 707| 4| for (unsigned int i = 0; i < pcOut->mNumMeshes; ++i, ++a) { ------------------ | Branch (707:34): [True: 2, False: 2] ------------------ 708| 2| pcOut->mRootNode->mChildren[a] = new aiNode(); 709| 2| auto *pcNode = pcOut->mRootNode->mChildren[a]; 710| 2| pcNode->mParent = pcOut->mRootNode; 711| 2| pcNode->mMeshes = new unsigned int[1]; 712| 2| pcNode->mMeshes[0] = i; 713| 2| pcNode->mNumMeshes = 1; 714| | 715| | // Build a name for the node 716| 2| pcNode->mName.length = ai_snprintf(pcNode->mName.data, AI_MAXLEN, "3DSMesh_%u", i); 717| 2| } 718| | 719| | // Build dummy nodes for all cameras 720| 2| for (unsigned int i = 0; i < (unsigned int)mScene->mCameras.size(); ++i, ++a) { ------------------ | Branch (720:34): [True: 0, False: 2] ------------------ 721| 0| auto *pcNode = pcOut->mRootNode->mChildren[a] = new aiNode(); 722| 0| pcNode->mParent = pcOut->mRootNode; 723| | 724| | // Build a name for the node 725| 0| pcNode->mName = mScene->mCameras[i]->mName; 726| 0| } 727| | 728| | // Build dummy nodes for all lights 729| 2| for (unsigned int i = 0; i < (unsigned int)mScene->mLights.size(); ++i, ++a) { ------------------ | Branch (729:34): [True: 0, False: 2] ------------------ 730| 0| auto *pcNode = pcOut->mRootNode->mChildren[a] = new aiNode(); 731| 0| pcNode->mParent = pcOut->mRootNode; 732| | 733| | // Build a name for the node 734| 0| pcNode->mName = mScene->mLights[i]->mName; 735| 0| } 736| 2| } else { 737| | // First of all: find out how many scaling, rotation and translation 738| | // animation tracks we'll have afterwards 739| 1| unsigned int numChannel = 0; 740| 1| CountTracks(mRootNode, numChannel); 741| | 742| 1| if (numChannel) { ------------------ | Branch (742:13): [True: 0, False: 1] ------------------ 743| | // Allocate a primary animation channel 744| 0| pcOut->mNumAnimations = 1; 745| 0| pcOut->mAnimations = new aiAnimation *[1]; 746| 0| auto *anim = pcOut->mAnimations[0] = new aiAnimation(); 747| | 748| 0| anim->mName.Set("3DSMasterAnim"); 749| | 750| | // Allocate enough storage for all node animation channels, 751| | // but don't set the mNumChannels member - we'll use it to 752| | // index into the array 753| 0| anim->mChannels = new aiNodeAnim *[numChannel]; 754| 0| } 755| | 756| 1| aiMatrix4x4 m; 757| 1| AddNodeToGraph(pcOut, pcOut->mRootNode, mRootNode, m); 758| 1| } 759| | 760| | // We used the first and second vertex color set to store some temporary values so we need to cleanup here 761| 9| for (unsigned int a = 0; a < pcOut->mNumMeshes; ++a) { ------------------ | Branch (761:30): [True: 6, False: 3] ------------------ 762| 6| pcOut->mMeshes[a]->mColors[0] = nullptr; 763| 6| pcOut->mMeshes[a]->mColors[1] = nullptr; 764| 6| } 765| | 766| 3| pcOut->mRootNode->mTransformation = aiMatrix4x4( 767| 3| 1.f, 0.f, 0.f, 0.f, 768| 3| 0.f, 0.f, 1.f, 0.f, 769| 3| 0.f, -1.f, 0.f, 0.f, 770| 3| 0.f, 0.f, 0.f, 1.f) * 771| 3| pcOut->mRootNode->mTransformation; 772| | 773| | // If the root node is unnamed name it "<3DSRoot>" 774| 3| if (::strstr(pcOut->mRootNode->mName.data, "UNNAMED") || ------------------ | Branch (774:9): [True: 1, False: 2] ------------------ 775| 2| (pcOut->mRootNode->mName.data[0] == '$' && pcOut->mRootNode->mName.data[1] == '$')) { ------------------ | Branch (775:14): [True: 0, False: 2] | Branch (775:56): [True: 0, False: 0] ------------------ 776| 1| pcOut->mRootNode->mName.Set("<3DSRoot>"); 777| 1| } 778| 3|} _ZN6Assimp19Discreet3DSImporter12ConvertSceneEP7aiScene: 782| 3|void Discreet3DSImporter::ConvertScene(aiScene *pcOut) { 783| | // Allocate enough storage for all output materials 784| 3| pcOut->mNumMaterials = static_cast(mScene->mMaterials.size()); 785| 3| pcOut->mMaterials = new aiMaterial *[pcOut->mNumMaterials]; 786| | 787| | // ... and convert the 3DS materials to aiMaterial's 788| 9| for (unsigned int i = 0; i < pcOut->mNumMaterials; ++i) { ------------------ | Branch (788:30): [True: 6, False: 3] ------------------ 789| 6| auto *pcNew = new aiMaterial(); 790| 6| ConvertMaterial(mScene->mMaterials[i], *pcNew); 791| 6| pcOut->mMaterials[i] = pcNew; 792| 6| } 793| | 794| | // Generate the output mesh list 795| 3| ConvertMeshes(pcOut); 796| | 797| | // Now copy all light sources to the output scene 798| 3| pcOut->mNumLights = static_cast(mScene->mLights.size()); 799| 3| if (pcOut->mNumLights) { ------------------ | Branch (799:9): [True: 0, False: 3] ------------------ 800| 0| pcOut->mLights = new aiLight *[pcOut->mNumLights]; 801| 0| memcpy(pcOut->mLights, &mScene->mLights[0], sizeof(void *) * pcOut->mNumLights); 802| 0| } 803| | 804| | // Now copy all cameras to the output scene 805| 3| pcOut->mNumCameras = static_cast(mScene->mCameras.size()); 806| 3| if (pcOut->mNumCameras) { ------------------ | Branch (806:9): [True: 0, False: 3] ------------------ 807| 0| pcOut->mCameras = new aiCamera *[pcOut->mNumCameras]; 808| 0| memcpy(pcOut->mCameras, &mScene->mCameras[0], sizeof(void *) * pcOut->mNumCameras); 809| 0| } 810| 3|} _ZN6Assimp4D3DS7TextureC2Ev: 322| 456| : mTextureBlend(0.0f), 323| 456| mOffsetU(0.0), 324| 456| mOffsetV(0.0), 325| 456| mScaleU(1.0), 326| 456| mScaleV(1.0), 327| 456| mRotation(0.0), 328| 456| mMapMode(aiTextureMapMode_Wrap), 329| | bPrivate(), 330| 456| iUVSrc(0) { 331| 456| mTextureBlend = get_qnan(); 332| 456| } _ZN6Assimp4D3DS8MaterialC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 384| 57| mName(name), 385| 57| mDiffuse(0.6f, 0.6f, 0.6f), 386| 57| mSpecularExponent(ai_real(0.0)), 387| 57| mShininessStrength(ai_real(1.0)), 388| 57| mShading(Discreet3DS::Gouraud), 389| 57| mTransparency(ai_real(1.0)), 390| 57| mBumpHeight(ai_real(1.0)), 391| 57| mTwoSided(false) { 392| | // empty 393| 57| } _ZN6Assimp4D3DS4MeshC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 448| 9| mName(name) { 449| 9| } _ZN6Assimp4D3DS4NodeC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 493| 10| mParent(nullptr), 494| 10| mName(name), 495| 10| mInstanceNumber(0), 496| 10| mHierarchyPos(0), 497| 10| mHierarchyIndex(0), 498| 10| mInstanceCount(1) { 499| 10| aRotationKeys.reserve(20); 500| 10| aPositionKeys.reserve(20); 501| 10| aScalingKeys.reserve(20); 502| 10| } _ZN6Assimp4D3DS4NodeD2Ev: 504| 10| ~Node() { 505| 11| for (unsigned int i = 0; i < mChildren.size(); ++i) ------------------ | Branch (505:34): [True: 1, False: 10] ------------------ 506| 1| delete mChildren[i]; 507| 10| } _ZN6Assimp4D3DS4Node9push_backEPS1_: 554| 1| inline Node &push_back(Node *pc) { 555| 1| mChildren.push_back(pc); 556| 1| pc->mParent = this; 557| 1| return *this; 558| 1| } _ZN6Assimp4D3DS8MaterialD2Ev: 397| 87| virtual ~Material() = default; _ZN6Assimp4D3DS8MaterialC2ERKS1_: 395| 30| Material(const Material &other) = default; _ZN6Assimp4D3DS7TextureC2ERKS1_: 334| 240| Texture(const Texture &other) = default; _ZN6Assimp19Discreet3DSImporterC2Ev: 104| 624| mStream(nullptr), mLastNodeIndex(), mCurrentNode(), mRootNode(), mScene(), mMasterScale(), bHasBG(), bIsPrj() { 105| | // empty 106| 624|} _ZNK6Assimp19Discreet3DSImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 110| 483|bool Discreet3DSImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 111| 483| static constexpr uint16_t token[] = { 0x4d4d, 0x3dc2 /*, 0x3daa */ }; 112| | return CheckMagicToken(pIOHandler, pFile, token, AI_COUNT_OF(token), 0, sizeof token[0]); 113| 483|} _ZNK6Assimp19Discreet3DSImporter7GetInfoEv: 117| 643|const aiImporterDesc *Discreet3DSImporter::GetInfo() const { 118| 643| return &desc; 119| 643|} _ZN6Assimp19Discreet3DSImporter15SetupPropertiesEPKNS_8ImporterE: 123| 9|void Discreet3DSImporter::SetupProperties(const Importer * /*pImp*/) { 124| | // nothing to be done for the moment 125| 9|} _ZN6Assimp19Discreet3DSImporter14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 129| 9|void Discreet3DSImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { 130| 9| auto theFile = pIOHandler->Open(pFile, "rb"); 131| 9| if (!theFile) { ------------------ | Branch (131:9): [True: 0, False: 9] ------------------ 132| 0| throw DeadlyImportError("3DS: Could not open ", pFile); 133| 0| } 134| | 135| 9| StreamReaderLE theStream(theFile); 136| | 137| | // We should have at least one chunk 138| 9| if (theStream.GetRemainingSize() < 16) { ------------------ | Branch (138:9): [True: 0, False: 9] ------------------ 139| 0| throw DeadlyImportError("3DS file is either empty or corrupt: ", pFile); 140| 0| } 141| 9| mStream = &theStream; 142| | 143| | // Allocate our temporary 3DS representation 144| 9| Scene _scene; 145| 9| mScene = &_scene; 146| | 147| | // Initialize members 148| 9| Node _rootNode("UNNAMED"); 149| 9| mLastNodeIndex = -1; 150| 9| mCurrentNode = &_rootNode; 151| 9| mRootNode = mCurrentNode; 152| 9| mRootNode->mHierarchyPos = -1; 153| 9| mRootNode->mHierarchyIndex = -1; 154| 9| mRootNode->mParent = nullptr; 155| 9| mMasterScale = 1.0f; 156| 9| mBackgroundImage = std::string(); 157| 9| bHasBG = false; 158| 9| bIsPrj = false; 159| | 160| | // Parse the file 161| 9| ParseMainChunk(); 162| | 163| | // Process all meshes in the file. First check whether all 164| | // face indices have valid values. The generate our 165| | // internal verbose representation. Finally compute normal 166| | // vectors from the smoothing groups we read from the 167| | // file. 168| 9| for (auto &mesh : mScene->mMeshes) { ------------------ | Branch (168:21): [True: 3, False: 9] ------------------ 169| 3| if (!mesh.mFaces.empty() && mesh.mPositions.empty()) { ------------------ | Branch (169:13): [True: 3, False: 0] | Branch (169:37): [True: 0, False: 3] ------------------ 170| 0| throw DeadlyImportError("3DS file contains faces but no vertices: ", pFile); 171| 0| } 172| 3| CheckIndices(mesh); 173| 3| MakeUnique(mesh); 174| 3| ComputeNormalsWithSmoothingsGroups(mesh); 175| 3| } 176| | 177| | // Replace all occurrences of the default material with a 178| | // valid material. Generate it if no material containing 179| | // DEFAULT in its name has been found in the file 180| 9| ReplaceDefaultMaterial(); 181| | 182| | // Convert the scene from our internal representation to an 183| | // aiScene object. This involves copying all meshes, lights 184| | // and cameras to the scene 185| 9| ConvertScene(pScene); 186| | 187| | // Generate the node graph for the scene. This is a little bit 188| | // tricky since we'll need to split some meshes into sub-meshes 189| 9| GenerateNodeGraph(pScene); 190| | 191| | // Now apply the master scaling factor to the scene 192| 9| ApplyMasterScale(pScene); 193| | 194| | // Our internal scene representation and the root 195| | // node will be automatically deleted, so the whole hierarchy will follow 196| | 197| 9| AI_DEBUG_INVALIDATE_PTR(mRootNode); 198| 9| AI_DEBUG_INVALIDATE_PTR(mScene); 199| | AI_DEBUG_INVALIDATE_PTR(mStream); 200| 9|} _ZN6Assimp19Discreet3DSImporter16ApplyMasterScaleEPK7aiScene: 204| 3|void Discreet3DSImporter::ApplyMasterScale(const aiScene *pScene) { 205| | // There are some 3DS files with a zero scaling factor 206| 3| if (!mMasterScale) ------------------ | Branch (206:9): [True: 0, False: 3] ------------------ 207| 0| mMasterScale = 1.0f; 208| 3| else 209| 3| mMasterScale = 1.0f / mMasterScale; 210| | 211| | // Construct an uniform scaling matrix and multiply with it 212| 3| pScene->mRootNode->mTransformation *= aiMatrix4x4( 213| 3| mMasterScale, 0.0f, 0.0f, 0.0f, 214| 3| 0.0f, mMasterScale, 0.0f, 0.0f, 215| 3| 0.0f, 0.0f, mMasterScale, 0.0f, 216| 3| 0.0f, 0.0f, 0.0f, 1.0f); 217| | 218| | // Check whether a scaling track is assigned to the root node. 219| 3|} _ZN6Assimp19Discreet3DSImporter9ReadChunkEPNS_4D3DS11Discreet3DS5ChunkE: 223| 185|void Discreet3DSImporter::ReadChunk(Discreet3DS::Chunk *pcOut) { 224| 185| ai_assert(pcOut != nullptr); 225| | 226| 185| pcOut->Flag = mStream->GetI2(); 227| 185| pcOut->Size = mStream->GetI4(); 228| | 229| 185| if (pcOut->Size - sizeof(Discreet3DS::Chunk) > mStream->GetRemainingSize()) { ------------------ | Branch (229:9): [True: 6, False: 179] ------------------ 230| 6| throw DeadlyImportError("Chunk is too large"); 231| 6| } 232| | 233| 179| if (pcOut->Size - sizeof(Discreet3DS::Chunk) > mStream->GetRemainingSizeToLimit()) { ------------------ | Branch (233:9): [True: 0, False: 179] ------------------ 234| | ASSIMP_LOG_ERROR("3DS: Chunk overflow"); 235| 0| } 236| 179|} _ZN6Assimp19Discreet3DSImporter14ParseMainChunkEv: 249| 9|void Discreet3DSImporter::ParseMainChunk() { 250| 31| ASSIMP_3DS_BEGIN_CHUNK(); ------------------ | | 79| 11| while (true) { \ | | ------------------ | | | Branch (79:12): [True: 11, Folded] | | ------------------ | | 80| 11| if (mStream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)) { \ | | ------------------ | | | Branch (80:13): [True: 1, False: 10] | | ------------------ | | 81| 1| return; \ | | 82| 1| } \ | | 83| 11| Discreet3DS::Chunk chunk; \ | | 84| 10| ReadChunk(&chunk); \ | | 85| 10| int chunkSize = chunk.Size - sizeof(Discreet3DS::Chunk); \ | | 86| 10| if (chunkSize <= 0) \ | | ------------------ | | | Branch (86:13): [True: 0, False: 10] | | ------------------ | | 87| 10| continue; \ | | 88| 10| const unsigned int oldReadLimit = mStream->SetReadLimit( \ | | 89| 10| mStream->GetCurrentPos() + chunkSize); ------------------ 251| | 252| | // get chunk type 253| 31| switch (chunk.Flag) { ------------------ | Branch (253:13): [True: 9, False: 1] ------------------ 254| | 255| 0| case Discreet3DS::CHUNK_PRJ: ------------------ | Branch (255:5): [True: 0, False: 10] ------------------ 256| 0| bIsPrj = true; 257| 0| break; 258| 9| case Discreet3DS::CHUNK_MAIN: ------------------ | Branch (258:5): [True: 9, False: 1] ------------------ 259| 9| ParseEditorChunk(); 260| 9| break; 261| 31| } 262| | 263| 4| ASSIMP_3DS_END_CHUNK(); ------------------ | | 95| 4| mStream->SkipToReadLimit(); \ | | 96| 4| mStream->SetReadLimit(oldReadLimit); \ | | 97| 4| if (mStream->GetRemainingSizeToLimit() == 0) \ | | ------------------ | | | Branch (97:9): [True: 2, False: 2] | | ------------------ | | 98| 4| return; \ | | 99| 4| } ------------------ 264| 0|#if defined(__clang__) 265| 0|#pragma clang diagnostic push 266| 0|#pragma clang diagnostic ignored "-Wunreachable-code-return" 267| 0|#endif 268| | // recursively continue processing this hierarchy level 269| 0| return ParseMainChunk(); 270| 9|#if defined(__clang__) 271| 9|#pragma clang diagnostic pop 272| 9|#endif 273| 9|} _ZN6Assimp19Discreet3DSImporter16ParseEditorChunkEv: 276| 9|void Discreet3DSImporter::ParseEditorChunk() { 277| 57| ASSIMP_3DS_BEGIN_CHUNK() ------------------ | | 79| 19| while (true) { \ | | ------------------ | | | Branch (79:12): [True: 19, Folded] | | ------------------ | | 80| 19| if (mStream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)) { \ | | ------------------ | | | Branch (80:13): [True: 0, False: 19] | | ------------------ | | 81| 0| return; \ | | 82| 0| } \ | | 83| 19| Discreet3DS::Chunk chunk; \ | | 84| 19| ReadChunk(&chunk); \ | | 85| 19| int chunkSize = chunk.Size - sizeof(Discreet3DS::Chunk); \ | | 86| 19| if (chunkSize <= 0) \ | | ------------------ | | | Branch (86:13): [True: 0, False: 19] | | ------------------ | | 87| 19| continue; \ | | 88| 19| const unsigned int oldReadLimit = mStream->SetReadLimit( \ | | 89| 19| mStream->GetCurrentPos() + chunkSize); ------------------ 278| | 279| | // get chunk type 280| 57| switch (chunk.Flag) { ------------------ | Branch (280:13): [True: 19, False: 0] ------------------ 281| 9| case Discreet3DS::CHUNK_OBJMESH: ------------------ | Branch (281:9): [True: 9, False: 10] ------------------ 282| 9| ParseObjectChunk(); 283| 9| break; 284| | 285| | // NOTE: In several documentations in the internet this 286| | // chunk appears at different locations 287| 1| case Discreet3DS::CHUNK_KEYFRAMER: ------------------ | Branch (287:9): [True: 1, False: 18] ------------------ 288| 1| ParseKeyframeChunk(); 289| 1| break; 290| | 291| 9| case Discreet3DS::CHUNK_VERSION: { ------------------ | Branch (291:9): [True: 9, False: 10] ------------------ 292| | // print the version number 293| 9| char buff[10]; 294| 9| ASSIMP_itoa10(buff, mStream->GetI2()); 295| 9| ASSIMP_LOG_INFO("3DS file format version: ", buff); 296| 9| } 297| 9| break; 298| 57| }; 299| 14| ASSIMP_3DS_END_CHUNK() ------------------ | | 95| 14| mStream->SkipToReadLimit(); \ | | 96| 14| mStream->SetReadLimit(oldReadLimit); \ | | 97| 14| if (mStream->GetRemainingSizeToLimit() == 0) \ | | ------------------ | | | Branch (97:9): [True: 4, False: 10] | | ------------------ | | 98| 14| return; \ | | 99| 14| } ------------------ 300| 9|} _ZN6Assimp19Discreet3DSImporter16ParseObjectChunkEv: 303| 9|void Discreet3DSImporter::ParseObjectChunk() { 304| 99| ASSIMP_3DS_BEGIN_CHUNK(); ------------------ | | 79| 33| while (true) { \ | | ------------------ | | | Branch (79:12): [True: 33, Folded] | | ------------------ | | 80| 33| if (mStream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)) { \ | | ------------------ | | | Branch (80:13): [True: 0, False: 33] | | ------------------ | | 81| 0| return; \ | | 82| 0| } \ | | 83| 33| Discreet3DS::Chunk chunk; \ | | 84| 33| ReadChunk(&chunk); \ | | 85| 33| int chunkSize = chunk.Size - sizeof(Discreet3DS::Chunk); \ | | 86| 33| if (chunkSize <= 0) \ | | ------------------ | | | Branch (86:13): [True: 0, False: 33] | | ------------------ | | 87| 33| continue; \ | | 88| 33| const unsigned int oldReadLimit = mStream->SetReadLimit( \ | | 89| 33| mStream->GetCurrentPos() + chunkSize); ------------------ 305| | 306| | // get chunk type 307| 99| switch (chunk.Flag) { ------------------ | Branch (307:13): [True: 24, False: 9] ------------------ 308| 9| case Discreet3DS::CHUNK_OBJBLOCK: { ------------------ | Branch (308:5): [True: 9, False: 24] ------------------ 309| 9| unsigned int cnt = 0; 310| 9| const auto *sz = (const char *)mStream->GetPtr(); 311| | 312| | // Get the name of the geometry object 313| 62| while (mStream->GetI1()) ------------------ | Branch (313:16): [True: 53, False: 9] ------------------ 314| 53| ++cnt; 315| 9| ParseChunk(sz, cnt); 316| 9| } break; 317| | 318| 7| case Discreet3DS::CHUNK_MAT_MATERIAL: ------------------ | Branch (318:5): [True: 7, False: 26] ------------------ 319| | 320| | // Add a new material to the list 321| 7| mScene->mMaterials.emplace_back(std::string("UNNAMED_" + ai_to_string(mScene->mMaterials.size()))); 322| 7| ParseMaterialChunk(); 323| 7| break; 324| | 325| 0| case Discreet3DS::CHUNK_AMBCOLOR: ------------------ | Branch (325:5): [True: 0, False: 33] ------------------ 326| | 327| | // This is the ambient base color of the scene. 328| | // We add it to the ambient color of all materials 329| 0| ParseColorChunk(&mClrAmbient, true); 330| 0| if (is_qnan(mClrAmbient.r)) { ------------------ | Branch (330:13): [True: 0, False: 0] ------------------ 331| | // We failed to read the ambient base color. 332| 0| ASSIMP_LOG_ERROR("3DS: Failed to read ambient base color"); 333| 0| mClrAmbient.r = mClrAmbient.g = mClrAmbient.b = 0.0f; 334| 0| } 335| 0| break; 336| | 337| 0| case Discreet3DS::CHUNK_BIT_MAP: { ------------------ | Branch (337:5): [True: 0, False: 33] ------------------ 338| | // Specifies the background image. The string should already be 339| | // properly 0 terminated but we need to be sure 340| 0| unsigned int cnt = 0; 341| 0| auto *sz = (const char *)mStream->GetPtr(); 342| 0| while (mStream->GetI1()) ------------------ | Branch (342:16): [True: 0, False: 0] ------------------ 343| 0| ++cnt; 344| 0| mBackgroundImage = std::string(sz, cnt); 345| 0| } break; 346| | 347| 0| case Discreet3DS::CHUNK_BIT_MAP_EXISTS: ------------------ | Branch (347:5): [True: 0, False: 33] ------------------ 348| 0| bHasBG = true; 349| 0| break; 350| | 351| 8| case Discreet3DS::CHUNK_MASTER_SCALE: ------------------ | Branch (351:5): [True: 8, False: 25] ------------------ 352| | // Scene master scaling factor 353| 8| mMasterScale = mStream->GetF4(); 354| 8| break; 355| 99| }; 356| 28| ASSIMP_3DS_END_CHUNK(); ------------------ | | 95| 28| mStream->SkipToReadLimit(); \ | | 96| 28| mStream->SetReadLimit(oldReadLimit); \ | | 97| 28| if (mStream->GetRemainingSizeToLimit() == 0) \ | | ------------------ | | | Branch (97:9): [True: 4, False: 24] | | ------------------ | | 98| 28| return; \ | | 99| 28| } ------------------ 357| 0|} _ZN6Assimp19Discreet3DSImporter10ParseChunkEPKcj: 360| 9|void Discreet3DSImporter::ParseChunk(const char *name, unsigned int num) { 361| 27| ASSIMP_3DS_BEGIN_CHUNK(); ------------------ | | 79| 9| while (true) { \ | | ------------------ | | | Branch (79:12): [True: 9, Folded] | | ------------------ | | 80| 9| if (mStream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)) { \ | | ------------------ | | | Branch (80:13): [True: 0, False: 9] | | ------------------ | | 81| 0| return; \ | | 82| 0| } \ | | 83| 9| Discreet3DS::Chunk chunk; \ | | 84| 9| ReadChunk(&chunk); \ | | 85| 9| int chunkSize = chunk.Size - sizeof(Discreet3DS::Chunk); \ | | 86| 9| if (chunkSize <= 0) \ | | ------------------ | | | Branch (86:13): [True: 0, False: 9] | | ------------------ | | 87| 9| continue; \ | | 88| 9| const unsigned int oldReadLimit = mStream->SetReadLimit( \ | | 89| 9| mStream->GetCurrentPos() + chunkSize); ------------------ 362| | 363| | // IMPLEMENTATION NOTE; 364| | // Cameras or lights define their transformation in their parent node and in the 365| | // corresponding light or camera chunks. However, we read and process the latter 366| | // to be able to return valid cameras/lights even if no scenegraph is given. 367| | 368| | // get chunk type 369| 27| switch (chunk.Flag) { ------------------ | Branch (369:13): [True: 9, False: 0] ------------------ 370| 9| case Discreet3DS::CHUNK_TRIMESH: { ------------------ | Branch (370:5): [True: 9, False: 0] ------------------ 371| | // this starts a new triangle mesh 372| 9| mScene->mMeshes.emplace_back(std::string(name, num)); 373| | 374| | // Read mesh chunks 375| 9| ParseMeshChunk(); 376| 9| } break; 377| | 378| 0| case Discreet3DS::CHUNK_LIGHT: { ------------------ | Branch (378:5): [True: 0, False: 9] ------------------ 379| | // This starts a new light 380| 0| auto *light = new aiLight(); 381| 0| mScene->mLights.push_back(light); 382| | 383| 0| light->mName.Set(std::string(name, num)); 384| | 385| | // First read the position of the light 386| 0| light->mPosition.x = mStream->GetF4(); 387| 0| light->mPosition.y = mStream->GetF4(); 388| 0| light->mPosition.z = mStream->GetF4(); 389| | 390| 0| light->mColorDiffuse = aiColor3D(1.f, 1.f, 1.f); 391| | 392| | // Now check for further subchunks 393| 0| if (!bIsPrj) /* fixme */ ------------------ | Branch (393:13): [True: 0, False: 0] ------------------ 394| 0| ParseLightChunk(); 395| | 396| | // The specular light color is identical the the diffuse light color. The ambient light color 397| | // is equal to the ambient base color of the whole scene. 398| 0| light->mColorSpecular = light->mColorDiffuse; 399| 0| light->mColorAmbient = mClrAmbient; 400| | 401| 0| if (light->mType == aiLightSource_UNDEFINED) { ------------------ | Branch (401:13): [True: 0, False: 0] ------------------ 402| | // It must be a point light 403| 0| light->mType = aiLightSource_POINT; 404| 0| } 405| 0| } break; 406| | 407| 0| case Discreet3DS::CHUNK_CAMERA: { ------------------ | Branch (407:5): [True: 0, False: 9] ------------------ 408| | // This starts a new camera 409| 0| auto *camera = new aiCamera(); 410| 0| mScene->mCameras.push_back(camera); 411| 0| camera->mName.Set(std::string(name, num)); 412| | 413| | // First read the position of the camera 414| 0| camera->mPosition.x = mStream->GetF4(); 415| 0| camera->mPosition.y = mStream->GetF4(); 416| 0| camera->mPosition.z = mStream->GetF4(); 417| | 418| | // Then the camera target 419| 0| camera->mLookAt.x = mStream->GetF4() - camera->mPosition.x; 420| 0| camera->mLookAt.y = mStream->GetF4() - camera->mPosition.y; 421| 0| camera->mLookAt.z = mStream->GetF4() - camera->mPosition.z; 422| 0| ai_real len = camera->mLookAt.Length(); 423| 0| if (len < 1e-5) { ------------------ | Branch (423:13): [True: 0, False: 0] ------------------ 424| | 425| | // There are some files with lookat == position. Don't know why or whether it's ok or not. 426| 0| ASSIMP_LOG_ERROR("3DS: Unable to read proper camera look-at vector"); 427| 0| camera->mLookAt = aiVector3D(0.0, 1.0, 0.0); 428| | 429| 0| } else 430| 0| camera->mLookAt /= len; 431| | 432| | // And finally - the camera rotation angle, in counter clockwise direction 433| 0| const ai_real angle = AI_DEG_TO_RAD(mStream->GetF4()); 434| 0| aiQuaternion quat(camera->mLookAt, angle); 435| 0| camera->mUp = quat.GetMatrix() * aiVector3D(0.0, 1.0, 0.0); 436| | 437| | // Read the lense angle 438| 0| camera->mHorizontalFOV = AI_DEG_TO_RAD(mStream->GetF4()); 439| 0| if (camera->mHorizontalFOV < 0.001f) { ------------------ | Branch (439:13): [True: 0, False: 0] ------------------ 440| 0| camera->mHorizontalFOV = float(AI_DEG_TO_RAD(45.f)); 441| 0| } 442| | 443| | // Now check for further subchunks 444| 0| if (!bIsPrj) /* fixme */ { ------------------ | Branch (444:13): [True: 0, False: 0] ------------------ 445| 0| ParseCameraChunk(); 446| 0| } 447| 0| } break; 448| 27| }; 449| 4| ASSIMP_3DS_END_CHUNK(); ------------------ | | 95| 4| mStream->SkipToReadLimit(); \ | | 96| 4| mStream->SetReadLimit(oldReadLimit); \ | | 97| 4| if (mStream->GetRemainingSizeToLimit() == 0) \ | | ------------------ | | | Branch (97:9): [True: 4, False: 0] | | ------------------ | | 98| 4| return; \ | | 99| 4| } ------------------ 450| 0|} _ZN6Assimp19Discreet3DSImporter18ParseKeyframeChunkEv: 516| 1|void Discreet3DSImporter::ParseKeyframeChunk() { 517| 12| ASSIMP_3DS_BEGIN_CHUNK(); ------------------ | | 79| 4| while (true) { \ | | ------------------ | | | Branch (79:12): [True: 4, Folded] | | ------------------ | | 80| 4| if (mStream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)) { \ | | ------------------ | | | Branch (80:13): [True: 0, False: 4] | | ------------------ | | 81| 0| return; \ | | 82| 0| } \ | | 83| 4| Discreet3DS::Chunk chunk; \ | | 84| 4| ReadChunk(&chunk); \ | | 85| 4| int chunkSize = chunk.Size - sizeof(Discreet3DS::Chunk); \ | | 86| 4| if (chunkSize <= 0) \ | | ------------------ | | | Branch (86:13): [True: 0, False: 4] | | ------------------ | | 87| 4| continue; \ | | 88| 4| const unsigned int oldReadLimit = mStream->SetReadLimit( \ | | 89| 4| mStream->GetCurrentPos() + chunkSize); ------------------ 518| | 519| | // get chunk type 520| 12| switch (chunk.Flag) { ------------------ | Branch (520:13): [True: 1, False: 3] ------------------ 521| 0| case Discreet3DS::CHUNK_TRACKCAMTGT: ------------------ | Branch (521:5): [True: 0, False: 4] ------------------ 522| 0| case Discreet3DS::CHUNK_TRACKSPOTL: ------------------ | Branch (522:5): [True: 0, False: 4] ------------------ 523| 0| case Discreet3DS::CHUNK_TRACKCAMERA: ------------------ | Branch (523:5): [True: 0, False: 4] ------------------ 524| 1| case Discreet3DS::CHUNK_TRACKINFO: ------------------ | Branch (524:5): [True: 1, False: 3] ------------------ 525| 1| case Discreet3DS::CHUNK_TRACKLIGHT: ------------------ | Branch (525:5): [True: 0, False: 4] ------------------ 526| 1| case Discreet3DS::CHUNK_TRACKLIGTGT: ------------------ | Branch (526:5): [True: 0, False: 4] ------------------ 527| | 528| | // this starts a new mesh hierarchy chunk 529| 1| ParseHierarchyChunk(chunk.Flag); 530| 1| break; 531| 12| }; 532| | 533| 4| ASSIMP_3DS_END_CHUNK(); ------------------ | | 95| 4| mStream->SkipToReadLimit(); \ | | 96| 4| mStream->SetReadLimit(oldReadLimit); \ | | 97| 4| if (mStream->GetRemainingSizeToLimit() == 0) \ | | ------------------ | | | Branch (97:9): [True: 1, False: 3] | | ------------------ | | 98| 4| return; \ | | 99| 4| } ------------------ 534| 0|} _ZN6Assimp8FindNodeEPNS_4D3DS4NodeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 556| 1|Node *FindNode(Node *root, const std::string &name) { 557| 1| if (root->mName == name) { ------------------ | Branch (557:9): [True: 0, False: 1] ------------------ 558| 0| return root; 559| 0| } 560| | 561| 1| for (auto it = root->mChildren.begin(); it != root->mChildren.end(); ++it) { ------------------ | Branch (561:45): [True: 0, False: 1] ------------------ 562| 0| if (auto *nd = FindNode(*it, name); nullptr != nd) { ------------------ | Branch (562:45): [True: 0, False: 0] ------------------ 563| 0| return nd; 564| 0| } 565| 0| } 566| | 567| 1| return nullptr; 568| 1|} _ZN6Assimp19Discreet3DSImporter11SkipTCBInfoEv: 579| 3|void Discreet3DSImporter::SkipTCBInfo() { 580| 3| unsigned int flags = mStream->GetI2(); 581| | 582| 3| if (!flags) { ------------------ | Branch (582:9): [True: 3, False: 0] ------------------ 583| | // Currently we can't do anything with these values. They occur 584| | // quite rare, so it wouldn't be worth the effort implementing 585| | // them. 3DS is not really suitable for complex animations, 586| | // so full support is not required. 587| 3| ASSIMP_LOG_WARN("3DS: Skipping TCB animation info"); 588| 3| } 589| | 590| 3| if (flags & Discreet3DS::KEY_USE_TENS) { ------------------ | Branch (590:9): [True: 0, False: 3] ------------------ 591| 0| mStream->IncPtr(4); 592| 0| } 593| 3| if (flags & Discreet3DS::KEY_USE_BIAS) { ------------------ | Branch (593:9): [True: 0, False: 3] ------------------ 594| 0| mStream->IncPtr(4); 595| 0| } 596| 3| if (flags & Discreet3DS::KEY_USE_CONT) { ------------------ | Branch (596:9): [True: 0, False: 3] ------------------ 597| 0| mStream->IncPtr(4); 598| 0| } 599| 3| if (flags & Discreet3DS::KEY_USE_EASE_FROM) { ------------------ | Branch (599:9): [True: 0, False: 3] ------------------ 600| 0| mStream->IncPtr(4); 601| 0| } 602| 3| if (flags & Discreet3DS::KEY_USE_EASE_TO) { ------------------ | Branch (602:9): [True: 0, False: 3] ------------------ 603| 0| mStream->IncPtr(4); 604| 0| } 605| 3|} _ZN6Assimp19Discreet3DSImporter19ParseHierarchyChunkEt: 609| 1|void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent) { 610| 18| ASSIMP_3DS_BEGIN_CHUNK(); ------------------ | | 79| 6| while (true) { \ | | ------------------ | | | Branch (79:12): [True: 6, Folded] | | ------------------ | | 80| 6| if (mStream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)) { \ | | ------------------ | | | Branch (80:13): [True: 0, False: 6] | | ------------------ | | 81| 0| return; \ | | 82| 0| } \ | | 83| 6| Discreet3DS::Chunk chunk; \ | | 84| 6| ReadChunk(&chunk); \ | | 85| 6| int chunkSize = chunk.Size - sizeof(Discreet3DS::Chunk); \ | | 86| 6| if (chunkSize <= 0) \ | | ------------------ | | | Branch (86:13): [True: 0, False: 6] | | ------------------ | | 87| 6| continue; \ | | 88| 6| const unsigned int oldReadLimit = mStream->SetReadLimit( \ | | 89| 6| mStream->GetCurrentPos() + chunkSize); ------------------ 611| | 612| | // get chunk type 613| 18| switch (chunk.Flag) { ------------------ | Branch (613:13): [True: 5, False: 1] ------------------ 614| 1| case Discreet3DS::CHUNK_TRACKOBJNAME: ------------------ | Branch (614:5): [True: 1, False: 5] ------------------ 615| | 616| | // This is the name of the object to which the track applies. The chunk also 617| | // defines the position of this object in the hierarchy. 618| 1| { 619| | 620| | // First of all: get the name of the object 621| 1| unsigned int cnt = 0; 622| 1| auto *sz = (const char *)mStream->GetPtr(); 623| | 624| 8| while (mStream->GetI1()) ------------------ | Branch (624:20): [True: 7, False: 1] ------------------ 625| 7| ++cnt; 626| 1| std::string name = std::string(sz, cnt); 627| | 628| | // Now find out whether we have this node already (target animation channels 629| | // are stored with a separate object ID) 630| 1| Node *pcNode = FindNode(mRootNode, name); 631| 1| int instanceNumber = 1; 632| | 633| 1| if (pcNode) { ------------------ | Branch (633:17): [True: 0, False: 1] ------------------ 634| | // if the source is not a CHUNK_TRACKINFO block it won't be an object instance 635| 0| if (parent != Discreet3DS::CHUNK_TRACKINFO) { ------------------ | Branch (635:21): [True: 0, False: 0] ------------------ 636| 0| mCurrentNode = pcNode; 637| 0| break; 638| 0| } 639| 0| pcNode->mInstanceCount++; 640| 0| instanceNumber = pcNode->mInstanceCount; 641| 0| } 642| 1| pcNode = new D3DS::Node(name); 643| 1| pcNode->mInstanceNumber = instanceNumber; 644| | 645| | // There are two unknown values which we can safely ignore 646| 1| mStream->IncPtr(4); 647| | 648| | // Now read the hierarchy position of the object 649| 1| uint16_t hierarchy = mStream->GetI2() + 1; 650| 1| pcNode->mHierarchyPos = hierarchy; 651| 1| pcNode->mHierarchyIndex = mLastNodeIndex; 652| | 653| | // And find a proper position in the graph for it 654| 1| if (mCurrentNode && mCurrentNode->mHierarchyPos == hierarchy) { ------------------ | Branch (654:17): [True: 1, False: 0] | Branch (654:33): [True: 0, False: 1] ------------------ 655| | 656| | // add to the parent of the last touched node 657| 0| mCurrentNode->mParent->push_back(pcNode); 658| 0| mLastNodeIndex++; 659| 1| } else if (hierarchy >= mLastNodeIndex) { ------------------ | Branch (659:24): [True: 1, False: 0] ------------------ 660| | 661| | // place it at the current position in the hierarchy 662| 1| mCurrentNode->push_back(pcNode); 663| 1| mLastNodeIndex = hierarchy; 664| 1| } else { 665| | // need to go back to the specified position in the hierarchy. 666| 0| InverseNodeSearch(pcNode, mCurrentNode); 667| 0| mLastNodeIndex++; 668| 0| } 669| | // Make this node the current node 670| 1| mCurrentNode = pcNode; 671| 1| } 672| 0| break; 673| | 674| 0| case Discreet3DS::CHUNK_TRACKDUMMYOBJNAME: ------------------ | Branch (674:5): [True: 0, False: 6] ------------------ 675| | 676| | // This is the "real" name of a $$$DUMMY object 677| 0| { 678| 0| const char *sz = (const char *)mStream->GetPtr(); 679| 0| while (mStream->GetI1()) ------------------ | Branch (679:20): [True: 0, False: 0] ------------------ 680| 0| ; 681| | 682| | // If object name is DUMMY, take this one instead 683| 0| if (mCurrentNode->mName == "$$$DUMMY") { ------------------ | Branch (683:17): [True: 0, False: 0] ------------------ 684| 0| mCurrentNode->mName = std::string(sz); 685| 0| break; 686| 0| } 687| 0| } 688| 0| break; 689| | 690| 1| case Discreet3DS::CHUNK_TRACKPIVOT: ------------------ | Branch (690:5): [True: 1, False: 5] ------------------ 691| | 692| 1| if (Discreet3DS::CHUNK_TRACKINFO != parent) { ------------------ | Branch (692:13): [True: 0, False: 1] ------------------ 693| 0| ASSIMP_LOG_WARN("3DS: Skipping pivot subchunk for non usual object"); 694| 0| break; 695| 0| } 696| | 697| | // Pivot = origin of rotation and scaling 698| 1| mCurrentNode->vPivot.x = mStream->GetF4(); 699| 1| mCurrentNode->vPivot.y = mStream->GetF4(); 700| 1| mCurrentNode->vPivot.z = mStream->GetF4(); 701| 1| break; 702| | 703| | // //////////////////////////////////////////////////////////////////// 704| | // POSITION KEYFRAME 705| 1| case Discreet3DS::CHUNK_TRACKPOS: { ------------------ | Branch (705:5): [True: 1, False: 5] ------------------ 706| 1| mStream->IncPtr(10); 707| 1| const unsigned int numFrames = mStream->GetI4(); 708| 1| bool sortKeys = false; 709| | 710| | // This could also be meant as the target position for 711| | // (targeted) lights and cameras 712| 1| std::vector *l; 713| 1| if (Discreet3DS::CHUNK_TRACKCAMTGT == parent || Discreet3DS::CHUNK_TRACKLIGTGT == parent) { ------------------ | Branch (713:13): [True: 0, False: 1] | Branch (713:57): [True: 0, False: 1] ------------------ 714| 0| l = &mCurrentNode->aTargetPositionKeys; 715| 0| } else 716| 1| l = &mCurrentNode->aPositionKeys; 717| | 718| 1| l->reserve(numFrames); 719| 2| for (unsigned int i = 0; i < numFrames; ++i) { ------------------ | Branch (719:34): [True: 1, False: 1] ------------------ 720| 1| const unsigned int fidx = mStream->GetI4(); 721| | 722| | // Setup a new position key 723| 1| aiVectorKey v; 724| 1| v.mTime = (double)fidx; 725| | 726| 1| SkipTCBInfo(); 727| 1| v.mValue.x = mStream->GetF4(); 728| 1| v.mValue.y = mStream->GetF4(); 729| 1| v.mValue.z = mStream->GetF4(); 730| | 731| | // check whether we'll need to sort the keys 732| 1| if (!l->empty() && v.mTime <= l->back().mTime) ------------------ | Branch (732:17): [True: 0, False: 1] | Branch (732:32): [True: 0, False: 0] ------------------ 733| 0| sortKeys = true; 734| | 735| | // Add the new keyframe to the list 736| 1| l->push_back(v); 737| 1| } 738| | 739| | // Sort all keys with ascending time values and remove duplicates? 740| 1| if (sortKeys) { ------------------ | Branch (740:13): [True: 0, False: 1] ------------------ 741| 0| std::stable_sort(l->begin(), l->end()); 742| 0| l->erase(std::unique(l->begin(), l->end(), &KeyUniqueCompare), l->end()); 743| 0| } 744| 1| } 745| | 746| 1| break; 747| | 748| | // //////////////////////////////////////////////////////////////////// 749| | // CAMERA ROLL KEYFRAME 750| 0| case Discreet3DS::CHUNK_TRACKROLL: { ------------------ | Branch (750:5): [True: 0, False: 6] ------------------ 751| | // roll keys are accepted for cameras only 752| 0| if (parent != Discreet3DS::CHUNK_TRACKCAMERA) { ------------------ | Branch (752:13): [True: 0, False: 0] ------------------ 753| 0| ASSIMP_LOG_WARN("3DS: Ignoring roll track for non-camera object"); 754| 0| break; 755| 0| } 756| 0| bool sortKeys = false; 757| 0| std::vector *l = &mCurrentNode->aCameraRollKeys; 758| | 759| 0| mStream->IncPtr(10); 760| 0| const unsigned int numFrames = mStream->GetI4(); 761| 0| l->reserve(numFrames); 762| 0| for (unsigned int i = 0; i < numFrames; ++i) { ------------------ | Branch (762:34): [True: 0, False: 0] ------------------ 763| 0| const unsigned int fidx = mStream->GetI4(); 764| | 765| | // Setup a new position key 766| 0| aiFloatKey v; 767| 0| v.mTime = (double)fidx; 768| | 769| | // This is just a single float 770| 0| SkipTCBInfo(); 771| 0| v.mValue = mStream->GetF4(); 772| | 773| | // Check whether we'll need to sort the keys 774| 0| if (!l->empty() && v.mTime <= l->back().mTime) ------------------ | Branch (774:17): [True: 0, False: 0] | Branch (774:32): [True: 0, False: 0] ------------------ 775| 0| sortKeys = true; 776| | 777| | // Add the new keyframe to the list 778| 0| l->push_back(v); 779| 0| } 780| | 781| | // Sort all keys with ascending time values and remove duplicates? 782| 0| if (sortKeys) { ------------------ | Branch (782:13): [True: 0, False: 0] ------------------ 783| 0| std::stable_sort(l->begin(), l->end()); 784| 0| l->erase(std::unique(l->begin(), l->end(), &KeyUniqueCompare), l->end()); 785| 0| } 786| 0| } break; 787| | 788| | // //////////////////////////////////////////////////////////////////// 789| | // CAMERA FOV KEYFRAME 790| 0| case Discreet3DS::CHUNK_TRACKFOV: { ------------------ | Branch (790:5): [True: 0, False: 6] ------------------ 791| 0| ASSIMP_LOG_ERROR("3DS: Skipping FOV animation track. " 792| 0| "This is not supported"); 793| 0| } break; 794| | 795| | // //////////////////////////////////////////////////////////////////// 796| | // ROTATION KEYFRAME 797| 1| case Discreet3DS::CHUNK_TRACKROTATE: { ------------------ | Branch (797:5): [True: 1, False: 5] ------------------ 798| 1| mStream->IncPtr(10); 799| 1| const unsigned int numFrames = mStream->GetI4(); 800| | 801| 1| bool sortKeys = false; 802| 1| std::vector *l = &mCurrentNode->aRotationKeys; 803| 1| l->reserve(numFrames); 804| | 805| 2| for (unsigned int i = 0; i < numFrames; ++i) { ------------------ | Branch (805:34): [True: 1, False: 1] ------------------ 806| 1| const unsigned int fidx = mStream->GetI4(); 807| 1| SkipTCBInfo(); 808| | 809| 1| aiQuatKey v; 810| 1| v.mTime = (double)fidx; 811| | 812| | // The rotation keyframe is given as an axis-angle pair 813| 1| const float rad = mStream->GetF4(); 814| 1| aiVector3D axis; 815| 1| axis.x = mStream->GetF4(); 816| 1| axis.y = mStream->GetF4(); 817| 1| axis.z = mStream->GetF4(); 818| | 819| 1| if (!axis.x && !axis.y && !axis.z) ------------------ | Branch (819:17): [True: 1, False: 0] | Branch (819:28): [True: 1, False: 0] | Branch (819:39): [True: 1, False: 0] ------------------ 820| 1| axis.y = 1.f; 821| | 822| | // Construct a rotation quaternion from the axis-angle pair 823| 1| v.mValue = aiQuaternion(axis, rad); 824| | 825| | // Check whether we'll need to sort the keys 826| 1| if (!l->empty() && v.mTime <= l->back().mTime) ------------------ | Branch (826:17): [True: 0, False: 1] | Branch (826:32): [True: 0, False: 0] ------------------ 827| 0| sortKeys = true; 828| | 829| | // add the new keyframe to the list 830| 1| l->push_back(v); 831| 1| } 832| | // Sort all keys with ascending time values and remove duplicates? 833| 1| if (sortKeys) { ------------------ | Branch (833:13): [True: 0, False: 1] ------------------ 834| 0| std::stable_sort(l->begin(), l->end()); 835| 0| l->erase(std::unique(l->begin(), l->end(), &KeyUniqueCompare), l->end()); 836| 0| } 837| 1| } break; 838| | 839| | // //////////////////////////////////////////////////////////////////// 840| | // SCALING KEYFRAME 841| 1| case Discreet3DS::CHUNK_TRACKSCALE: { ------------------ | Branch (841:5): [True: 1, False: 5] ------------------ 842| 1| mStream->IncPtr(10); 843| 1| const unsigned int numFrames = mStream->GetI2(); 844| 1| mStream->IncPtr(2); 845| | 846| 1| bool sortKeys = false; 847| 1| std::vector *l = &mCurrentNode->aScalingKeys; 848| 1| l->reserve(numFrames); 849| | 850| 2| for (unsigned int i = 0; i < numFrames; ++i) { ------------------ | Branch (850:34): [True: 1, False: 1] ------------------ 851| 1| const unsigned int fidx = mStream->GetI4(); 852| 1| SkipTCBInfo(); 853| | 854| | // Setup a new key 855| 1| aiVectorKey v; 856| 1| v.mTime = (double)fidx; 857| | 858| | // ... and read its value 859| 1| v.mValue.x = mStream->GetF4(); 860| 1| v.mValue.y = mStream->GetF4(); 861| 1| v.mValue.z = mStream->GetF4(); 862| | 863| | // check whether we'll need to sort the keys 864| 1| if (!l->empty() && v.mTime <= l->back().mTime) ------------------ | Branch (864:17): [True: 0, False: 1] | Branch (864:32): [True: 0, False: 0] ------------------ 865| 0| sortKeys = true; 866| | 867| | // Remove zero-scalings on singular axes - they've been reported to be there erroneously in some strange files 868| 1| if (!v.mValue.x) v.mValue.x = 1.f; ------------------ | Branch (868:17): [True: 0, False: 1] ------------------ 869| 1| if (!v.mValue.y) v.mValue.y = 1.f; ------------------ | Branch (869:17): [True: 0, False: 1] ------------------ 870| 1| if (!v.mValue.z) v.mValue.z = 1.f; ------------------ | Branch (870:17): [True: 0, False: 1] ------------------ 871| | 872| 1| l->push_back(v); 873| 1| } 874| | // Sort all keys with ascending time values and remove duplicates? 875| 1| if (sortKeys) { ------------------ | Branch (875:13): [True: 0, False: 1] ------------------ 876| 0| std::stable_sort(l->begin(), l->end()); 877| 0| l->erase(std::unique(l->begin(), l->end(), &KeyUniqueCompare), l->end()); 878| 0| } 879| 1| } break; 880| 18| }; 881| | 882| 6| ASSIMP_3DS_END_CHUNK(); ------------------ | | 95| 6| mStream->SkipToReadLimit(); \ | | 96| 6| mStream->SetReadLimit(oldReadLimit); \ | | 97| 6| if (mStream->GetRemainingSizeToLimit() == 0) \ | | ------------------ | | | Branch (97:9): [True: 1, False: 5] | | ------------------ | | 98| 6| return; \ | | 99| 6| } ------------------ 883| 0|} _ZN6Assimp19Discreet3DSImporter14ParseFaceChunkEv: 887| 4|void Discreet3DSImporter::ParseFaceChunk() { 888| 24| ASSIMP_3DS_BEGIN_CHUNK(); ------------------ | | 79| 8| while (true) { \ | | ------------------ | | | Branch (79:12): [True: 8, Folded] | | ------------------ | | 80| 8| if (mStream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)) { \ | | ------------------ | | | Branch (80:13): [True: 0, False: 8] | | ------------------ | | 81| 0| return; \ | | 82| 0| } \ | | 83| 8| Discreet3DS::Chunk chunk; \ | | 84| 8| ReadChunk(&chunk); \ | | 85| 8| int chunkSize = chunk.Size - sizeof(Discreet3DS::Chunk); \ | | 86| 8| if (chunkSize <= 0) \ | | ------------------ | | | Branch (86:13): [True: 0, False: 8] | | ------------------ | | 87| 8| continue; \ | | 88| 8| const unsigned int oldReadLimit = mStream->SetReadLimit( \ | | 89| 8| mStream->GetCurrentPos() + chunkSize); ------------------ 889| | 890| | // Get the mesh we're currently working on 891| 24| D3DS::Mesh &mMesh = mScene->mMeshes.back(); 892| | 893| | // Get chunk type 894| 24| switch (chunk.Flag) { ------------------ | Branch (894:13): [True: 8, False: 0] ------------------ 895| 1| case Discreet3DS::CHUNK_SMOOLIST: { ------------------ | Branch (895:5): [True: 1, False: 7] ------------------ 896| | // This is the list of smoothing groups - a bitfield for every face. 897| | // Up to 32 smoothing groups assigned to a single face. 898| 1| unsigned int num = chunkSize / 4, m = 0; 899| 1| if (num > mMesh.mFaces.size()) { ------------------ | Branch (899:13): [True: 0, False: 1] ------------------ 900| 0| throw DeadlyImportError("3DS: More smoothing groups than faces"); 901| 0| } 902| 1.36k| for (auto i = mMesh.mFaces.begin(); m != num; ++i, ++m) { ------------------ | Branch (902:45): [True: 1.36k, False: 1] ------------------ 903| | // nth bit is set for nth smoothing group 904| 1.36k| i->iSmoothGroup = mStream->GetI4(); 905| 1.36k| } 906| 1| } break; 907| | 908| 7| case Discreet3DS::CHUNK_FACEMAT: { ------------------ | Branch (908:5): [True: 7, False: 1] ------------------ 909| | // at fist an asciiz with the material name 910| 7| const char *sz = (const char *)mStream->GetPtr(); 911| 84| while (mStream->GetI1()) ------------------ | Branch (911:16): [True: 77, False: 7] ------------------ 912| 77| ; 913| | 914| | // find the index of the material 915| 7| unsigned int idx = 0xcdcdcdcd, cnt = 0; 916| 14| for (auto i = mScene->mMaterials.begin(); i != mScene->mMaterials.end(); ++i, ++cnt) { ------------------ | Branch (916:51): [True: 13, False: 1] ------------------ 917| | // use case independent comparisons. hopefully it will work. 918| 13| if (i->mName.length() && !ASSIMP_stricmp(sz, i->mName.c_str())) { ------------------ | Branch (918:17): [True: 13, False: 0] | Branch (918:38): [True: 6, False: 7] ------------------ 919| 6| idx = cnt; 920| 6| break; 921| 6| } 922| 13| } 923| 7| if (0xcdcdcdcd == idx) { ------------------ | Branch (923:13): [True: 1, False: 6] ------------------ 924| 1| ASSIMP_LOG_ERROR("3DS: Unknown material: ", sz); 925| 1| } 926| | 927| | // Now continue and read all material indices 928| 7| cnt = (uint16_t)mStream->GetI2(); 929| 2.91k| for (unsigned int i = 0; i < cnt; ++i) { ------------------ | Branch (929:34): [True: 2.90k, False: 7] ------------------ 930| 2.90k| unsigned int fidx = (uint16_t)mStream->GetI2(); 931| | 932| | // check range 933| 2.90k| if (fidx >= mMesh.mFaceMaterials.size()) { ------------------ | Branch (933:17): [True: 2, False: 2.90k] ------------------ 934| 2| ASSIMP_LOG_ERROR("3DS: Invalid face index in face material list"); 935| 2| } else 936| 2.90k| mMesh.mFaceMaterials[fidx] = idx; 937| 2.90k| } 938| 7| } break; 939| 24| }; 940| 8| ASSIMP_3DS_END_CHUNK(); ------------------ | | 95| 8| mStream->SkipToReadLimit(); \ | | 96| 8| mStream->SetReadLimit(oldReadLimit); \ | | 97| 8| if (mStream->GetRemainingSizeToLimit() == 0) \ | | ------------------ | | | Branch (97:9): [True: 4, False: 4] | | ------------------ | | 98| 8| return; \ | | 99| 8| } ------------------ 941| 0|} _ZN6Assimp19Discreet3DSImporter14ParseMeshChunkEv: 945| 9|void Discreet3DSImporter::ParseMeshChunk() { 946| 66| ASSIMP_3DS_BEGIN_CHUNK(); ------------------ | | 79| 22| while (true) { \ | | ------------------ | | | Branch (79:12): [True: 22, Folded] | | ------------------ | | 80| 22| if (mStream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)) { \ | | ------------------ | | | Branch (80:13): [True: 0, False: 22] | | ------------------ | | 81| 0| return; \ | | 82| 0| } \ | | 83| 22| Discreet3DS::Chunk chunk; \ | | 84| 22| ReadChunk(&chunk); \ | | 85| 22| int chunkSize = chunk.Size - sizeof(Discreet3DS::Chunk); \ | | 86| 22| if (chunkSize <= 0) \ | | ------------------ | | | Branch (86:13): [True: 0, False: 22] | | ------------------ | | 87| 22| continue; \ | | 88| 22| const unsigned int oldReadLimit = mStream->SetReadLimit( \ | | 89| 22| mStream->GetCurrentPos() + chunkSize); ------------------ 947| | 948| | // Get the mesh we're currently working on 949| 66| D3DS::Mesh &mMesh = mScene->mMeshes.back(); 950| | 951| | // get chunk type 952| 66| switch (chunk.Flag) { ------------------ | Branch (952:13): [True: 14, False: 8] ------------------ 953| 9| case Discreet3DS::CHUNK_VERTLIST: { ------------------ | Branch (953:5): [True: 9, False: 13] ------------------ 954| | // This is the list of all vertices in the current mesh 955| 9| int num = (int)(uint16_t)mStream->GetI2(); 956| 9| mMesh.mPositions.reserve(num); 957| 2.05k| while (num-- > 0) { ------------------ | Branch (957:16): [True: 2.05k, False: 9] ------------------ 958| 2.05k| aiVector3D v; 959| 2.05k| v.x = mStream->GetF4(); 960| 2.05k| v.y = mStream->GetF4(); 961| 2.05k| v.z = mStream->GetF4(); 962| 2.05k| mMesh.mPositions.push_back(v); 963| 2.05k| } 964| 9| } break; 965| 1| case Discreet3DS::CHUNK_TRMATRIX: { ------------------ | Branch (965:5): [True: 1, False: 21] ------------------ 966| | // This is the RLEATIVE transformation matrix of the current mesh. Vertices are 967| | // pretransformed by this matrix wonder. 968| 1| mMesh.mMat.a1 = mStream->GetF4(); 969| 1| mMesh.mMat.b1 = mStream->GetF4(); 970| 1| mMesh.mMat.c1 = mStream->GetF4(); 971| 1| mMesh.mMat.a2 = mStream->GetF4(); 972| 1| mMesh.mMat.b2 = mStream->GetF4(); 973| 1| mMesh.mMat.c2 = mStream->GetF4(); 974| 1| mMesh.mMat.a3 = mStream->GetF4(); 975| 1| mMesh.mMat.b3 = mStream->GetF4(); 976| 1| mMesh.mMat.c3 = mStream->GetF4(); 977| 1| mMesh.mMat.a4 = mStream->GetF4(); 978| 1| mMesh.mMat.b4 = mStream->GetF4(); 979| 1| mMesh.mMat.c4 = mStream->GetF4(); 980| 1| } break; 981| | 982| 0| case Discreet3DS::CHUNK_MAPLIST: { ------------------ | Branch (982:5): [True: 0, False: 22] ------------------ 983| | // This is the list of all UV coords in the current mesh 984| 0| int num = (int)(uint16_t)mStream->GetI2(); 985| 0| mMesh.mTexCoords.reserve(num); 986| 0| while (num-- > 0) { ------------------ | Branch (986:16): [True: 0, False: 0] ------------------ 987| 0| aiVector3D v; 988| 0| v.x = mStream->GetF4(); 989| 0| v.y = mStream->GetF4(); 990| 0| mMesh.mTexCoords.push_back(v); 991| 0| } 992| 0| } break; 993| | 994| 4| case Discreet3DS::CHUNK_FACELIST: { ------------------ | Branch (994:5): [True: 4, False: 18] ------------------ 995| | // This is the list of all faces in the current mesh 996| 4| int num = (int)(uint16_t)mStream->GetI2(); 997| 4| mMesh.mFaces.reserve(num); 998| 3.67k| while (num-- > 0) { ------------------ | Branch (998:16): [True: 3.67k, False: 4] ------------------ 999| | // 3DS faces are ALWAYS triangles 1000| 3.67k| mMesh.mFaces.emplace_back(); 1001| 3.67k| Face &sFace = mMesh.mFaces.back(); 1002| | 1003| 3.67k| sFace.mIndices[0] = (uint16_t)mStream->GetI2(); 1004| 3.67k| sFace.mIndices[1] = (uint16_t)mStream->GetI2(); 1005| 3.67k| sFace.mIndices[2] = (uint16_t)mStream->GetI2(); 1006| | 1007| 3.67k| mStream->IncPtr(2); // skip edge visibility flag 1008| 3.67k| } 1009| | 1010| | // Resize the material array (0xcdcdcdcd marks the default material; so if a face is 1011| | // not referenced by a material, $$DEFAULT will be assigned to it) 1012| 4| mMesh.mFaceMaterials.resize(mMesh.mFaces.size(), 0xcdcdcdcd); 1013| | 1014| | // Larger 3DS files could have multiple FACE chunks here 1015| 4| chunkSize = (int)mStream->GetRemainingSizeToLimit(); 1016| 4| if (chunkSize > (int)sizeof(Discreet3DS::Chunk)) ------------------ | Branch (1016:13): [True: 4, False: 0] ------------------ 1017| 4| ParseFaceChunk(); 1018| 4| } break; 1019| 66| }; 1020| 17| ASSIMP_3DS_END_CHUNK(); ------------------ | | 95| 17| mStream->SkipToReadLimit(); \ | | 96| 17| mStream->SetReadLimit(oldReadLimit); \ | | 97| 17| if (mStream->GetRemainingSizeToLimit() == 0) \ | | ------------------ | | | Branch (97:9): [True: 4, False: 13] | | ------------------ | | 98| 17| return; \ | | 99| 17| } ------------------ 1021| 0|} _ZN6Assimp19Discreet3DSImporter18ParseMaterialChunkEv: 1025| 7|void Discreet3DSImporter::ParseMaterialChunk() { 1026| 132| ASSIMP_3DS_BEGIN_CHUNK(); ------------------ | | 79| 44| while (true) { \ | | ------------------ | | | Branch (79:12): [True: 44, Folded] | | ------------------ | | 80| 44| if (mStream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)) { \ | | ------------------ | | | Branch (80:13): [True: 0, False: 44] | | ------------------ | | 81| 0| return; \ | | 82| 0| } \ | | 83| 44| Discreet3DS::Chunk chunk; \ | | 84| 44| ReadChunk(&chunk); \ | | 85| 44| int chunkSize = chunk.Size - sizeof(Discreet3DS::Chunk); \ | | 86| 44| if (chunkSize <= 0) \ | | ------------------ | | | Branch (86:13): [True: 0, False: 44] | | ------------------ | | 87| 44| continue; \ | | 88| 44| const unsigned int oldReadLimit = mStream->SetReadLimit( \ | | 89| 44| mStream->GetCurrentPos() + chunkSize); ------------------ 1027| 132| switch (chunk.Flag) { ------------------ | Branch (1027:13): [True: 44, False: 0] ------------------ 1028| 7| case Discreet3DS::CHUNK_MAT_MATNAME: ------------------ | Branch (1028:5): [True: 7, False: 37] ------------------ 1029| | 1030| 7| { 1031| | // The material name string is already zero-terminated, but we need to be sure ... 1032| 7| const char *sz = (const char *)mStream->GetPtr(); 1033| 7| unsigned int cnt = 0; 1034| 72| while (mStream->GetI1()) ------------------ | Branch (1034:16): [True: 65, False: 7] ------------------ 1035| 65| ++cnt; 1036| | 1037| 7| if (!cnt) { ------------------ | Branch (1037:13): [True: 0, False: 7] ------------------ 1038| | // This may not be, we use the default name instead 1039| 0| ASSIMP_LOG_ERROR("3DS: Empty material name"); 1040| 0| } else 1041| 7| mScene->mMaterials.back().mName = std::string(sz, cnt); 1042| 7| } break; 1043| | 1044| 7| case Discreet3DS::CHUNK_MAT_DIFFUSE: { ------------------ | Branch (1044:5): [True: 7, False: 37] ------------------ 1045| | // This is the diffuse material color 1046| 7| aiColor3D *pc = &mScene->mMaterials.back().mDiffuse; 1047| 7| ParseColorChunk(pc); 1048| 7| if (is_qnan(pc->r)) { ------------------ | Branch (1048:13): [True: 0, False: 7] ------------------ 1049| | // color chunk is invalid. Simply ignore it 1050| 0| ASSIMP_LOG_ERROR("3DS: Unable to read DIFFUSE chunk"); 1051| 0| pc->r = pc->g = pc->b = 1.0f; 1052| 0| } 1053| 7| } break; 1054| | 1055| 3| case Discreet3DS::CHUNK_MAT_SPECULAR: { ------------------ | Branch (1055:5): [True: 3, False: 41] ------------------ 1056| | // This is the specular material color 1057| 3| aiColor3D *pc = &mScene->mMaterials.back().mSpecular; 1058| 3| ParseColorChunk(pc); 1059| 3| if (is_qnan(pc->r)) { ------------------ | Branch (1059:13): [True: 0, False: 3] ------------------ 1060| | // color chunk is invalid. Simply ignore it 1061| 0| ASSIMP_LOG_ERROR("3DS: Unable to read SPECULAR chunk"); 1062| 0| pc->r = pc->g = pc->b = 1.0f; 1063| 0| } 1064| 3| } break; 1065| | 1066| 3| case Discreet3DS::CHUNK_MAT_AMBIENT: { ------------------ | Branch (1066:5): [True: 3, False: 41] ------------------ 1067| | // This is the ambient material color 1068| 3| aiColor3D *pc = &mScene->mMaterials.back().mAmbient; 1069| 3| ParseColorChunk(pc); 1070| 3| if (is_qnan(pc->r)) { ------------------ | Branch (1070:13): [True: 0, False: 3] ------------------ 1071| | // color chunk is invalid. Simply ignore it 1072| 0| ASSIMP_LOG_ERROR("3DS: Unable to read AMBIENT chunk"); 1073| 0| pc->r = pc->g = pc->b = 0.0f; 1074| 0| } 1075| 3| } break; 1076| | 1077| 0| case Discreet3DS::CHUNK_MAT_SELF_ILLUM: { ------------------ | Branch (1077:5): [True: 0, False: 44] ------------------ 1078| | // This is the emissive material color 1079| 0| aiColor3D *pc = &mScene->mMaterials.back().mEmissive; 1080| 0| ParseColorChunk(pc); 1081| 0| if (is_qnan(pc->r)) { ------------------ | Branch (1081:13): [True: 0, False: 0] ------------------ 1082| | // color chunk is invalid. Simply ignore it 1083| 0| ASSIMP_LOG_ERROR("3DS: Unable to read EMISSIVE chunk"); 1084| 0| pc->r = pc->g = pc->b = 0.0f; 1085| 0| } 1086| 0| } break; 1087| | 1088| 7| case Discreet3DS::CHUNK_MAT_TRANSPARENCY: { ------------------ | Branch (1088:5): [True: 7, False: 37] ------------------ 1089| | // This is the material's transparency 1090| 7| ai_real *pcf = &mScene->mMaterials.back().mTransparency; 1091| 7| *pcf = ParsePercentageChunk(); 1092| | 1093| | // NOTE: transparency, not opacity 1094| 7| if (is_qnan(*pcf)) ------------------ | Branch (1094:13): [True: 0, False: 7] ------------------ 1095| 0| *pcf = ai_real(1.0); 1096| 7| else 1097| 7| *pcf = ai_real(1.0) - *pcf * (ai_real)0xFFFF / ai_real(100.0); 1098| 7| } break; 1099| | 1100| 7| case Discreet3DS::CHUNK_MAT_SHADING: ------------------ | Branch (1100:5): [True: 7, False: 37] ------------------ 1101| | // This is the material shading mode 1102| 7| mScene->mMaterials.back().mShading = (Discreet3DS::shadetype3ds)mStream->GetI2(); 1103| 7| break; 1104| | 1105| 0| case Discreet3DS::CHUNK_MAT_TWO_SIDE: ------------------ | Branch (1105:5): [True: 0, False: 44] ------------------ 1106| | // This is the two-sided flag 1107| 0| mScene->mMaterials.back().mTwoSided = true; 1108| 0| break; 1109| | 1110| 7| case Discreet3DS::CHUNK_MAT_SHININESS: { // This is the shininess of the material ------------------ | Branch (1110:5): [True: 7, False: 37] ------------------ 1111| 7| ai_real *pcf = &mScene->mMaterials.back().mSpecularExponent; 1112| 7| *pcf = ParsePercentageChunk(); 1113| 7| if (is_qnan(*pcf)) ------------------ | Branch (1113:13): [True: 0, False: 7] ------------------ 1114| 0| *pcf = 0.0; 1115| 7| else 1116| 7| *pcf *= (ai_real)0xFFFF; 1117| 7| } break; 1118| | 1119| 3| case Discreet3DS::CHUNK_MAT_SHININESS_PERCENT: { // This is the shininess strength of the material ------------------ | Branch (1119:5): [True: 3, False: 41] ------------------ 1120| 3| ai_real *pcf = &mScene->mMaterials.back().mShininessStrength; 1121| 3| *pcf = ParsePercentageChunk(); 1122| 3| if (is_qnan(*pcf)) ------------------ | Branch (1122:13): [True: 0, False: 3] ------------------ 1123| 0| *pcf = ai_real(0.0); 1124| 3| else 1125| 3| *pcf *= (ai_real)0xffff / ai_real(100.0); 1126| 3| } break; 1127| | 1128| 0| case Discreet3DS::CHUNK_MAT_SELF_ILPCT: { // This is the self illumination strength of the material ------------------ | Branch (1128:5): [True: 0, False: 44] ------------------ 1129| 0| ai_real f = ParsePercentageChunk(); 1130| 0| if (is_qnan(f)) ------------------ | Branch (1130:13): [True: 0, False: 0] ------------------ 1131| 0| f = ai_real(0.0); 1132| 0| else 1133| 0| f *= (ai_real)0xFFFF / ai_real(100.0); 1134| 0| mScene->mMaterials.back().mEmissive = aiColor3D(f, f, f); 1135| 0| } break; 1136| | 1137| | // Parse texture chunks 1138| 0| case Discreet3DS::CHUNK_MAT_TEXTURE: ------------------ | Branch (1138:5): [True: 0, False: 44] ------------------ 1139| | // Diffuse texture 1140| 0| ParseTextureChunk(&mScene->mMaterials.back().sTexDiffuse); 1141| 0| break; 1142| 0| case Discreet3DS::CHUNK_MAT_BUMPMAP: ------------------ | Branch (1142:5): [True: 0, False: 44] ------------------ 1143| | // Height map 1144| 0| ParseTextureChunk(&mScene->mMaterials.back().sTexBump); 1145| 0| break; 1146| 0| case Discreet3DS::CHUNK_MAT_OPACMAP: ------------------ | Branch (1146:5): [True: 0, False: 44] ------------------ 1147| | // Opacity texture 1148| 0| ParseTextureChunk(&mScene->mMaterials.back().sTexOpacity); 1149| 0| break; 1150| 0| case Discreet3DS::CHUNK_MAT_MAT_SHINMAP: ------------------ | Branch (1150:5): [True: 0, False: 44] ------------------ 1151| | // Shininess map 1152| 0| ParseTextureChunk(&mScene->mMaterials.back().sTexShininess); 1153| 0| break; 1154| 0| case Discreet3DS::CHUNK_MAT_SPECMAP: ------------------ | Branch (1154:5): [True: 0, False: 44] ------------------ 1155| | // Specular map 1156| 0| ParseTextureChunk(&mScene->mMaterials.back().sTexSpecular); 1157| 0| break; 1158| 0| case Discreet3DS::CHUNK_MAT_SELFIMAP: ------------------ | Branch (1158:5): [True: 0, False: 44] ------------------ 1159| | // Self-illumination (emissive) map 1160| 0| ParseTextureChunk(&mScene->mMaterials.back().sTexEmissive); 1161| 0| break; 1162| 0| case Discreet3DS::CHUNK_MAT_REFLMAP: ------------------ | Branch (1162:5): [True: 0, False: 44] ------------------ 1163| | // Reflection map 1164| 0| ParseTextureChunk(&mScene->mMaterials.back().sTexReflective); 1165| 0| break; 1166| 132| }; 1167| 44| ASSIMP_3DS_END_CHUNK(); ------------------ | | 95| 44| mStream->SkipToReadLimit(); \ | | 96| 44| mStream->SetReadLimit(oldReadLimit); \ | | 97| 44| if (mStream->GetRemainingSizeToLimit() == 0) \ | | ------------------ | | | Branch (97:9): [True: 7, False: 37] | | ------------------ | | 98| 44| return; \ | | 99| 44| } ------------------ 1168| 0|} _ZN6Assimp19Discreet3DSImporter20ParsePercentageChunkEv: 1253| 17|ai_real Discreet3DSImporter::ParsePercentageChunk() { 1254| 17| Discreet3DS::Chunk chunk; 1255| 17| ReadChunk(&chunk); 1256| | 1257| 17| if (Discreet3DS::CHUNK_PERCENTF == chunk.Flag) { ------------------ | Branch (1257:9): [True: 0, False: 17] ------------------ 1258| 0| return mStream->GetF4() * ai_real(100) / ai_real(0xFFFF); 1259| 0| } 1260| | 1261| 17| if (Discreet3DS::CHUNK_PERCENTW == chunk.Flag) { ------------------ | Branch (1261:9): [True: 17, False: 0] ------------------ 1262| 17| return (ai_real)((uint16_t)mStream->GetI2()) / (ai_real)0xFFFF; 1263| 17| } 1264| | 1265| 0| return get_qnan(); 1266| 17|} _ZN6Assimp19Discreet3DSImporter15ParseColorChunkEP9aiColor3Db: 1270| 13|void Discreet3DSImporter::ParseColorChunk(aiColor3D *out, bool acceptPercent) { 1271| 13| ai_assert(out != nullptr); 1272| | 1273| | // error return value 1274| 13| const ai_real qnan = get_qnan(); 1275| 13| static const aiColor3D clrError = aiColor3D(qnan, qnan, qnan); 1276| | 1277| 13| Discreet3DS::Chunk chunk; 1278| 13| ReadChunk(&chunk); 1279| 13| const unsigned int diff = chunk.Size - sizeof(Discreet3DS::Chunk); 1280| | 1281| 13| bool bGamma = false; 1282| | 1283| | // Get the type of the chunk 1284| 13| switch (chunk.Flag) { 1285| 0| case Discreet3DS::CHUNK_LINRGBF: ------------------ | Branch (1285:5): [True: 0, False: 13] ------------------ 1286| 0| bGamma = true; 1287| | // fallthrough 1288| 0| case Discreet3DS::CHUNK_RGBF: ------------------ | Branch (1288:5): [True: 0, False: 13] ------------------ 1289| 0| if (sizeof(float) * 3 > diff) { ------------------ | Branch (1289:13): [True: 0, False: 0] ------------------ 1290| 0| *out = clrError; 1291| 0| return; 1292| 0| } 1293| 0| out->r = mStream->GetF4(); 1294| 0| out->g = mStream->GetF4(); 1295| 0| out->b = mStream->GetF4(); 1296| 0| break; 1297| | 1298| 0| case Discreet3DS::CHUNK_LINRGBB: ------------------ | Branch (1298:5): [True: 0, False: 13] ------------------ 1299| 0| bGamma = true; 1300| | // fallthrough 1301| 13| case Discreet3DS::CHUNK_RGBB: { ------------------ | Branch (1301:5): [True: 13, False: 0] ------------------ 1302| 13| if (sizeof(char) * 3 > diff) { ------------------ | Branch (1302:13): [True: 0, False: 13] ------------------ 1303| 0| *out = clrError; 1304| 0| return; 1305| 0| } 1306| 13| const ai_real invVal = ai_real(1.0) / ai_real(255.0); 1307| 13| out->r = (ai_real)(uint8_t)mStream->GetI1() * invVal; 1308| 13| out->g = (ai_real)(uint8_t)mStream->GetI1() * invVal; 1309| 13| out->b = (ai_real)(uint8_t)mStream->GetI1() * invVal; 1310| 13| } break; 1311| | 1312| | // Percentage chunks are accepted, too. 1313| 0| case Discreet3DS::CHUNK_PERCENTF: ------------------ | Branch (1313:5): [True: 0, False: 13] ------------------ 1314| 0| if (acceptPercent && 4 <= diff) { ------------------ | Branch (1314:13): [True: 0, False: 0] | Branch (1314:30): [True: 0, False: 0] ------------------ 1315| 0| out->g = out->b = out->r = mStream->GetF4(); 1316| 0| break; 1317| 0| } 1318| 0| *out = clrError; 1319| 0| return; 1320| | 1321| 0| case Discreet3DS::CHUNK_PERCENTW: ------------------ | Branch (1321:5): [True: 0, False: 13] ------------------ 1322| 0| if (acceptPercent && 1 <= diff) { ------------------ | Branch (1322:13): [True: 0, False: 0] | Branch (1322:30): [True: 0, False: 0] ------------------ 1323| 0| out->g = out->b = out->r = (ai_real)(uint8_t)mStream->GetI1() / ai_real(255.0); 1324| 0| break; 1325| 0| } 1326| 0| *out = clrError; 1327| 0| return; 1328| | 1329| 0| default: ------------------ | Branch (1329:5): [True: 0, False: 13] ------------------ 1330| 0| mStream->IncPtr(diff); 1331| | // Skip unknown chunks, hope this won't cause any problems. 1332| 0| return ParseColorChunk(out, acceptPercent); 1333| 13| }; 1334| 13| (void)bGamma; 1335| 13|} _ZNK6Assimp19Discreet3DSImporter16ContainsTexturesEj: 201| 2| bool ContainsTextures(unsigned int i) const { 202| 2| return !mScene->mMaterials[i].sTexDiffuse.mMapName.empty() || ------------------ | Branch (202:16): [True: 0, False: 2] ------------------ 203| 2| !mScene->mMaterials[i].sTexBump.mMapName.empty() || ------------------ | Branch (203:16): [True: 0, False: 2] ------------------ 204| 2| !mScene->mMaterials[i].sTexOpacity.mMapName.empty() || ------------------ | Branch (204:16): [True: 0, False: 2] ------------------ 205| 2| !mScene->mMaterials[i].sTexEmissive.mMapName.empty() || ------------------ | Branch (205:16): [True: 0, False: 2] ------------------ 206| 2| !mScene->mMaterials[i].sTexSpecular.mMapName.empty() || ------------------ | Branch (206:16): [True: 0, False: 2] ------------------ 207| 2| !mScene->mMaterials[i].sTexShininess.mMapName.empty() ; ------------------ | Branch (207:16): [True: 0, False: 2] ------------------ 208| 2| } _ZN6Assimp19Discreet3DSImporterD2Ev: 65| 624| ~Discreet3DSImporter() override = default; _ZNK6Assimp12D3MFImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 84| 43|bool D3MFImporter::CanRead(const std::string &filename, IOSystem *pIOHandler, bool ) const { 85| 43| if (!ZipArchiveIOSystem::isZipArchive(pIOHandler, filename)) { ------------------ | Branch (85:9): [True: 36, False: 7] ------------------ 86| 36| return false; 87| 36| } 88| 7| static constexpr char ModelRef[] = "3D/3dmodel.model"; 89| 7| ZipArchiveIOSystem archive(pIOHandler, filename); 90| 7| if (!archive.Exists(ModelRef)) { ------------------ | Branch (90:9): [True: 7, False: 0] ------------------ 91| 7| return false; 92| 7| } 93| | 94| 0| return true; 95| 7|} _ZNK6Assimp12D3MFImporter7GetInfoEv: 101| 634|const aiImporterDesc *D3MFImporter::GetInfo() const { 102| 634| return &desc; 103| 634|} _ZN6Assimp12D3MFImporterC2Ev: 59| 624| D3MFImporter() = default; _ZN6Assimp12AC3DImporterC2Ev: 161| 624| mBuffer(), 162| | configSplitBFCull(), 163| | configEvalSubdivision(), 164| | mNumMeshes(), 165| | mLights(), 166| 624| mLightsCounter(0), 167| 624| mGroupsCounter(0), 168| 624| mPolysCounter(0), 169| 624| mWorldsCounter(0) { 170| | // nothing to be done here 171| 624|} _ZNK6Assimp12AC3DImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 175| 352|bool AC3DImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 176| 352| static constexpr uint32_t tokens[] = { AI_MAKE_MAGIC("AC3D") }; 177| | return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); 178| 352|} _ZNK6Assimp12AC3DImporter7GetInfoEv: 182| 639|const aiImporterDesc *AC3DImporter::GetInfo() const { 183| 639| return &desc; 184| 639|} _ZN6Assimp12AC3DImporter11GetNextLineEv: 188| 42.3k|bool AC3DImporter::GetNextLine() { 189| 42.3k| SkipLine(&mBuffer.data, mBuffer.end); 190| 42.3k| return SkipSpaces(&mBuffer.data, mBuffer.end); 191| 42.3k|} _ZN6Assimp12AC3DImporter17LoadObjectSectionERNSt3__16vectorINS0_6ObjectENS1_9allocatorIS3_EEEE: 195| 13|bool AC3DImporter::LoadObjectSection(std::vector &objects) { 196| 13| if (!TokenMatch(mBuffer.data, "OBJECT", 6)) { ------------------ | Branch (196:9): [True: 0, False: 13] ------------------ 197| 0| return false; 198| 0| } 199| | 200| 13| SkipSpaces(&mBuffer.data, mBuffer.end); 201| | 202| 13| ++mNumMeshes; 203| | 204| 13| objects.emplace_back(); 205| 13| Object &obj = objects.back(); 206| | 207| 13| aiLight *light = nullptr; 208| 13| if (!ASSIMP_strincmp(mBuffer.data, "light", 5)) { ------------------ | Branch (208:9): [True: 3, False: 10] ------------------ 209| | // This is a light source. Add it to the list 210| 3| mLights->push_back(light = new aiLight()); 211| | 212| | // Return a point light with no attenuation 213| 3| light->mType = aiLightSource_POINT; 214| 3| light->mColorDiffuse = light->mColorSpecular = aiColor3D(1.f, 1.f, 1.f); 215| 3| light->mAttenuationConstant = 1.f; 216| | 217| | // Generate a default name for both the light source and the node 218| 3| light->mName.length = ::ai_snprintf(light->mName.data, AI_MAXLEN, "ACLight_%i", static_cast(mLights->size()) - 1); 219| 3| obj.name = std::string(light->mName.data); 220| | 221| 3| ASSIMP_LOG_VERBOSE_DEBUG("AC3D: Light source encountered"); 222| 3| obj.type = Object::Light; 223| 10| } else if (!ASSIMP_strincmp(mBuffer.data, "group", 5)) { ------------------ | Branch (223:16): [True: 0, False: 10] ------------------ 224| 0| obj.type = Object::Group; 225| 10| } else if (!ASSIMP_strincmp(mBuffer.data, "world", 5)) { ------------------ | Branch (225:16): [True: 5, False: 5] ------------------ 226| 5| obj.type = Object::World; 227| 5| } else { 228| 5| obj.type = Object::Poly; 229| 5| } 230| | 231| 51| while (GetNextLine()) { ------------------ | Branch (231:12): [True: 51, False: 0] ------------------ 232| 51| if (TokenMatch(mBuffer.data, "kids", 4)) { ------------------ | Branch (232:13): [True: 13, False: 38] ------------------ 233| 13| SkipSpaces(&mBuffer.data, mBuffer.end); 234| 13| unsigned int num = strtoul10(mBuffer.data, &mBuffer.data); 235| 13| GetNextLine(); 236| 13| if (num) { ------------------ | Branch (236:17): [True: 5, False: 8] ------------------ 237| | // load the children of this object recursively 238| 5| obj.children.reserve(num); 239| 13| for (unsigned int i = 0; i < num; ++i) { ------------------ | Branch (239:42): [True: 8, False: 5] ------------------ 240| 8| if (!LoadObjectSection(obj.children)) { ------------------ | Branch (240:25): [True: 0, False: 8] ------------------ 241| 0| ASSIMP_LOG_WARN("AC3D: wrong number of kids"); 242| 0| break; 243| 0| } 244| 8| } 245| 5| } 246| 13| return true; 247| 38| } else if (TokenMatch(mBuffer.data, "name", 4)) { ------------------ | Branch (247:20): [True: 8, False: 30] ------------------ 248| 8| SkipSpaces(&mBuffer.data, mBuffer.data); 249| 8| mBuffer.data = AcGetString(mBuffer.data, mBuffer.end, obj.name); 250| | 251| | // If this is a light source, we'll also need to store 252| | // the name of the node in it. 253| 8| if (light) { ------------------ | Branch (253:17): [True: 3, False: 5] ------------------ 254| 3| light->mName.Set(obj.name); 255| 3| } 256| 30| } else if (TokenMatch(mBuffer.data, "texture", 7)) { ------------------ | Branch (256:20): [True: 6, False: 24] ------------------ 257| 6| SkipSpaces(&mBuffer.data, mBuffer.end); 258| 6| std::string texture; 259| 6| mBuffer.data = AcGetString(mBuffer.data, mBuffer.end, texture); 260| 6| obj.textures.push_back(texture); 261| 24| } else if (TokenMatch(mBuffer.data, "texrep", 6)) { ------------------ | Branch (261:20): [True: 1, False: 23] ------------------ 262| 1| SkipSpaces(&mBuffer.data, mBuffer.end); 263| 1| mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "", 0, 2, &obj.texRepeat); 264| 1| if (!obj.texRepeat.x || !obj.texRepeat.y) ------------------ | Branch (264:17): [True: 0, False: 1] | Branch (264:37): [True: 0, False: 1] ------------------ 265| 0| obj.texRepeat = aiVector2D(1.f, 1.f); 266| 23| } else if (TokenMatch(mBuffer.data, "texoff", 6)) { ------------------ | Branch (266:20): [True: 1, False: 22] ------------------ 267| 1| SkipSpaces(&mBuffer.data, mBuffer.end); 268| 1| mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "", 0, 2, &obj.texOffset); 269| 22| } else if (TokenMatch(mBuffer.data, "rot", 3)) { ------------------ | Branch (269:20): [True: 0, False: 22] ------------------ 270| 0| SkipSpaces(&mBuffer.data, mBuffer.end); 271| 0| mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "", 0, 9, &obj.rotation); 272| 22| } else if (TokenMatch(mBuffer.data, "loc", 3)) { ------------------ | Branch (272:20): [True: 5, False: 17] ------------------ 273| 5| SkipSpaces(&mBuffer.data, mBuffer.end); 274| 5| mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "", 0, 3, &obj.translation); 275| 17| } else if (TokenMatch(mBuffer.data, "subdiv", 6)) { ------------------ | Branch (275:20): [True: 2, False: 15] ------------------ 276| 2| SkipSpaces(&mBuffer.data, mBuffer.end); 277| 2| obj.subDiv = strtoul10(mBuffer.data, &mBuffer.data); 278| 15| } else if (TokenMatch(mBuffer.data, "crease", 6)) { ------------------ | Branch (278:20): [True: 3, False: 12] ------------------ 279| 3| SkipSpaces(&mBuffer.data, mBuffer.end); 280| 3| obj.crease = fast_atof(mBuffer.data); 281| 12| } else if (TokenMatch(mBuffer.data, "numvert", 7)) { ------------------ | Branch (281:20): [True: 5, False: 7] ------------------ 282| 5| SkipSpaces(&mBuffer.data, mBuffer.end); 283| | 284| 5| unsigned int t = strtoul10(mBuffer.data, &mBuffer.data); 285| 5| if (t >= AI_MAX_ALLOC(aiVector3D)) { ------------------ | Branch (285:17): [True: 0, False: 5] ------------------ 286| 0| throw DeadlyImportError("AC3D: Too many vertices, would run out of memory"); 287| 0| } 288| 5| obj.vertices.reserve(t); 289| 6.79k| for (unsigned int i = 0; i < t; ++i) { ------------------ | Branch (289:38): [True: 6.79k, False: 4] ------------------ 290| 6.79k| if (!GetNextLine()) { ------------------ | Branch (290:21): [True: 0, False: 6.79k] ------------------ 291| 0| ASSIMP_LOG_ERROR("AC3D: Unexpected EOF: not all vertices have been parsed yet"); 292| 0| break; 293| 6.79k| } else if (!IsNumeric(*mBuffer.data)) { ------------------ | Branch (293:28): [True: 1, False: 6.78k] ------------------ 294| 1| ASSIMP_LOG_ERROR("AC3D: Unexpected token: not all vertices have been parsed yet"); 295| 1| --mBuffer.data; // make sure the line is processed a second time 296| 1| break; 297| 1| } 298| 6.78k| obj.vertices.emplace_back(); 299| 6.78k| aiVector3D &v = obj.vertices.back(); 300| 6.78k| mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "", 0, 3, &v.x); 301| 6.78k| } 302| 7| } else if (TokenMatch(mBuffer.data, "numsurf", 7)) { ------------------ | Branch (302:20): [True: 5, False: 2] ------------------ 303| 5| SkipSpaces(&mBuffer.data, mBuffer.end); 304| | 305| 5| bool Q3DWorkAround = false; 306| | 307| 5| const unsigned int t = strtoul10(mBuffer.data, &mBuffer.data); 308| 5| obj.surfaces.reserve(t); 309| 4.38k| for (unsigned int i = 0; i < t; ++i) { ------------------ | Branch (309:38): [True: 4.37k, False: 5] ------------------ 310| 4.37k| GetNextLine(); 311| 4.37k| if (!TokenMatch(mBuffer.data, "SURF", 4)) { ------------------ | Branch (311:21): [True: 0, False: 4.37k] ------------------ 312| | // FIX: this can occur for some files - Quick 3D for 313| | // example writes no surf chunks 314| 0| if (!Q3DWorkAround) { ------------------ | Branch (314:25): [True: 0, False: 0] ------------------ 315| 0| ASSIMP_LOG_WARN("AC3D: SURF token was expected"); 316| 0| ASSIMP_LOG_VERBOSE_DEBUG("Continuing with Quick3D Workaround enabled"); 317| 0| } 318| 0| --mBuffer.data; // make sure the line is processed a second time 319| | // break; --- see fix notes above 320| | 321| 0| Q3DWorkAround = true; 322| 0| } 323| 4.37k| SkipSpaces(&mBuffer.data, mBuffer.end); 324| 4.37k| obj.surfaces.emplace_back(); 325| 4.37k| Surface &surf = obj.surfaces.back(); 326| 4.37k| surf.flags = strtoul_cppstyle(mBuffer.data); 327| | 328| 13.1k| while (true) { ------------------ | Branch (328:24): [True: 13.1k, Folded] ------------------ 329| 13.1k| if (!GetNextLine()) { ------------------ | Branch (329:25): [True: 0, False: 13.1k] ------------------ 330| 0| throw DeadlyImportError("AC3D: Unexpected EOF: surface is incomplete"); 331| 0| } 332| 13.1k| if (TokenMatch(mBuffer.data, "mat", 3)) { ------------------ | Branch (332:25): [True: 4.37k, False: 8.75k] ------------------ 333| 4.37k| SkipSpaces(&mBuffer.data, mBuffer.end); 334| 4.37k| surf.mat = strtoul10(mBuffer.data); 335| 8.75k| } else if (TokenMatch(mBuffer.data, "refs", 4)) { ------------------ | Branch (335:32): [True: 4.37k, False: 4.37k] ------------------ 336| | // --- see fix notes above 337| 4.37k| if (Q3DWorkAround) { ------------------ | Branch (337:29): [True: 0, False: 4.37k] ------------------ 338| 0| if (!surf.entries.empty()) { ------------------ | Branch (338:33): [True: 0, False: 0] ------------------ 339| 0| mBuffer.data -= 6; 340| 0| break; 341| 0| } 342| 0| } 343| | 344| 4.37k| SkipSpaces(&mBuffer.data, mBuffer.end); 345| 4.37k| const unsigned int m = strtoul10(mBuffer.data); 346| 4.37k| surf.entries.reserve(m); 347| | 348| 4.37k| obj.numRefs += m; 349| | 350| 22.3k| for (unsigned int k = 0; k < m; ++k) { ------------------ | Branch (350:50): [True: 17.9k, False: 4.37k] ------------------ 351| 17.9k| if (!GetNextLine()) { ------------------ | Branch (351:33): [True: 0, False: 17.9k] ------------------ 352| 0| ASSIMP_LOG_ERROR("AC3D: Unexpected EOF: surface references are incomplete"); 353| 0| break; 354| 0| } 355| 17.9k| surf.entries.emplace_back(); 356| 17.9k| Surface::SurfaceEntry &entry = surf.entries.back(); 357| | 358| 17.9k| entry.first = strtoul10(mBuffer.data, &mBuffer.data); 359| 17.9k| SkipSpaces(&mBuffer.data, mBuffer.end); 360| 17.9k| mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "", 0, 2, &entry.second); 361| 17.9k| } 362| 4.37k| } else { 363| 4.37k| --mBuffer.data; // make sure the line is processed a second time 364| 4.37k| break; 365| 4.37k| } 366| 13.1k| } 367| 4.37k| } 368| 5| } 369| 51| } 370| 13| ASSIMP_LOG_ERROR("AC3D: Unexpected EOF: \'kids\' line was expected"); 371| | 372| 0| return false; 373| 13|} _ZN6Assimp12AC3DImporter15ConvertMaterialERKNS0_6ObjectERKNS0_8MaterialER10aiMaterial: 379| 5| aiMaterial &matDest) { 380| 5| aiString s; 381| | 382| 5| if (matSrc.name.length()) { ------------------ | Branch (382:9): [True: 5, False: 0] ------------------ 383| 5| s.Set(matSrc.name); 384| 5| matDest.AddProperty(&s, AI_MATKEY_NAME); 385| 5| } 386| 5| if (!object.textures.empty()) { ------------------ | Branch (386:9): [True: 3, False: 2] ------------------ 387| 3| s.Set(object.textures[0]); 388| 3| matDest.AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0)); 389| | 390| | // UV transformation 391| 3| if (1.f != object.texRepeat.x || 1.f != object.texRepeat.y || ------------------ | Branch (391:13): [True: 1, False: 2] | Branch (391:42): [True: 0, False: 2] ------------------ 392| 2| object.texOffset.x || object.texOffset.y) { ------------------ | Branch (392:17): [True: 0, False: 2] | Branch (392:39): [True: 0, False: 2] ------------------ 393| 1| aiUVTransform transform; 394| 1| transform.mScaling = object.texRepeat; 395| 1| transform.mTranslation = object.texOffset; 396| 1| matDest.AddProperty(&transform, 1, AI_MATKEY_UVTRANSFORM_DIFFUSE(0)); 397| 1| } 398| 3| } 399| | 400| 5| matDest.AddProperty(&matSrc.rgb, 1, AI_MATKEY_COLOR_DIFFUSE); 401| 5| matDest.AddProperty(&matSrc.amb, 1, AI_MATKEY_COLOR_AMBIENT); 402| 5| matDest.AddProperty(&matSrc.emis, 1, AI_MATKEY_COLOR_EMISSIVE); 403| 5| matDest.AddProperty(&matSrc.spec, 1, AI_MATKEY_COLOR_SPECULAR); 404| | 405| 5| int n = -1; 406| 5| if (matSrc.shin) { ------------------ | Branch (406:9): [True: 3, False: 2] ------------------ 407| 3| n = aiShadingMode_Phong; 408| 3| matDest.AddProperty(&matSrc.shin, 1, AI_MATKEY_SHININESS); 409| 3| } else { 410| 2| n = aiShadingMode_Gouraud; 411| 2| } 412| 5| matDest.AddProperty(&n, 1, AI_MATKEY_SHADING_MODEL); 413| | 414| 5| float f = 1.f - matSrc.trans; 415| | matDest.AddProperty(&f, 1, AI_MATKEY_OPACITY); 416| 5|} _ZN6Assimp12AC3DImporter20ConvertObjectSectionERNS0_6ObjectERNSt3__16vectorIP6aiMeshNS3_9allocatorIS6_EEEERNS4_IP10aiMaterialNS7_ISC_EEEERKNS4_INS0_8MaterialENS7_ISG_EEEEP6aiNode: 424| 13| aiNode *parent) { 425| 13| aiNode *node = new aiNode(); 426| 13| node->mParent = parent; 427| 13| if (object.vertices.size()) { ------------------ | Branch (427:9): [True: 5, False: 8] ------------------ 428| 5| if (!object.surfaces.size() || !object.numRefs) { ------------------ | Branch (428:13): [True: 0, False: 5] | Branch (428:40): [True: 0, False: 5] ------------------ 429| | /* " An object with 7 vertices (no surfaces, no materials defined). 430| | This is a good way of getting point data into AC3D. 431| | The Vertex->create convex-surface/object can be used on these 432| | vertices to 'wrap' a 3d shape around them " 433| | (http://www.opencity.info/html/ac3dfileformat.html) 434| | 435| | therefore: if no surfaces are defined return point data only 436| | */ 437| | 438| 0| ASSIMP_LOG_INFO("AC3D: No surfaces defined in object definition, " 439| 0| "a point list is returned"); 440| | 441| 0| meshes.push_back(new aiMesh()); 442| 0| aiMesh *mesh = meshes.back(); 443| | 444| 0| mesh->mNumFaces = mesh->mNumVertices = (unsigned int)object.vertices.size(); 445| 0| aiFace *faces = mesh->mFaces = new aiFace[mesh->mNumFaces]; 446| 0| aiVector3D *verts = mesh->mVertices = new aiVector3D[mesh->mNumVertices]; 447| | 448| 0| for (unsigned int i = 0; i < mesh->mNumVertices; ++i, ++faces, ++verts) { ------------------ | Branch (448:38): [True: 0, False: 0] ------------------ 449| 0| *verts = object.vertices[i]; 450| 0| faces->mNumIndices = 1; 451| 0| faces->mIndices = new unsigned int[1]; 452| 0| faces->mIndices[0] = i; 453| 0| } 454| | 455| | // use the primary material in this case. this should be the 456| | // default material if all objects of the file contain points 457| | // and no faces. 458| 0| mesh->mMaterialIndex = 0; 459| 0| outMaterials.push_back(new aiMaterial()); 460| 0| ConvertMaterial(object, materials[0], *outMaterials.back()); 461| 5| } else { 462| | // need to generate one or more meshes for this object. 463| | // find out how many different materials we have 464| 5| typedef std::pair IntPair; 465| 5| typedef std::vector MatTable; 466| 5| MatTable needMat(materials.size(), IntPair(0, 0)); 467| | 468| 5| std::vector::iterator it, end = object.surfaces.end(); 469| 5| std::vector::iterator it2, end2; 470| | 471| 4.38k| for (it = object.surfaces.begin(); it != end; ++it) { ------------------ | Branch (471:48): [True: 4.37k, False: 5] ------------------ 472| 4.37k| unsigned int idx = (*it).mat; 473| 4.37k| if (idx >= needMat.size()) { ------------------ | Branch (473:21): [True: 0, False: 4.37k] ------------------ 474| 0| ASSIMP_LOG_ERROR("AC3D: material index is out of range"); 475| 0| idx = 0; 476| 0| } 477| 4.37k| if ((*it).entries.empty()) { ------------------ | Branch (477:21): [True: 0, False: 4.37k] ------------------ 478| 0| ASSIMP_LOG_WARN("AC3D: surface has zero vertex references"); 479| 0| } 480| 4.37k| const bool isDoubleSided = ACDoubleSidedFlag == (it->flags & ACDoubleSidedFlag); 481| 4.37k| const int doubleSidedFactor = isDoubleSided ? 2 : 1; ------------------ | Branch (481:47): [True: 345, False: 4.03k] ------------------ 482| | 483| | // validate all vertex indices to make sure we won't crash here 484| 4.37k| for (it2 = (*it).entries.begin(), 485| 4.37k| end2 = (*it).entries.end(); 486| 22.3k| it2 != end2; ++it2) { ------------------ | Branch (486:25): [True: 17.9k, False: 4.37k] ------------------ 487| 17.9k| if ((*it2).first >= object.vertices.size()) { ------------------ | Branch (487:25): [True: 35, False: 17.9k] ------------------ 488| 35| ASSIMP_LOG_WARN("AC3D: Invalid vertex reference"); 489| 35| (*it2).first = 0; 490| 35| } 491| 17.9k| } 492| | 493| 4.37k| if (!needMat[idx].first) { ------------------ | Branch (493:21): [True: 5, False: 4.37k] ------------------ 494| 5| ++node->mNumMeshes; 495| 5| } 496| | 497| 4.37k| switch ((*it).GetType()) { 498| 0| case Surface::ClosedLine: // closed line ------------------ | Branch (498:17): [True: 0, False: 4.37k] ------------------ 499| 0| needMat[idx].first += static_cast((*it).entries.size()); 500| 0| needMat[idx].second += static_cast((*it).entries.size() << 1u); 501| 0| break; 502| | 503| | // unclosed line 504| 0| case Surface::OpenLine: ------------------ | Branch (504:17): [True: 0, False: 4.37k] ------------------ 505| 0| needMat[idx].first += static_cast((*it).entries.size() - 1); 506| 0| needMat[idx].second += static_cast(((*it).entries.size() - 1) << 1u); 507| 0| break; 508| | 509| | // triangle strip 510| 358| case Surface::TriangleStrip: ------------------ | Branch (510:17): [True: 358, False: 4.02k] ------------------ 511| 358| needMat[idx].first += static_cast(it->entries.size() - 2) * doubleSidedFactor; 512| 358| needMat[idx].second += static_cast(it->entries.size() - 2) * 3 * doubleSidedFactor; 513| 358| break; 514| | 515| 0| default: ------------------ | Branch (515:17): [True: 0, False: 4.37k] ------------------ 516| | // Coerce unknowns to a polygon and warn 517| 0| ASSIMP_LOG_WARN("AC3D: The type flag of a surface is unknown: ", (*it).flags); 518| 0| (*it).flags &= ~(Surface::Mask); 519| | // fallthrough 520| | 521| | // polygon 522| 4.02k| case Surface::Polygon: ------------------ | Branch (522:17): [True: 4.02k, False: 358] ------------------ 523| | // the number of faces increments by one, the number 524| | // of vertices by surface.numref. 525| 4.02k| needMat[idx].first += doubleSidedFactor; 526| 4.02k| needMat[idx].second += static_cast(it->entries.size()) * doubleSidedFactor; 527| 4.37k| }; 528| 4.37k| } 529| 5| unsigned int *pip = node->mMeshes = new unsigned int[node->mNumMeshes]; 530| 5| unsigned int mat = 0; 531| 5| const size_t oldm = meshes.size(); 532| 5| for (MatTable::const_iterator cit = needMat.begin(), cend = needMat.end(); 533| 10| cit != cend; ++cit, ++mat) { ------------------ | Branch (533:21): [True: 5, False: 5] ------------------ 534| 5| if (!(*cit).first) { ------------------ | Branch (534:21): [True: 0, False: 5] ------------------ 535| 0| continue; 536| 0| } 537| | 538| | // allocate a new aiMesh object 539| 5| *pip++ = (unsigned int)meshes.size(); 540| 5| aiMesh *mesh = new aiMesh(); 541| 5| meshes.push_back(mesh); 542| | 543| 5| mesh->mMaterialIndex = static_cast(outMaterials.size()); 544| 5| outMaterials.push_back(new aiMaterial()); 545| 5| ConvertMaterial(object, materials[mat], *outMaterials.back()); 546| | 547| | // allocate storage for vertices and normals 548| 5| mesh->mNumFaces = (*cit).first; 549| 5| if (mesh->mNumFaces == 0) { ------------------ | Branch (549:21): [True: 0, False: 5] ------------------ 550| 0| throw DeadlyImportError("AC3D: No faces"); 551| 5| } else if (mesh->mNumFaces > AI_MAX_ALLOC(aiFace)) { ------------------ | Branch (551:28): [True: 0, False: 5] ------------------ 552| 0| throw DeadlyImportError("AC3D: Too many faces, would run out of memory"); 553| 0| } 554| 5| aiFace *faces = mesh->mFaces = new aiFace[mesh->mNumFaces]; 555| | 556| 5| mesh->mNumVertices = (*cit).second; 557| 5| if (mesh->mNumVertices == 0) { ------------------ | Branch (557:21): [True: 0, False: 5] ------------------ 558| 0| throw DeadlyImportError("AC3D: No vertices"); 559| 5| } else if (mesh->mNumVertices > AI_MAX_ALLOC(aiVector3D)) { ------------------ | Branch (559:28): [True: 0, False: 5] ------------------ 560| 0| throw DeadlyImportError("AC3D: Too many vertices, would run out of memory"); 561| 0| } 562| 5| aiVector3D *vertices = mesh->mVertices = new aiVector3D[mesh->mNumVertices]; 563| 5| unsigned int cur = 0; 564| | 565| | // allocate UV coordinates, but only if the texture name for the 566| | // surface is not empty 567| 5| aiVector3D *uv = nullptr; 568| 5| if (!object.textures.empty()) { ------------------ | Branch (568:21): [True: 3, False: 2] ------------------ 569| 3| uv = mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices]; 570| 3| mesh->mNumUVComponents[0] = 2; 571| 3| } 572| | 573| 4.38k| for (it = object.surfaces.begin(); it != end; ++it) { ------------------ | Branch (573:52): [True: 4.37k, False: 5] ------------------ 574| 4.37k| if (mat == (*it).mat) { ------------------ | Branch (574:25): [True: 4.37k, False: 0] ------------------ 575| 4.37k| const Surface &src = *it; 576| 4.37k| const bool isDoubleSided = ACDoubleSidedFlag == (src.flags & ACDoubleSidedFlag); 577| | 578| | // closed polygon 579| 4.37k| uint8_t type = (*it).GetType(); 580| 4.37k| if (type == Surface::Polygon) { ------------------ | Branch (580:29): [True: 4.02k, False: 358] ------------------ 581| 4.02k| aiFace &face = *faces++; 582| 4.02k| face.mNumIndices = (unsigned int)src.entries.size(); 583| 4.02k| if (0 != face.mNumIndices) { ------------------ | Branch (583:33): [True: 4.02k, False: 0] ------------------ 584| 4.02k| face.mIndices = new unsigned int[face.mNumIndices]; 585| 16.3k| for (unsigned int i = 0; i < face.mNumIndices; ++i, ++vertices) { ------------------ | Branch (585:58): [True: 12.3k, False: 4.02k] ------------------ 586| 12.3k| const Surface::SurfaceEntry &entry = src.entries[i]; 587| 12.3k| face.mIndices[i] = cur++; 588| | 589| | // copy vertex positions 590| 12.3k| if (static_cast(vertices - mesh->mVertices) >= mesh->mNumVertices) { ------------------ | Branch (590:41): [True: 0, False: 12.3k] ------------------ 591| 0| throw DeadlyImportError("AC3D: Invalid number of vertices"); 592| 0| } 593| 12.3k| *vertices = object.vertices[entry.first] + object.translation; 594| | 595| | // copy texture coordinates 596| 12.3k| if (uv) { ------------------ | Branch (596:41): [True: 1.10k, False: 11.1k] ------------------ 597| 1.10k| uv->x = entry.second.x; 598| 1.10k| uv->y = entry.second.y; 599| 1.10k| ++uv; 600| 1.10k| } 601| 12.3k| } 602| 4.02k| if(isDoubleSided) // Need a backface? ------------------ | Branch (602:36): [True: 0, False: 4.02k] ------------------ 603| 0| buildBacksideOfFace(faces[-1], faces, vertices, mesh->mVertices, uv, mesh->mTextureCoords[0], cur); 604| 4.02k| } 605| 4.02k| } else if (type == Surface::TriangleStrip) { ------------------ | Branch (605:36): [True: 358, False: 0] ------------------ 606| 5.27k| for (unsigned int i = 0; i < (unsigned int)src.entries.size() - 2; ++i) { ------------------ | Branch (606:54): [True: 4.91k, False: 358] ------------------ 607| 4.91k| const Surface::SurfaceEntry &entry1 = src.entries[i]; 608| 4.91k| const Surface::SurfaceEntry &entry2 = src.entries[i + 1]; 609| 4.91k| const Surface::SurfaceEntry &entry3 = src.entries[i + 2]; 610| 4.91k| const unsigned int verticesNeeded = isDoubleSided ? 6 : 3; ------------------ | Branch (610:69): [True: 4.63k, False: 286] ------------------ 611| 4.91k| if (static_cast(vertices - mesh->mVertices) + verticesNeeded > mesh->mNumVertices) { ------------------ | Branch (611:37): [True: 0, False: 4.91k] ------------------ 612| 0| throw DeadlyImportError("AC3D: Invalid number of vertices"); 613| 0| } 614| | 615| 4.91k| aiFace &face = *faces++; 616| 4.91k| face.mNumIndices = 3; 617| 4.91k| face.mIndices = new unsigned int[face.mNumIndices]; 618| 4.91k| face.mIndices[0] = cur++; 619| 4.91k| face.mIndices[1] = cur++; 620| 4.91k| face.mIndices[2] = cur++; 621| 4.91k| if (!(i & 1)) { ------------------ | Branch (621:37): [True: 2.55k, False: 2.36k] ------------------ 622| 2.55k| *vertices++ = object.vertices[entry1.first] + object.translation; 623| 2.55k| if (uv) { ------------------ | Branch (623:41): [True: 144, False: 2.40k] ------------------ 624| 144| uv->x = entry1.second.x; 625| 144| uv->y = entry1.second.y; 626| 144| ++uv; 627| 144| } 628| 2.55k| *vertices++ = object.vertices[entry2.first] + object.translation; 629| 2.55k| if (uv) { ------------------ | Branch (629:41): [True: 144, False: 2.40k] ------------------ 630| 144| uv->x = entry2.second.x; 631| 144| uv->y = entry2.second.y; 632| 144| ++uv; 633| 144| } 634| 2.55k| } else { 635| 2.36k| *vertices++ = object.vertices[entry2.first] + object.translation; 636| 2.36k| if (uv) { ------------------ | Branch (636:41): [True: 142, False: 2.22k] ------------------ 637| 142| uv->x = entry2.second.x; 638| 142| uv->y = entry2.second.y; 639| 142| ++uv; 640| 142| } 641| 2.36k| *vertices++ = object.vertices[entry1.first] + object.translation; 642| 2.36k| if (uv) { ------------------ | Branch (642:41): [True: 142, False: 2.22k] ------------------ 643| 142| uv->x = entry1.second.x; 644| 142| uv->y = entry1.second.y; 645| 142| ++uv; 646| 142| } 647| 2.36k| } 648| 4.91k| if (static_cast(vertices - mesh->mVertices) >= mesh->mNumVertices) { ------------------ | Branch (648:37): [True: 0, False: 4.91k] ------------------ 649| 0| throw DeadlyImportError("AC3D: Invalid number of vertices"); 650| 0| } 651| 4.91k| *vertices++ = object.vertices[entry3.first] + object.translation; 652| 4.91k| if (uv) { ------------------ | Branch (652:37): [True: 286, False: 4.63k] ------------------ 653| 286| uv->x = entry3.second.x; 654| 286| uv->y = entry3.second.y; 655| 286| ++uv; 656| 286| } 657| 4.91k| if(isDoubleSided) // Need a backface? ------------------ | Branch (657:36): [True: 4.63k, False: 286] ------------------ 658| 4.63k| buildBacksideOfFace(faces[-1], faces, vertices, mesh->mVertices, uv, mesh->mTextureCoords[0], cur); 659| 4.91k| } 660| 358| } else { 661| | 662| 0| it2 = (*it).entries.begin(); 663| | 664| | // either a closed or an unclosed line 665| 0| unsigned int tmp = (unsigned int)(*it).entries.size(); 666| 0| if (Surface::OpenLine == type) --tmp; ------------------ | Branch (666:33): [True: 0, False: 0] ------------------ 667| 0| for (unsigned int m = 0; m < tmp; ++m) { ------------------ | Branch (667:54): [True: 0, False: 0] ------------------ 668| 0| if (static_cast(vertices - mesh->mVertices) + 2 > mesh->mNumVertices) { ------------------ | Branch (668:37): [True: 0, False: 0] ------------------ 669| 0| throw DeadlyImportError("AC3D: Invalid number of vertices"); 670| 0| } 671| | 672| 0| aiFace &face = *faces++; 673| | 674| 0| face.mNumIndices = 2; 675| 0| face.mIndices = new unsigned int[2]; 676| 0| face.mIndices[0] = cur++; 677| 0| face.mIndices[1] = cur++; 678| | 679| | // copy vertex positions 680| 0| if (it2 == (*it).entries.end()) { ------------------ | Branch (680:37): [True: 0, False: 0] ------------------ 681| 0| throw DeadlyImportError("AC3D: Bad line"); 682| 0| } 683| 0| ai_assert((*it2).first < object.vertices.size()); 684| 0| *vertices++ = object.vertices[(*it2).first]; 685| | 686| | // copy texture coordinates 687| 0| if (uv) { ------------------ | Branch (687:37): [True: 0, False: 0] ------------------ 688| 0| uv->x = (*it2).second.x; 689| 0| uv->y = (*it2).second.y; 690| 0| ++uv; 691| 0| } 692| | 693| 0| if (Surface::ClosedLine == type && tmp - 1 == m) { ------------------ | Branch (693:37): [True: 0, False: 0] | Branch (693:68): [True: 0, False: 0] ------------------ 694| | // if this is a closed line repeat its beginning now 695| 0| it2 = (*it).entries.begin(); 696| 0| } else 697| 0| ++it2; 698| | 699| | // second point 700| 0| *vertices++ = object.vertices[(*it2).first]; 701| | 702| 0| if (uv) { ------------------ | Branch (702:37): [True: 0, False: 0] ------------------ 703| 0| uv->x = (*it2).second.x; 704| 0| uv->y = (*it2).second.y; 705| 0| ++uv; 706| 0| } 707| 0| } 708| 0| } 709| 4.37k| } 710| 4.37k| } 711| 5| } 712| | 713| | // Now apply catmull clark subdivision if necessary. We split meshes into 714| | // materials which is not done by AC3D during smoothing, so we need to 715| | // collect all meshes using the same material group. 716| 5| if (object.subDiv) { ------------------ | Branch (716:17): [True: 2, False: 3] ------------------ 717| 2| if (configEvalSubdivision) { ------------------ | Branch (717:21): [True: 2, False: 0] ------------------ 718| 2| std::unique_ptr div(Subdivider::Create(Subdivider::CATMULL_CLARKE)); 719| 2| ASSIMP_LOG_INFO("AC3D: Evaluating subdivision surface: ", object.name); 720| | 721| 2| std::vector cpy(meshes.size() - oldm, nullptr); 722| 2| div->Subdivide(&meshes[oldm], cpy.size(), &cpy.front(), object.subDiv, true); 723| 2| std::copy(cpy.begin(), cpy.end(), meshes.begin() + oldm); 724| | 725| | // previous meshes are deleted vy Subdivide(). 726| 2| } else { 727| 0| ASSIMP_LOG_INFO("AC3D: Letting the subdivision surface untouched due to my configuration: ", object.name); 728| 0| } 729| 2| } 730| 5| } 731| 5| } 732| | 733| 13| if (object.name.length()) ------------------ | Branch (733:9): [True: 8, False: 5] ------------------ 734| 8| node->mName.Set(object.name); 735| 5| else { 736| | // generate a name depending on the type of the node 737| 5| switch (object.type) { ------------------ | Branch (737:17): [True: 5, False: 0] ------------------ 738| 0| case Object::Group: ------------------ | Branch (738:9): [True: 0, False: 5] ------------------ 739| 0| node->mName.length = ::ai_snprintf(node->mName.data, AI_MAXLEN, "ACGroup_%i", mGroupsCounter++); 740| 0| break; 741| 0| case Object::Poly: ------------------ | Branch (741:9): [True: 0, False: 5] ------------------ 742| 0| node->mName.length = ::ai_snprintf(node->mName.data, AI_MAXLEN, "ACPoly_%i", mPolysCounter++); 743| 0| break; 744| 0| case Object::Light: ------------------ | Branch (744:9): [True: 0, False: 5] ------------------ 745| 0| node->mName.length = ::ai_snprintf(node->mName.data, AI_MAXLEN, "ACLight_%i", mLightsCounter++); 746| 0| break; 747| | 748| | // there shouldn't be more than one world, but we don't care 749| 5| case Object::World: ------------------ | Branch (749:9): [True: 5, False: 0] ------------------ 750| 5| node->mName.length = ::ai_snprintf(node->mName.data, AI_MAXLEN, "ACWorld_%i", mWorldsCounter++); 751| 5| break; 752| 5| } 753| 5| } 754| | 755| | // setup the local transformation matrix of the object 756| | // compute the transformation offset to the parent node 757| 13| node->mTransformation = aiMatrix4x4(object.rotation); 758| | 759| 13| if (object.type == Object::Group || !object.numRefs) { ------------------ | Branch (759:9): [True: 0, False: 13] | Branch (759:41): [True: 8, False: 5] ------------------ 760| 8| node->mTransformation.a4 = object.translation.x; 761| 8| node->mTransformation.b4 = object.translation.y; 762| 8| node->mTransformation.c4 = object.translation.z; 763| 8| } 764| | 765| | // add children to the object 766| 13| if (object.children.size()) { ------------------ | Branch (766:9): [True: 5, False: 8] ------------------ 767| 5| node->mNumChildren = (unsigned int)object.children.size(); 768| 5| node->mChildren = new aiNode *[node->mNumChildren]; 769| 13| for (unsigned int i = 0; i < node->mNumChildren; ++i) { ------------------ | Branch (769:34): [True: 8, False: 5] ------------------ 770| 8| node->mChildren[i] = ConvertObjectSection(object.children[i], meshes, outMaterials, materials, node); 771| 8| } 772| 5| } 773| | 774| 13| return node; 775| 13|} _ZN6Assimp12AC3DImporter15SetupPropertiesEPKNS_8ImporterE: 778| 5|void AC3DImporter::SetupProperties(const Importer *pImp) { 779| 5| configSplitBFCull = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_AC_SEPARATE_BFCULL, 1) ? true : false; ------------------ | Branch (779:25): [True: 5, False: 0] ------------------ 780| 5| configEvalSubdivision = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_AC_EVAL_SUBDIVISION, 1) ? true : false; ------------------ | Branch (780:29): [True: 5, False: 0] ------------------ 781| 5|} _ZN6Assimp12AC3DImporter14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 786| 5| aiScene *pScene, IOSystem *pIOHandler) { 787| 5| std::unique_ptr file(pIOHandler->Open(pFile, "rb")); 788| | 789| | // Check whether we can read from the file 790| 5| if (file == nullptr) { ------------------ | Branch (790:9): [True: 0, False: 5] ------------------ 791| 0| throw DeadlyImportError("Failed to open AC3D file ", pFile, "."); 792| 0| } 793| | 794| | // allocate storage and copy the contents of the file to a memory buffer 795| 5| std::vector mBuffer2; 796| 5| TextFileToBuffer(file.get(), mBuffer2); 797| | 798| 5| mBuffer.data = &mBuffer2[0]; 799| 5| mBuffer.end = &mBuffer2[0] + mBuffer2.size(); 800| 5| mNumMeshes = 0; 801| | 802| 5| mLightsCounter = mPolysCounter = mWorldsCounter = mGroupsCounter = 0; 803| | 804| 5| if (::strncmp(mBuffer.data, "AC3D", 4)) { ------------------ | Branch (804:9): [True: 0, False: 5] ------------------ 805| 0| throw DeadlyImportError("AC3D: No valid AC3D file, magic sequence not found"); 806| 0| } 807| | 808| | // print the file format version to the console 809| 5| unsigned int version = HexDigitToDecimal(mBuffer.data[4]); 810| 5| char msg[3]; 811| 5| ASSIMP_itoa10(msg, 3, version); 812| 5| ASSIMP_LOG_INFO("AC3D file format version: ", msg); 813| | 814| 5| std::vector materials; 815| 5| materials.reserve(5); 816| | 817| 5| std::vector rootObjects; 818| 5| rootObjects.reserve(5); 819| | 820| 5| std::vector lights; 821| 5| mLights = &lights; 822| | 823| 15| while (GetNextLine()) { ------------------ | Branch (823:12): [True: 10, False: 5] ------------------ 824| 10| if (TokenMatch(mBuffer.data, "MATERIAL", 8)) { ------------------ | Branch (824:13): [True: 5, False: 5] ------------------ 825| 5| materials.emplace_back(); 826| 5| Material &mat = materials.back(); 827| | 828| | // manually parse the material ... sscanf would use the buldin atof ... 829| | // Format: (name) rgb %f %f %f amb %f %f %f emis %f %f %f spec %f %f %f shi %d trans %f 830| | 831| 5| mBuffer.data = AcSkipToNextToken(mBuffer.data, mBuffer.end); 832| 5| if ('\"' == *mBuffer.data) { ------------------ | Branch (832:17): [True: 5, False: 0] ------------------ 833| 5| mBuffer.data = AcGetString(mBuffer.data, mBuffer.end, mat.name); 834| 5| mBuffer.data = AcSkipToNextToken(mBuffer.data, mBuffer.end); 835| 5| } 836| | 837| 5| mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "rgb", 3, 3, &mat.rgb); 838| 5| mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "amb", 3, 3, &mat.amb); 839| 5| mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "emis", 4, 3, &mat.emis); 840| 5| mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "spec", 4, 3, &mat.spec); 841| 5| mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "shi", 3, 1, &mat.shin); 842| 5| mBuffer.data = TAcCheckedLoadFloatArray(mBuffer.data, mBuffer.end, "trans", 5, 1, &mat.trans); 843| 5| } else { 844| 5| LoadObjectSection(rootObjects); 845| 5| } 846| 10| } 847| | 848| 5| if (rootObjects.empty() || mNumMeshes == 0u) { ------------------ | Branch (848:9): [True: 0, False: 5] | Branch (848:32): [True: 0, False: 5] ------------------ 849| 0| throw DeadlyImportError("AC3D: No meshes have been loaded"); 850| 0| } 851| 5| if (materials.empty()) { ------------------ | Branch (851:9): [True: 0, False: 5] ------------------ 852| 0| ASSIMP_LOG_WARN("AC3D: No material has been found"); 853| 0| materials.emplace_back(); 854| 0| } 855| | 856| 5| mNumMeshes += (mNumMeshes >> 2u) + 1; 857| 5| std::vector meshes; 858| 5| meshes.reserve(mNumMeshes); 859| | 860| 5| std::vector omaterials; 861| 5| materials.reserve(mNumMeshes); 862| | 863| | // generate a dummy root if there are multiple objects on the top layer 864| 5| Object *root = nullptr; 865| 5| if (1 == rootObjects.size()) ------------------ | Branch (865:9): [True: 5, False: 0] ------------------ 866| 5| root = &rootObjects[0]; 867| 0| else { 868| 0| root = new Object(); 869| 0| } 870| | 871| | // now convert the imported stuff to our output data structure 872| 5| pScene->mRootNode = ConvertObjectSection(*root, meshes, omaterials, materials); 873| 5| if (1 != rootObjects.size()) { ------------------ | Branch (873:9): [True: 0, False: 5] ------------------ 874| 0| delete root; 875| 0| } 876| | 877| 5| if (::strncmp(pScene->mRootNode->mName.data, "Node", 4) == 0) { ------------------ | Branch (877:9): [True: 0, False: 5] ------------------ 878| 0| pScene->mRootNode->mName.Set(""); 879| 0| } 880| | 881| | // copy meshes 882| 5| if (meshes.empty()) { ------------------ | Branch (882:9): [True: 0, False: 5] ------------------ 883| 0| throw DeadlyImportError("An unknown error occurred during converting"); 884| 0| } 885| 5| pScene->mNumMeshes = (unsigned int)meshes.size(); 886| 5| pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]; 887| 5| ::memcpy(pScene->mMeshes, &meshes[0], pScene->mNumMeshes * sizeof(void *)); 888| | 889| | // copy materials 890| 5| pScene->mNumMaterials = (unsigned int)omaterials.size(); 891| 5| pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials]; 892| 5| ::memcpy(pScene->mMaterials, &omaterials[0], pScene->mNumMaterials * sizeof(void *)); 893| | 894| | // copy lights 895| 5| pScene->mNumLights = (unsigned int)lights.size(); 896| 5| if (!lights.empty()) { ------------------ | Branch (896:9): [True: 3, False: 2] ------------------ 897| 3| pScene->mLights = new aiLight *[lights.size()]; 898| 3| ::memcpy(pScene->mLights, &lights[0], lights.size() * sizeof(void *)); 899| 3| } 900| 5|} _ZN6Assimp11AcGetStringEPKcS1_RNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 91| 19|inline const char *AcGetString(const char *buffer, const char *end, std::string &out) { 92| 19| if (*buffer == '\0') { ------------------ | Branch (92:9): [True: 0, False: 19] ------------------ 93| 0| throw DeadlyImportError("AC3D: Unexpected EOF in string"); 94| 0| } 95| 19| ++buffer; 96| 19| const char *sz = buffer; 97| 248| while ('\"' != *buffer && buffer != end) { ------------------ | Branch (97:12): [True: 232, False: 16] | Branch (97:31): [True: 232, False: 0] ------------------ 98| 232| if (IsLineEnd(*buffer)) { ------------------ | Branch (98:13): [True: 3, False: 229] ------------------ 99| 3| ASSIMP_LOG_ERROR("AC3D: Unexpected EOF/EOL in string"); 100| 3| out = "ERROR"; 101| 3| break; 102| 3| } 103| 229| ++buffer; 104| 229| } 105| 19| if (IsLineEnd(*buffer)) { ------------------ | Branch (105:9): [True: 3, False: 16] ------------------ 106| 3| return buffer; 107| 3| } 108| 16| out = std::string(sz, (unsigned int)(buffer - sz)); 109| 16| ++buffer; 110| | 111| 16| return buffer; 112| 19|} ACLoader.cpp:_ZN6AssimpL19buildBacksideOfFaceERK6aiFaceRPS0_RP10aiVector3tIfEPKS6_S8_SA_Rj: 144| 4.63k| aiVector3D *&outUV, const aiVector3D *allUV, unsigned &curIdx) { 145| 4.63k| auto &newFace = *outFaces++; 146| 4.63k| newFace = origFace; 147| 4.63k| flipWindingOrder(newFace); 148| 18.5k| for (unsigned f = 0; f < newFace.mNumIndices; ++f) { ------------------ | Branch (148:26): [True: 13.8k, False: 4.63k] ------------------ 149| 13.8k| *outVertices++ = allVertices[newFace.mIndices[f]]; 150| 13.8k| if (outUV) { ------------------ | Branch (150:13): [True: 0, False: 13.8k] ------------------ 151| 0| *outUV = allUV[newFace.mIndices[f]]; 152| 0| outUV++; 153| 0| } 154| 13.8k| newFace.mIndices[f] = curIdx++; 155| 13.8k| } 156| 4.63k|} ACLoader.cpp:_ZN6AssimpL16flipWindingOrderER6aiFace: 136| 4.63k|static void flipWindingOrder(aiFace &f) { 137| 4.63k| std::reverse(f.mIndices, f.mIndices + f.mNumIndices); 138| 4.63k|} _ZN6Assimp17AcSkipToNextTokenEPKcS1_: 82| 81.0k|inline const char *AcSkipToNextToken(const char *buffer, const char *end) { 83| 81.0k| if (!SkipSpaces(&buffer, end)) { ------------------ | Branch (83:9): [True: 0, False: 81.0k] ------------------ 84| | ASSIMP_LOG_ERROR("AC3D: Unexpected EOF/EOL"); 85| 0| } 86| 81.0k| return buffer; 87| 81.0k|} _ZN6Assimp24TAcCheckedLoadFloatArrayI10aiVector2tIfEEEPKcS4_S4_S4_mmPT_: 117| 17.9k|inline const char *TAcCheckedLoadFloatArray(const char *buffer, const char *end, const char *name, size_t name_length, size_t num, T *out) { 118| 17.9k| buffer = AcSkipToNextToken(buffer, end); 119| 17.9k| if (0 != name_length) { ------------------ | Branch (119:9): [True: 0, False: 17.9k] ------------------ 120| 0| if (0 != strncmp(buffer, name, name_length) || !IsSpace(buffer[name_length])) { ------------------ | Branch (120:13): [True: 0, False: 0] | Branch (120:56): [True: 0, False: 0] ------------------ 121| 0| ASSIMP_LOG_ERROR("AC3D: Unexpected token. ", name, " was expected."); 122| 0| return buffer; 123| 0| } 124| 0| buffer += name_length + 1; 125| 0| } 126| 53.8k| for (unsigned int _i = 0; _i < num; ++_i) { ------------------ | Branch (126:31): [True: 35.8k, False: 17.9k] ------------------ 127| 35.8k| buffer = AcSkipToNextToken(buffer, end); 128| 35.8k| buffer = fast_atoreal_move(buffer, ((float *)out)[_i]); 129| 35.8k| } 130| | 131| 17.9k| return buffer; 132| 17.9k|} _ZN6Assimp24TAcCheckedLoadFloatArrayI10aiVector3tIfEEEPKcS4_S4_S4_mmPT_: 117| 5|inline const char *TAcCheckedLoadFloatArray(const char *buffer, const char *end, const char *name, size_t name_length, size_t num, T *out) { 118| 5| buffer = AcSkipToNextToken(buffer, end); 119| 5| if (0 != name_length) { ------------------ | Branch (119:9): [True: 0, False: 5] ------------------ 120| 0| if (0 != strncmp(buffer, name, name_length) || !IsSpace(buffer[name_length])) { ------------------ | Branch (120:13): [True: 0, False: 0] | Branch (120:56): [True: 0, False: 0] ------------------ 121| 0| ASSIMP_LOG_ERROR("AC3D: Unexpected token. ", name, " was expected."); 122| 0| return buffer; 123| 0| } 124| 0| buffer += name_length + 1; 125| 0| } 126| 20| for (unsigned int _i = 0; _i < num; ++_i) { ------------------ | Branch (126:31): [True: 15, False: 5] ------------------ 127| 15| buffer = AcSkipToNextToken(buffer, end); 128| 15| buffer = fast_atoreal_move(buffer, ((float *)out)[_i]); 129| 15| } 130| | 131| 5| return buffer; 132| 5|} _ZN6Assimp24TAcCheckedLoadFloatArrayIfEEPKcS2_S2_S2_mmPT_: 117| 6.79k|inline const char *TAcCheckedLoadFloatArray(const char *buffer, const char *end, const char *name, size_t name_length, size_t num, T *out) { 118| 6.79k| buffer = AcSkipToNextToken(buffer, end); 119| 6.79k| if (0 != name_length) { ------------------ | Branch (119:9): [True: 10, False: 6.78k] ------------------ 120| 10| if (0 != strncmp(buffer, name, name_length) || !IsSpace(buffer[name_length])) { ------------------ | Branch (120:13): [True: 0, False: 10] | Branch (120:56): [True: 0, False: 10] ------------------ 121| 0| ASSIMP_LOG_ERROR("AC3D: Unexpected token. ", name, " was expected."); 122| 0| return buffer; 123| 0| } 124| 10| buffer += name_length + 1; 125| 10| } 126| 27.1k| for (unsigned int _i = 0; _i < num; ++_i) { ------------------ | Branch (126:31): [True: 20.3k, False: 6.79k] ------------------ 127| 20.3k| buffer = AcSkipToNextToken(buffer, end); 128| 20.3k| buffer = fast_atoreal_move(buffer, ((float *)out)[_i]); 129| 20.3k| } 130| | 131| 6.79k| return buffer; 132| 6.79k|} _ZN6Assimp24TAcCheckedLoadFloatArrayI9aiColor3DEEPKcS3_S3_S3_mmPT_: 117| 20|inline const char *TAcCheckedLoadFloatArray(const char *buffer, const char *end, const char *name, size_t name_length, size_t num, T *out) { 118| 20| buffer = AcSkipToNextToken(buffer, end); 119| 20| if (0 != name_length) { ------------------ | Branch (119:9): [True: 20, False: 0] ------------------ 120| 20| if (0 != strncmp(buffer, name, name_length) || !IsSpace(buffer[name_length])) { ------------------ | Branch (120:13): [True: 0, False: 20] | Branch (120:56): [True: 0, False: 20] ------------------ 121| 0| ASSIMP_LOG_ERROR("AC3D: Unexpected token. ", name, " was expected."); 122| 0| return buffer; 123| 0| } 124| 20| buffer += name_length + 1; 125| 20| } 126| 80| for (unsigned int _i = 0; _i < num; ++_i) { ------------------ | Branch (126:31): [True: 60, False: 20] ------------------ 127| 60| buffer = AcSkipToNextToken(buffer, end); 128| 60| buffer = fast_atoreal_move(buffer, ((float *)out)[_i]); 129| 60| } 130| | 131| 20| return buffer; 132| 20|} _ZN6Assimp12AC3DImporter8MaterialC2Ev: 71| 5| rgb(0.6f, 0.6f, 0.6f), 72| 5| spec(1.f, 1.f, 1.f), 73| 5| shin(0.f), 74| 5| trans(0.f) {} _ZN6Assimp12AC3DImporter7SurfaceC2Ev: 101| 4.37k| mat(0), 102| 4.37k| flags(0) {} _ZNK6Assimp12AC3DImporter7Surface7GetTypeEv: 119| 8.75k| inline uint8_t GetType() const { return (flags & Mask); } _ZN6Assimp12AC3DImporter6ObjectC2Ev: 125| 13| type(World), 126| 13| name(), 127| 13| children(), 128| 13| texRepeat(1.f, 1.f), 129| 13| texOffset(0.0f, 0.0f), 130| 13| rotation(), 131| 13| translation(), 132| 13| vertices(), 133| 13| surfaces(), 134| 13| numRefs(0), 135| 13| subDiv(0), 136| 13| crease() {} _ZN6Assimp11AMFImporter5ClearEv: 69| 625|void AMFImporter::Clear() { 70| 625| mNodeElement_Cur = nullptr; 71| 625| mUnit.clear(); 72| 625| mMaterial_Converted.clear(); 73| 625| mTexture_Converted.clear(); 74| | // Delete all elements 75| 625| if (!mNodeElement_List.empty()) { ------------------ | Branch (75:9): [True: 0, False: 625] ------------------ 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| 625|} _ZN6Assimp11AMFImporterC2Ev: 85| 624| mNodeElement_Cur(nullptr), 86| 624| mXmlParser(nullptr) { 87| | // empty 88| 624|} _ZN6Assimp11AMFImporterD2Ev: 90| 624|AMFImporter::~AMFImporter() { 91| 624| delete mXmlParser; 92| | // Clear() is accounting if data already is deleted. So, just check again if all data is deleted. 93| 624| Clear(); 94| 624|} _ZN6Assimp11AMFImporter9ParseFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemE: 237| 1|void AMFImporter::ParseFile(const std::string &pFile, IOSystem *pIOHandler) { 238| 1| std::unique_ptr file(pIOHandler->Open(pFile, "rb")); 239| | 240| | // Check whether we can read from the file 241| 1| if (file == nullptr) { ------------------ | Branch (241:9): [True: 0, False: 1] ------------------ 242| 0| throw DeadlyImportError("Failed to open AMF file ", pFile, "."); 243| 0| } 244| | 245| 1| mXmlParser = new XmlParser(); 246| 1| if (!mXmlParser->parse(file.get())) { ------------------ | Branch (246:9): [True: 1, False: 0] ------------------ 247| 1| delete mXmlParser; 248| 1| mXmlParser = nullptr; 249| 1| throw DeadlyImportError("Failed to create XML reader for file ", pFile, "."); 250| 1| } 251| | 252| | // Start reading, search for root tag 253| 0| if (!mXmlParser->hasNode("amf")) { ------------------ | Branch (253:9): [True: 0, False: 0] ------------------ 254| 0| throw DeadlyImportError("Root node \"amf\" not found."); 255| 0| } 256| 0| ParseNode_Root(); 257| 0|} // namespace Assimp _ZNK6Assimp11AMFImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 482| 484|bool AMFImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*pCheckSig*/) const { 483| 484| static const char *tokens[] = { "GetPropertyInteger( ------------------ | Branch (105:31): [True: 43, False: 0] ------------------ 106| 43| AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS, 1) ? 107| 43| true : 108| 43| false); 109| | 110| | noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, 0) != 0; 111| 43|} _ZN6Assimp11ASEImporter14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 116| 43| aiScene *pScene, IOSystem *pIOHandler) { 117| 43| std::unique_ptr file(pIOHandler->Open(pFile, "rb")); 118| | 119| | // Check whether we can read from the file 120| 43| if (file == nullptr) { ------------------ | Branch (120:9): [True: 0, False: 43] ------------------ 121| 0| throw DeadlyImportError("Failed to open ASE file ", pFile, "."); 122| 0| } 123| | 124| | // Allocate storage and copy the contents of the file to a memory buffer 125| 43| std::vector mBuffer2; 126| 43| TextFileToBuffer(file.get(), mBuffer2); 127| 43| const size_t fileSize = mBuffer2.size(); 128| 43| this->mBuffer = &mBuffer2[0]; 129| 43| this->pcScene = pScene; 130| | 131| | // ------------------------------------------------------------------ 132| | // Guess the file format by looking at the extension 133| | // ASC is considered to be the older format 110, 134| | // ASE is the actual version 200 (that is currently written by max) 135| | // ------------------------------------------------------------------ 136| 43| unsigned int defaultFormat; 137| 43| std::string::size_type s = pFile.length() - 1; 138| 43| switch (pFile.c_str()[s]) { 139| | 140| 0| case 'C': ------------------ | Branch (140:5): [True: 0, False: 43] ------------------ 141| 0| case 'c': ------------------ | Branch (141:5): [True: 0, False: 43] ------------------ 142| 0| defaultFormat = AI_ASE_OLD_FILE_FORMAT; 143| 0| break; 144| 43| default: ------------------ | Branch (144:5): [True: 43, False: 0] ------------------ 145| 43| defaultFormat = AI_ASE_NEW_FILE_FORMAT; 146| 43| }; 147| | 148| | // Construct an ASE parser and parse the file 149| 43| ASE::Parser parser(mBuffer, fileSize, defaultFormat); 150| 43| mParser = &parser; 151| 43| mParser->Parse(); 152| | 153| | //------------------------------------------------------------------ 154| | // Check whether we god at least one mesh. If we did - generate 155| | // materials and copy meshes. 156| | // ------------------------------------------------------------------ 157| 43| if (!mParser->m_vMeshes.empty()) { ------------------ | Branch (157:9): [True: 17, False: 26] ------------------ 158| | 159| | // If absolutely no material has been loaded from the file 160| | // we need to generate a default material 161| 17| GenerateDefaultMaterial(); 162| | 163| | // process all meshes 164| 17| bool tookNormals = false; 165| 17| std::vector avOutMeshes; 166| 17| avOutMeshes.reserve(mParser->m_vMeshes.size() * 2); 167| 41| for (std::vector::iterator i = mParser->m_vMeshes.begin(); i != mParser->m_vMeshes.end(); ++i) { ------------------ | Branch (167:79): [True: 24, False: 17] ------------------ 168| 24| if ((*i).bSkip) { ------------------ | Branch (168:17): [True: 0, False: 24] ------------------ 169| 0| continue; 170| 0| } 171| 24| BuildUniqueRepresentation(*i); 172| | 173| | // Need to generate proper vertex normals if necessary 174| 24| if (GenerateNormals(*i)) { ------------------ | Branch (174:17): [True: 0, False: 24] ------------------ 175| 0| tookNormals = true; 176| 0| } 177| | 178| | // Convert all meshes to aiMesh objects 179| 24| ConvertMeshes(*i, avOutMeshes); 180| 24| } 181| 17| if (tookNormals) { ------------------ | Branch (181:13): [True: 0, False: 17] ------------------ 182| 0| ASSIMP_LOG_DEBUG("ASE: Taking normals from the file. Use " 183| 0| "the AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS setting if you " 184| 0| "experience problems"); 185| 0| } 186| | 187| | // Now build the output mesh list. Remove dummies 188| 17| pScene->mNumMeshes = (unsigned int)avOutMeshes.size(); 189| 17| aiMesh **pp = pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]; 190| 39| for (std::vector::const_iterator i = avOutMeshes.begin(); i != avOutMeshes.end(); ++i) { ------------------ | Branch (190:77): [True: 22, False: 17] ------------------ 191| 22| if (!(*i)->mNumFaces) { ------------------ | Branch (191:17): [True: 6, False: 16] ------------------ 192| 6| continue; 193| 6| } 194| 16| *pp++ = *i; 195| 16| } 196| 17| pScene->mNumMeshes = (unsigned int)(pp - pScene->mMeshes); 197| | 198| | // Build final material indices (remove submaterials and setup 199| | // the final list) 200| 17| BuildMaterialIndices(); 201| 17| } 202| | 203| | // ------------------------------------------------------------------ 204| | // Copy all scene graph nodes - lights, cameras, dummies and meshes 205| | // into one huge list. 206| | //------------------------------------------------------------------ 207| 43| std::vector nodes; 208| 43| nodes.reserve(mParser->m_vMeshes.size() + mParser->m_vLights.size() + mParser->m_vCameras.size() + mParser->m_vDummies.size()); 209| | 210| | // Lights 211| 43| for (auto &light : mParser->m_vLights) ------------------ | Branch (211:22): [True: 3, False: 43] ------------------ 212| 3| nodes.push_back(&light); 213| | // Cameras 214| 43| for (auto &camera : mParser->m_vCameras) ------------------ | Branch (214:23): [True: 4, False: 43] ------------------ 215| 4| nodes.push_back(&camera); 216| | // Meshes 217| 43| for (auto &mesh : mParser->m_vMeshes) ------------------ | Branch (217:21): [True: 22, False: 43] ------------------ 218| 22| nodes.push_back(&mesh); 219| | // Dummies 220| 43| for (auto &dummy : mParser->m_vDummies) ------------------ | Branch (220:22): [True: 0, False: 43] ------------------ 221| 0| nodes.push_back(&dummy); 222| | 223| | // build the final node graph 224| 43| BuildNodes(nodes); 225| | 226| | // build output animations 227| 43| BuildAnimations(nodes); 228| | 229| | // build output cameras 230| 43| BuildCameras(); 231| | 232| | // build output lights 233| 43| BuildLights(); 234| | 235| | // ------------------------------------------------------------------ 236| | // If we have no meshes use the SkeletonMeshBuilder helper class 237| | // to build a mesh for the animation skeleton 238| | // FIXME: very strange results 239| | // ------------------------------------------------------------------ 240| 43| if (!pScene->mNumMeshes) { ------------------ | Branch (240:9): [True: 8, False: 35] ------------------ 241| 8| pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; 242| 8| if (!noSkeletonMesh) { ------------------ | Branch (242:13): [True: 8, False: 0] ------------------ 243| 8| SkeletonMeshBuilder skeleton(pScene); 244| 8| } 245| 8| } 246| 43|} _ZN6Assimp11ASEImporter23GenerateDefaultMaterialEv: 248| 17|void ASEImporter::GenerateDefaultMaterial() { 249| 17| ai_assert(nullptr != mParser); 250| | 251| 17| bool bHas = false; 252| 41| for (std::vector::iterator i = mParser->m_vMeshes.begin(); i != mParser->m_vMeshes.end(); ++i) { ------------------ | Branch (252:75): [True: 24, False: 17] ------------------ 253| 24| if ((*i).bSkip) continue; ------------------ | Branch (253:13): [True: 0, False: 24] ------------------ 254| 24| if (ASE::Face::DEFAULT_MATINDEX == (*i).iMaterialIndex) { ------------------ | Branch (254:13): [True: 16, False: 8] ------------------ 255| 16| (*i).iMaterialIndex = (unsigned int)mParser->m_vMaterials.size(); 256| 16| bHas = true; 257| 16| } 258| 24| } 259| 17| if (bHas || mParser->m_vMaterials.empty()) { ------------------ | Branch (259:9): [True: 13, False: 4] | Branch (259:17): [True: 0, False: 4] ------------------ 260| | // add a simple material without submaterials to the parser's list 261| 13| mParser->m_vMaterials.emplace_back(AI_DEFAULT_MATERIAL_NAME); 262| 13| ASE::Material &mat = mParser->m_vMaterials.back(); 263| | 264| 13| mat.mDiffuse = aiColor3D(0.6f, 0.6f, 0.6f); 265| 13| mat.mSpecular = aiColor3D(1.0f, 1.0f, 1.0f); 266| 13| mat.mAmbient = aiColor3D(0.05f, 0.05f, 0.05f); 267| 13| mat.mShading = Discreet3DS::Gouraud; 268| 13| } 269| 17|} _ZN6Assimp11ASEImporter15BuildAnimationsERKNSt3__16vectorIPNS_3ASE8BaseNodeENS1_9allocatorIS5_EEEE: 272| 17|void ASEImporter::BuildAnimations(const std::vector &nodes) { 273| | // check whether we have at least one mesh which has animations 274| 17| std::vector::const_iterator i = nodes.begin(); 275| 17| unsigned int iNum = 0; 276| 46| for (; i != nodes.end(); ++i) { ------------------ | Branch (276:12): [True: 29, False: 17] ------------------ 277| | 278| | // TODO: Implement Bezier & TCB support 279| 29| if ((*i)->mAnim.mPositionType != ASE::Animation::TRACK) { ------------------ | Branch (279:13): [True: 0, False: 29] ------------------ 280| 0| ASSIMP_LOG_WARN("ASE: Position controller uses Bezier/TCB keys. " 281| 0| "This is not supported."); 282| 0| } 283| 29| if ((*i)->mAnim.mRotationType != ASE::Animation::TRACK) { ------------------ | Branch (283:13): [True: 0, False: 29] ------------------ 284| 0| ASSIMP_LOG_WARN("ASE: Rotation controller uses Bezier/TCB keys. " 285| 0| "This is not supported."); 286| 0| } 287| 29| if ((*i)->mAnim.mScalingType != ASE::Animation::TRACK) { ------------------ | Branch (287:13): [True: 0, False: 29] ------------------ 288| 0| ASSIMP_LOG_WARN("ASE: Position controller uses Bezier/TCB keys. " 289| 0| "This is not supported."); 290| 0| } 291| | 292| | // We compare against 1 here - firstly one key is not 293| | // really an animation and secondly MAX writes dummies 294| | // that represent the node transformation. 295| 29| if ((*i)->mAnim.akeyPositions.size() > 1 || (*i)->mAnim.akeyRotations.size() > 1 || (*i)->mAnim.akeyScaling.size() > 1) { ------------------ | Branch (295:13): [True: 10, False: 19] | Branch (295:53): [True: 3, False: 16] | Branch (295:93): [True: 0, False: 16] ------------------ 296| 13| ++iNum; 297| 13| } 298| 29| if ((*i)->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan((*i)->mTargetPosition.x)) { ------------------ | Branch (298:13): [True: 3, False: 26] | Branch (298:59): [True: 3, False: 0] ------------------ 299| 3| ++iNum; 300| 3| } 301| 29| } 302| 17| if (iNum) { ------------------ | Branch (302:9): [True: 11, False: 6] ------------------ 303| | // Generate a new animation channel and setup everything for it 304| 11| pcScene->mNumAnimations = 1; 305| 11| pcScene->mAnimations = new aiAnimation *[1]; 306| 11| aiAnimation *pcAnim = pcScene->mAnimations[0] = new aiAnimation(); 307| 11| pcAnim->mNumChannels = iNum; 308| 11| pcAnim->mChannels = new aiNodeAnim *[iNum]; 309| 11| pcAnim->mTicksPerSecond = mParser->iFrameSpeed * mParser->iTicksPerFrame; 310| | 311| 11| iNum = 0; 312| | 313| | // Now iterate through all meshes and collect all data we can find 314| 32| for (i = nodes.begin(); i != nodes.end(); ++i) { ------------------ | Branch (314:33): [True: 21, False: 11] ------------------ 315| | 316| 21| ASE::BaseNode *me = *i; 317| 21| if (me->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan(me->mTargetPosition.x)) { ------------------ | Branch (317:17): [True: 3, False: 18] | Branch (317:61): [True: 3, False: 0] ------------------ 318| | // Generate an extra channel for the camera/light target. 319| | // BuildNodes() does also generate an extra node, named 320| | // .Target. 321| 3| aiNodeAnim *nd = pcAnim->mChannels[iNum++] = new aiNodeAnim(); 322| 3| nd->mNodeName.Set(me->mName + ".Target"); 323| | 324| | // Allocate the key array and fill it 325| 3| nd->mNumPositionKeys = (unsigned int)me->mTargetAnim.akeyPositions.size(); 326| 3| nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys]; 327| | 328| 3| ::memcpy(nd->mPositionKeys, &me->mTargetAnim.akeyPositions[0], 329| 3| nd->mNumPositionKeys * sizeof(aiVectorKey)); 330| 3| } 331| | 332| 21| if (me->mAnim.akeyPositions.size() > 1 || me->mAnim.akeyRotations.size() > 1 || me->mAnim.akeyScaling.size() > 1) { ------------------ | Branch (332:17): [True: 10, False: 11] | Branch (332:55): [True: 3, False: 8] | Branch (332:93): [True: 0, False: 8] ------------------ 333| | // Begin a new node animation channel for this node 334| 13| aiNodeAnim *nd = pcAnim->mChannels[iNum++] = new aiNodeAnim(); 335| 13| nd->mNodeName.Set(me->mName); 336| | 337| | // copy position keys 338| 13| if (me->mAnim.akeyPositions.size() > 1) { ------------------ | Branch (338:21): [True: 10, False: 3] ------------------ 339| | // Allocate the key array and fill it 340| 10| nd->mNumPositionKeys = (unsigned int)me->mAnim.akeyPositions.size(); 341| 10| nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys]; 342| | 343| 10| ::memcpy(nd->mPositionKeys, &me->mAnim.akeyPositions[0], 344| 10| nd->mNumPositionKeys * sizeof(aiVectorKey)); 345| 10| } 346| | // copy rotation keys 347| 13| if (me->mAnim.akeyRotations.size() > 1) { ------------------ | Branch (347:21): [True: 10, False: 3] ------------------ 348| | // Allocate the key array and fill it 349| 10| nd->mNumRotationKeys = (unsigned int)me->mAnim.akeyRotations.size(); 350| 10| nd->mRotationKeys = new aiQuatKey[nd->mNumRotationKeys]; 351| | 352| | // -------------------------------------------------------------------- 353| | // Rotation keys are offsets to the previous keys. 354| | // We have the quaternion representations of all 355| | // of them, so we just need to concatenate all 356| | // (unit-length) quaternions to get the absolute 357| | // rotations. 358| | // Rotation keys are ABSOLUTE for older files 359| | // -------------------------------------------------------------------- 360| | 361| 10| aiQuaternion cur; 362| 1.00k| for (unsigned int a = 0; a < nd->mNumRotationKeys; ++a) { ------------------ | Branch (362:46): [True: 992, False: 10] ------------------ 363| 992| aiQuatKey q = me->mAnim.akeyRotations[a]; 364| | 365| 992| if (mParser->iFileFormat > 110) { ------------------ | Branch (365:29): [True: 901, False: 91] ------------------ 366| 901| cur = (a ? cur * q.mValue : q.mValue); ------------------ | Branch (366:36): [True: 892, False: 9] ------------------ 367| 901| q.mValue = cur.Normalize(); 368| 901| } 369| 992| nd->mRotationKeys[a] = q; 370| | 371| | // need this to get to Assimp quaternion conventions 372| 992| nd->mRotationKeys[a].mValue.w *= -1.f; 373| 992| } 374| 10| } 375| | // copy scaling keys 376| 13| if (me->mAnim.akeyScaling.size() > 1) { ------------------ | Branch (376:21): [True: 1, False: 12] ------------------ 377| | // Allocate the key array and fill it 378| 1| nd->mNumScalingKeys = (unsigned int)me->mAnim.akeyScaling.size(); 379| 1| nd->mScalingKeys = new aiVectorKey[nd->mNumScalingKeys]; 380| | 381| 1| ::memcpy(nd->mScalingKeys, &me->mAnim.akeyScaling[0], 382| 1| nd->mNumScalingKeys * sizeof(aiVectorKey)); 383| 1| } 384| 13| } 385| 21| } 386| 11| } 387| 17|} _ZN6Assimp11ASEImporter12BuildCamerasEv: 391| 17|void ASEImporter::BuildCameras() { 392| 17| if (!mParser->m_vCameras.empty()) { ------------------ | Branch (392:9): [True: 4, False: 13] ------------------ 393| 4| pcScene->mNumCameras = (unsigned int)mParser->m_vCameras.size(); 394| 4| pcScene->mCameras = new aiCamera *[pcScene->mNumCameras]; 395| | 396| 8| for (unsigned int i = 0; i < pcScene->mNumCameras; ++i) { ------------------ | Branch (396:34): [True: 4, False: 4] ------------------ 397| 4| aiCamera *out = pcScene->mCameras[i] = new aiCamera(); 398| 4| ASE::Camera &in = mParser->m_vCameras[i]; 399| | 400| | // copy members 401| 4| out->mClipPlaneFar = in.mFar; 402| 4| out->mClipPlaneNear = (in.mNear ? in.mNear : 0.1f); ------------------ | Branch (402:36): [True: 0, False: 4] ------------------ 403| 4| out->mHorizontalFOV = in.mFOV; 404| | 405| 4| out->mName.Set(in.mName); 406| 4| } 407| 4| } 408| 17|} _ZN6Assimp11ASEImporter11BuildLightsEv: 412| 17|void ASEImporter::BuildLights() { 413| 17| if (!mParser->m_vLights.empty()) { ------------------ | Branch (413:9): [True: 1, False: 16] ------------------ 414| 1| pcScene->mNumLights = (unsigned int)mParser->m_vLights.size(); 415| 1| pcScene->mLights = new aiLight *[pcScene->mNumLights]; 416| | 417| 4| for (unsigned int i = 0; i < pcScene->mNumLights; ++i) { ------------------ | Branch (417:34): [True: 3, False: 1] ------------------ 418| 3| aiLight *out = pcScene->mLights[i] = new aiLight(); 419| 3| ASE::Light &in = mParser->m_vLights[i]; 420| | 421| | // The direction is encoded in the transformation matrix of the node. 422| | // In 3DS MAX the light source points into negative Z direction if 423| | // the node transformation is the identity. 424| 3| out->mDirection = aiVector3D(0.f, 0.f, -1.f); 425| | 426| 3| out->mName.Set(in.mName); 427| 3| switch (in.mLightType) { 428| 0| case ASE::Light::TARGET: ------------------ | Branch (428:13): [True: 0, False: 3] ------------------ 429| 0| out->mType = aiLightSource_SPOT; 430| 0| out->mAngleInnerCone = AI_DEG_TO_RAD(in.mAngle); 431| 0| out->mAngleOuterCone = (in.mFalloff ? AI_DEG_TO_RAD(in.mFalloff) : out->mAngleInnerCone); ------------------ | Branch (431:41): [True: 0, False: 0] ------------------ 432| 0| break; 433| | 434| 2| case ASE::Light::DIRECTIONAL: ------------------ | Branch (434:13): [True: 2, False: 1] ------------------ 435| 2| out->mType = aiLightSource_DIRECTIONAL; 436| 2| break; 437| | 438| 1| default: ------------------ | Branch (438:13): [True: 1, False: 2] ------------------ 439| | //case ASE::Light::OMNI: 440| 1| out->mType = aiLightSource_POINT; 441| 1| break; 442| 3| }; 443| 3| out->mColorDiffuse = out->mColorSpecular = in.mColor * in.mIntensity; 444| 3| } 445| 1| } 446| 17|} _ZN6Assimp11ASEImporter8AddNodesERKNSt3__16vectorIPNS_3ASE8BaseNodeENS1_9allocatorIS5_EEEEP6aiNodeRKNS1_12basic_stringIcNS1_11char_traitsIcEENS6_IcEEEE: 449| 17|void ASEImporter::AddNodes(const std::vector &nodes, aiNode *pcParent, const std::string &name) { 450| 17| aiMatrix4x4 m; 451| 17| AddNodes(nodes, pcParent, name, m); 452| 17|} _ZN6Assimp11ASEImporter9AddMeshesEPKNS_3ASE8BaseNodeEP6aiNode: 456| 22|void ASEImporter::AddMeshes(const ASE::BaseNode *snode, aiNode *node) { 457| 64| for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i) { ------------------ | Branch (457:30): [True: 42, False: 22] ------------------ 458| | // Get the name of the mesh (the mesh instance has been temporarily stored in the third vertex color) 459| 42| const aiMesh *pcMesh = pcScene->mMeshes[i]; 460| 42| const ASE::Mesh *mesh = (const ASE::Mesh *)pcMesh->mColors[2]; 461| | 462| 42| if (mesh == snode) { ------------------ | Branch (462:13): [True: 16, False: 26] ------------------ 463| 16| ++node->mNumMeshes; 464| 16| } 465| 42| } 466| | 467| 22| if (node->mNumMeshes) { ------------------ | Branch (467:9): [True: 16, False: 6] ------------------ 468| 16| node->mMeshes = new unsigned int[node->mNumMeshes]; 469| 58| for (unsigned int i = 0, p = 0; i < pcScene->mNumMeshes; ++i) { ------------------ | Branch (469:41): [True: 42, False: 16] ------------------ 470| | 471| 42| const aiMesh *pcMesh = pcScene->mMeshes[i]; 472| 42| const ASE::Mesh *mesh = (const ASE::Mesh *)pcMesh->mColors[2]; 473| 42| if (mesh == snode) { ------------------ | Branch (473:17): [True: 16, False: 26] ------------------ 474| 16| node->mMeshes[p++] = i; 475| | 476| | // Transform all vertices of the mesh back into their local space -> 477| | // at the moment they are pretransformed 478| 16| aiMatrix4x4 m = mesh->mTransform; 479| 16| m.Inverse(); 480| | 481| 16| aiVector3D *pvCurPtr = pcMesh->mVertices; 482| 16| const aiVector3D *pvEndPtr = pvCurPtr + pcMesh->mNumVertices; 483| 712| while (pvCurPtr != pvEndPtr) { ------------------ | Branch (483:24): [True: 696, False: 16] ------------------ 484| 696| *pvCurPtr = m * (*pvCurPtr); 485| 696| pvCurPtr++; 486| 696| } 487| | 488| | // Do the same for the normal vectors, if we have them. 489| | // As always, inverse transpose. 490| 16| if (pcMesh->mNormals) { ------------------ | Branch (490:21): [True: 16, False: 0] ------------------ 491| 16| aiMatrix3x3 m3 = aiMatrix3x3(mesh->mTransform); 492| 16| m3.Transpose(); 493| | 494| 16| pvCurPtr = pcMesh->mNormals; 495| 16| pvEndPtr = pvCurPtr + pcMesh->mNumVertices; 496| 712| while (pvCurPtr != pvEndPtr) { ------------------ | Branch (496:28): [True: 696, False: 16] ------------------ 497| 696| *pvCurPtr = m3 * (*pvCurPtr); 498| 696| pvCurPtr++; 499| 696| } 500| 16| } 501| 16| } 502| 42| } 503| 16| } 504| 22|} _ZN6Assimp11ASEImporter8AddNodesERKNSt3__16vectorIPNS_3ASE8BaseNodeENS1_9allocatorIS5_EEEEP6aiNodeRKNS1_12basic_stringIcNS1_11char_traitsIcEENS6_IcEEEERK12aiMatrix4x4tIfE: 509| 46| const aiMatrix4x4 &mat) { 510| 46| const size_t len = name.size(); 511| 46| ai_assert(4 <= AI_MAX_NUMBER_OF_COLOR_SETS); 512| | 513| | // Receives child nodes for the pcParent node 514| 46| std::vector apcNodes; 515| | 516| | // Now iterate through all nodes in the scene and search for one 517| | // which has *us* as parent. 518| 166| for (std::vector::const_iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) { ------------------ | Branch (518:89): [True: 120, False: 46] ------------------ 519| 120| const BaseNode *snode = *it; 520| 120| if (!name.empty()) { ------------------ | Branch (520:13): [True: 91, False: 29] ------------------ 521| 91| if (len != snode->mParent.length() || name != snode->mParent.c_str()) { ------------------ | Branch (521:17): [True: 90, False: 1] | Branch (521:51): [True: 0, False: 1] ------------------ 522| 90| continue; 523| 90| } 524| 91| } else if (snode->mParent.length()) { ------------------ | Branch (524:20): [True: 1, False: 28] ------------------ 525| 1| continue; 526| 1| } 527| | 528| 29| (*it)->mProcessed = true; 529| | 530| | // Allocate a new node and add it to the output data structure 531| 29| apcNodes.push_back(new aiNode); 532| 29| aiNode *node = apcNodes.back(); 533| | 534| 29| node->mName.Set((snode->mName.length() ? snode->mName.c_str() : "Unnamed_Node")); ------------------ | Branch (534:26): [True: 29, False: 0] ------------------ 535| 29| node->mParent = pcParent; 536| | 537| | // Setup the transformation matrix of the node 538| 29| aiMatrix4x4 mParentAdjust = mat; 539| 29| mParentAdjust.Inverse(); 540| 29| node->mTransformation = mParentAdjust * snode->mTransform; 541| | 542| | // Add sub nodes - prevent stack overflow due to recursive parenting 543| 29| if (node->mName != node->mParent->mName && node->mName != node->mParent->mParent->mName) { ------------------ | Branch (543:13): [True: 29, False: 0] | Branch (543:52): [True: 29, False: 0] ------------------ 544| 29| AddNodes(nodes, node, node->mName.C_Str(), snode->mTransform); 545| 29| } 546| | 547| | // Further processing depends on the type of the node 548| 29| if (snode->mType == ASE::BaseNode::Mesh) { ------------------ | Branch (548:13): [True: 22, False: 7] ------------------ 549| | // If the type of this node is "Mesh" we need to search 550| | // the list of output meshes in the data structure for 551| | // all those that belonged to this node once. This is 552| | // slightly inconvinient here and a better solution should 553| | // be used when this code is refactored next. 554| 22| AddMeshes(snode, node); 555| 22| } else if (is_not_qnan(snode->mTargetPosition.x)) { ------------------ | Branch (555:20): [True: 4, False: 3] ------------------ 556| | // If this is a target camera or light we generate a small 557| | // child node which marks the position of the camera 558| | // target (the direction information is contained in *this* 559| | // node's animation track but the exact target position 560| | // would be lost otherwise) 561| 4| if (!node->mNumChildren) { ------------------ | Branch (561:17): [True: 3, False: 1] ------------------ 562| 3| node->mChildren = new aiNode *[1]; 563| 3| } 564| | 565| 4| aiNode *nd = new aiNode(); 566| | 567| 4| nd->mName.Set(snode->mName + ".Target"); 568| | 569| 4| nd->mTransformation.a4 = snode->mTargetPosition.x - snode->mTransform.a4; 570| 4| nd->mTransformation.b4 = snode->mTargetPosition.y - snode->mTransform.b4; 571| 4| nd->mTransformation.c4 = snode->mTargetPosition.z - snode->mTransform.c4; 572| | 573| 4| nd->mParent = node; 574| | 575| | // The .Target node is always the first child node 576| 5| for (unsigned int m = 0; m < node->mNumChildren; ++m) ------------------ | Branch (576:38): [True: 1, False: 4] ------------------ 577| 1| node->mChildren[m + 1] = node->mChildren[m]; 578| | 579| 4| node->mChildren[0] = nd; 580| 4| node->mNumChildren++; 581| | 582| | // What we did is so great, it is at least worth a debug message 583| 4| ASSIMP_LOG_VERBOSE_DEBUG("ASE: Generating separate target node (", snode->mName, ")"); 584| 4| } 585| 29| } 586| | 587| | // Allocate enough space for the child nodes 588| | // We allocate one slot more in case this is a target camera/light 589| 46| pcParent->mNumChildren = (unsigned int)apcNodes.size(); 590| 46| if (pcParent->mNumChildren) { ------------------ | Branch (590:9): [True: 16, False: 30] ------------------ 591| 16| pcParent->mChildren = new aiNode *[apcNodes.size() + 1 /* PLUS ONE !!! */]; 592| | 593| | // now build all nodes for our nice new children 594| 45| for (unsigned int p = 0; p < apcNodes.size(); ++p) ------------------ | Branch (594:34): [True: 29, False: 16] ------------------ 595| 29| pcParent->mChildren[p] = apcNodes[p]; 596| 16| } 597| 46| return; 598| 46|} _ZN6Assimp11ASEImporter10BuildNodesERNSt3__16vectorIPNS_3ASE8BaseNodeENS1_9allocatorIS5_EEEE: 602| 17|void ASEImporter::BuildNodes(std::vector &nodes) { 603| 17| ai_assert(nullptr != pcScene); 604| | 605| | // allocate the one and only root node 606| 17| aiNode *root = pcScene->mRootNode = new aiNode(); 607| 17| root->mName.Set(""); 608| | 609| | // Setup the coordinate system transformation 610| 17| pcScene->mRootNode->mNumChildren = 1; 611| 17| pcScene->mRootNode->mChildren = new aiNode *[1]; 612| 17| aiNode *ch = pcScene->mRootNode->mChildren[0] = new aiNode(); 613| 17| ch->mParent = root; 614| | 615| | // Change the transformation matrix of all nodes 616| 29| for (BaseNode *node : nodes) { ------------------ | Branch (616:25): [True: 29, False: 17] ------------------ 617| 29| aiMatrix4x4 &m = node->mTransform; 618| 29| m.Transpose(); // row-order vs column-order 619| 29| } 620| | 621| | // add all nodes 622| 17| static const std::string none = ""; 623| 17| AddNodes(nodes, ch, none); 624| | 625| | // now iterate through al nodes and find those that have not yet 626| | // been added to the nodegraph (= their parent could not be recognized) 627| 17| std::vector aiList; 628| 46| for (std::vector::iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) { ------------------ | Branch (628:83): [True: 29, False: 17] ------------------ 629| 29| if ((*it)->mProcessed) { ------------------ | Branch (629:13): [True: 29, False: 0] ------------------ 630| 29| continue; 631| 29| } 632| | 633| | // check whether our parent is known 634| 0| bool bKnowParent = false; 635| | 636| | // search the list another time, starting *here* and try to find out whether 637| | // there is a node that references *us* as a parent 638| 0| for (std::vector::const_iterator it2 = nodes.begin(); it2 != end; ++it2) { ------------------ | Branch (638:75): [True: 0, False: 0] ------------------ 639| 0| if (it2 == it) { ------------------ | Branch (639:17): [True: 0, False: 0] ------------------ 640| 0| continue; 641| 0| } 642| | 643| 0| if ((*it2)->mName == (*it)->mParent) { ------------------ | Branch (643:17): [True: 0, False: 0] ------------------ 644| 0| bKnowParent = true; 645| 0| break; 646| 0| } 647| 0| } 648| 0| if (!bKnowParent) { ------------------ | Branch (648:13): [True: 0, False: 0] ------------------ 649| 0| aiList.push_back(*it); 650| 0| } 651| 0| } 652| | 653| | // Are there any orphaned nodes? 654| 17| if (!aiList.empty()) { ------------------ | Branch (654:9): [True: 0, False: 17] ------------------ 655| 0| std::vector apcNodes; 656| 0| apcNodes.reserve(aiList.size() + pcScene->mRootNode->mNumChildren); 657| | 658| 0| for (unsigned int i = 0; i < pcScene->mRootNode->mNumChildren; ++i) ------------------ | Branch (658:34): [True: 0, False: 0] ------------------ 659| 0| apcNodes.push_back(pcScene->mRootNode->mChildren[i]); 660| | 661| 0| delete[] pcScene->mRootNode->mChildren; 662| 0| for (std::vector::/*const_*/ iterator i = aiList.begin(); i != aiList.end(); ++i) { ------------------ | Branch (662:85): [True: 0, False: 0] ------------------ 663| 0| const ASE::BaseNode *src = *i; 664| | 665| | // The parent is not known, so we can assume that we must add 666| | // this node to the root node of the whole scene 667| 0| aiNode *pcNode = new aiNode(); 668| 0| pcNode->mParent = pcScene->mRootNode; 669| 0| pcNode->mName.Set(src->mName); 670| 0| AddMeshes(src, pcNode); 671| 0| AddNodes(nodes, pcNode, pcNode->mName.data); 672| 0| apcNodes.push_back(pcNode); 673| 0| } 674| | 675| | // Regenerate our output array 676| 0| pcScene->mRootNode->mChildren = new aiNode *[apcNodes.size()]; 677| 0| for (unsigned int i = 0; i < apcNodes.size(); ++i) ------------------ | Branch (677:34): [True: 0, False: 0] ------------------ 678| 0| pcScene->mRootNode->mChildren[i] = apcNodes[i]; 679| | 680| 0| pcScene->mRootNode->mNumChildren = (unsigned int)apcNodes.size(); 681| 0| } 682| | 683| | // Reset the third color set to nullptr - we used this field to store a temporary pointer 684| 33| for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i) ------------------ | Branch (684:30): [True: 16, False: 17] ------------------ 685| 16| pcScene->mMeshes[i]->mColors[2] = nullptr; 686| | 687| | // The root node should not have at least one child or the file is valid 688| 17| if (!pcScene->mRootNode->mNumChildren) { ------------------ | Branch (688:9): [True: 0, False: 17] ------------------ 689| 0| throw DeadlyImportError("ASE: No nodes loaded. The file is either empty or corrupt"); 690| 0| } 691| | 692| | // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system 693| 17| pcScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f, 694| 17| 0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f); 695| 17|} _ZN6Assimp11ASEImporter25BuildUniqueRepresentationERNS_3ASE4MeshE: 699| 24|void ASEImporter::BuildUniqueRepresentation(ASE::Mesh &mesh) { 700| | // allocate output storage 701| 24| std::vector mPositions; 702| 24| std::vector amTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS]; 703| 24| std::vector mVertexColors; 704| 24| std::vector mNormals; 705| 24| std::vector mBoneVertices; 706| | 707| 24| unsigned int iSize = (unsigned int)mesh.mFaces.size() * 3; 708| 24| mPositions.resize(iSize); 709| | 710| | // optional texture coordinates 711| 216| for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) { ------------------ | Branch (711:30): [True: 192, False: 24] ------------------ 712| 192| if (!mesh.amTexCoords[i].empty()) { ------------------ | Branch (712:13): [True: 13, False: 179] ------------------ 713| 13| amTexCoords[i].resize(iSize); 714| 13| } 715| 192| } 716| | // optional vertex colors 717| 24| if (!mesh.mVertexColors.empty()) { ------------------ | Branch (717:9): [True: 0, False: 24] ------------------ 718| 0| mVertexColors.resize(iSize); 719| 0| } 720| | 721| | // optional vertex normals (vertex normals can simply be copied) 722| 24| if (!mesh.mNormals.empty()) { ------------------ | Branch (722:9): [True: 13, False: 11] ------------------ 723| 13| mNormals.resize(iSize); 724| 13| } 725| | // bone vertices. There is no need to change the bone list 726| 24| if (!mesh.mBoneVertices.empty()) { ------------------ | Branch (726:9): [True: 0, False: 24] ------------------ 727| 0| mBoneVertices.resize(iSize); 728| 0| } 729| | 730| | // iterate through all faces in the mesh 731| 24| unsigned int iCurrent = 0, fi = 0; 732| 266| for (std::vector::iterator i = mesh.mFaces.begin(); i != mesh.mFaces.end(); ++i, ++fi) { ------------------ | Branch (732:68): [True: 244, False: 22] ------------------ 733| 970| for (unsigned int n = 0; n < 3; ++n, ++iCurrent) { ------------------ | Branch (733:34): [True: 728, False: 242] ------------------ 734| 728| const uint32_t curIndex = (*i).mIndices[n]; 735| 728| if (curIndex >= mesh.mPositions.size()) { ------------------ | Branch (735:17): [True: 2, False: 726] ------------------ 736| 2| throw DeadlyImportError("ASE: Invalid vertex index in face ", fi, "."); 737| 2| } 738| 726| mPositions[iCurrent] = mesh.mPositions[(*i).mIndices[n]]; 739| | 740| | // add texture coordinates 741| 1.27k| for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) { ------------------ | Branch (741:38): [True: 1.27k, False: 0] ------------------ 742| 1.27k| if (mesh.amTexCoords[c].empty()) break; ------------------ | Branch (742:21): [True: 726, False: 546] ------------------ 743| 546| amTexCoords[c][iCurrent] = mesh.amTexCoords[c][(*i).amUVIndices[c][n]]; 744| 546| } 745| | // add vertex colors 746| 726| if (!mesh.mVertexColors.empty()) { ------------------ | Branch (746:17): [True: 0, False: 726] ------------------ 747| 0| mVertexColors[iCurrent] = mesh.mVertexColors[(*i).mColorIndices[n]]; 748| 0| } 749| | // add normal vectors 750| 726| if (!mesh.mNormals.empty()) { ------------------ | Branch (750:17): [True: 546, False: 180] ------------------ 751| 546| mNormals[iCurrent] = mesh.mNormals[fi * 3 + n]; 752| 546| mNormals[iCurrent].Normalize(); 753| 546| } 754| | 755| | // handle bone vertices 756| 726| if ((*i).mIndices[n] < mesh.mBoneVertices.size()) { ------------------ | Branch (756:17): [True: 0, False: 726] ------------------ 757| | // (sometimes this will cause bone verts to be duplicated 758| | // however, I' quite sure Schrompf' JoinVerticesStep 759| | // will fix that again ...) 760| 0| mBoneVertices[iCurrent] = mesh.mBoneVertices[(*i).mIndices[n]]; 761| 0| } 762| 726| (*i).mIndices[n] = iCurrent; 763| 726| } 764| 244| } 765| | 766| | // replace the old arrays 767| 22| mesh.mNormals = mNormals; 768| 22| mesh.mPositions = mPositions; 769| 22| mesh.mVertexColors = mVertexColors; 770| | 771| 198| for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) ------------------ | Branch (771:30): [True: 176, False: 22] ------------------ 772| 176| mesh.amTexCoords[c] = amTexCoords[c]; 773| 22|} _ZN6Assimp14CopyASETextureER10aiMaterialRNS_4D3DS7TextureE13aiTextureType: 777| 4|void CopyASETexture(aiMaterial &mat, ASE::Texture &texture, aiTextureType type) { 778| | // Setup the texture name 779| 4| aiString tex; 780| 4| tex.Set(texture.mMapName); 781| 4| mat.AddProperty(&tex, AI_MATKEY_TEXTURE(type, 0)); 782| | 783| | // Setup the texture blend factor 784| 4| if (is_not_qnan(texture.mTextureBlend)) ------------------ | Branch (784:9): [True: 4, False: 0] ------------------ 785| 4| mat.AddProperty(&texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type, 0)); 786| | 787| | // Setup texture UV transformations 788| | mat.AddProperty(&texture.mOffsetU, 5, AI_MATKEY_UVTRANSFORM(type, 0)); 789| 4|} _ZN6Assimp11ASEImporter15ConvertMaterialERNS_3ASE8MaterialE: 793| 19|void ASEImporter::ConvertMaterial(ASE::Material &mat) { 794| | // LARGE TODO: Much code her is copied from 3DS ... join them maybe? 795| | 796| | // Allocate the output material 797| 19| mat.pcInstance = new aiMaterial(); 798| | 799| | // At first add the base ambient color of the 800| | // scene to the material 801| 19| mat.mAmbient.r += mParser->m_clrAmbient.r; 802| 19| mat.mAmbient.g += mParser->m_clrAmbient.g; 803| 19| mat.mAmbient.b += mParser->m_clrAmbient.b; 804| | 805| 19| aiString name; 806| 19| name.Set(mat.mName); 807| 19| mat.pcInstance->AddProperty(&name, AI_MATKEY_NAME); 808| | 809| | // material colors 810| 19| mat.pcInstance->AddProperty(&mat.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT); 811| 19| mat.pcInstance->AddProperty(&mat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE); 812| 19| mat.pcInstance->AddProperty(&mat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR); 813| 19| mat.pcInstance->AddProperty(&mat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE); 814| | 815| | // shininess 816| 19| if (0.0f != mat.mSpecularExponent && 0.0f != mat.mShininessStrength) { ------------------ | Branch (816:9): [True: 7, False: 12] | Branch (816:42): [True: 0, False: 7] ------------------ 817| 0| mat.pcInstance->AddProperty(&mat.mSpecularExponent, 1, AI_MATKEY_SHININESS); 818| 0| mat.pcInstance->AddProperty(&mat.mShininessStrength, 1, AI_MATKEY_SHININESS_STRENGTH); 819| 0| } 820| | // If there is no shininess, we can disable phong lighting 821| 19| else if (D3DS::Discreet3DS::Metal == mat.mShading || ------------------ | Branch (821:14): [True: 0, False: 19] ------------------ 822| 19| D3DS::Discreet3DS::Phong == mat.mShading || ------------------ | Branch (822:14): [True: 0, False: 19] ------------------ 823| 19| D3DS::Discreet3DS::Blinn == mat.mShading) { ------------------ | Branch (823:14): [True: 7, False: 12] ------------------ 824| 7| mat.mShading = D3DS::Discreet3DS::Gouraud; 825| 7| } 826| | 827| | // opacity 828| 19| mat.pcInstance->AddProperty(&mat.mTransparency, 1, AI_MATKEY_OPACITY); 829| | 830| | // Two sided rendering? 831| 19| if (mat.mTwoSided) { ------------------ | Branch (831:9): [True: 0, False: 19] ------------------ 832| 0| int i = 1; 833| 0| mat.pcInstance->AddProperty(&i, 1, AI_MATKEY_TWOSIDED); 834| 0| } 835| | 836| | // shading mode 837| 19| aiShadingMode eShading = aiShadingMode_NoShading; 838| 19| switch (mat.mShading) { ------------------ | Branch (838:13): [True: 19, False: 0] ------------------ 839| 0| case D3DS::Discreet3DS::Flat: ------------------ | Branch (839:5): [True: 0, False: 19] ------------------ 840| 0| eShading = aiShadingMode_Flat; 841| 0| break; 842| 0| case D3DS::Discreet3DS::Phong: ------------------ | Branch (842:5): [True: 0, False: 19] ------------------ 843| 0| eShading = aiShadingMode_Phong; 844| 0| break; 845| 0| case D3DS::Discreet3DS::Blinn: ------------------ | Branch (845:5): [True: 0, False: 19] ------------------ 846| 0| eShading = aiShadingMode_Blinn; 847| 0| break; 848| | 849| | // I don't know what "Wire" shading should be, 850| | // assume it is simple lambertian diffuse (L dot N) shading 851| 0| case D3DS::Discreet3DS::Wire: { ------------------ | Branch (851:5): [True: 0, False: 19] ------------------ 852| | // set the wireframe flag 853| 0| unsigned int iWire = 1; 854| 0| mat.pcInstance->AddProperty((int *)&iWire, 1, AI_MATKEY_ENABLE_WIREFRAME); 855| 0| } 856| | // fallthrough 857| 19| case D3DS::Discreet3DS::Gouraud: ------------------ | Branch (857:5): [True: 19, False: 0] ------------------ 858| 19| eShading = aiShadingMode_Gouraud; 859| 19| break; 860| 0| case D3DS::Discreet3DS::Metal: ------------------ | Branch (860:5): [True: 0, False: 19] ------------------ 861| 0| eShading = aiShadingMode_CookTorrance; 862| 0| break; 863| 19| } 864| 19| mat.pcInstance->AddProperty((int *)&eShading, 1, AI_MATKEY_SHADING_MODEL); 865| | 866| | // DIFFUSE texture 867| 19| if (mat.sTexDiffuse.mMapName.length() > 0) ------------------ | Branch (867:9): [True: 3, False: 16] ------------------ 868| 3| CopyASETexture(*mat.pcInstance, mat.sTexDiffuse, aiTextureType_DIFFUSE); 869| | 870| | // SPECULAR texture 871| 19| if (mat.sTexSpecular.mMapName.length() > 0) ------------------ | Branch (871:9): [True: 0, False: 19] ------------------ 872| 0| CopyASETexture(*mat.pcInstance, mat.sTexSpecular, aiTextureType_SPECULAR); 873| | 874| | // AMBIENT texture 875| 19| if (mat.sTexAmbient.mMapName.length() > 0) ------------------ | Branch (875:9): [True: 0, False: 19] ------------------ 876| 0| CopyASETexture(*mat.pcInstance, mat.sTexAmbient, aiTextureType_AMBIENT); 877| | 878| | // OPACITY texture 879| 19| if (mat.sTexOpacity.mMapName.length() > 0) ------------------ | Branch (879:9): [True: 0, False: 19] ------------------ 880| 0| CopyASETexture(*mat.pcInstance, mat.sTexOpacity, aiTextureType_OPACITY); 881| | 882| | // EMISSIVE texture 883| 19| if (mat.sTexEmissive.mMapName.length() > 0) ------------------ | Branch (883:9): [True: 0, False: 19] ------------------ 884| 0| CopyASETexture(*mat.pcInstance, mat.sTexEmissive, aiTextureType_EMISSIVE); 885| | 886| | // BUMP texture 887| 19| if (mat.sTexBump.mMapName.length() > 0) ------------------ | Branch (887:9): [True: 0, False: 19] ------------------ 888| 0| CopyASETexture(*mat.pcInstance, mat.sTexBump, aiTextureType_HEIGHT); 889| | 890| | // SHININESS texture 891| 19| if (mat.sTexShininess.mMapName.length() > 0) ------------------ | Branch (891:9): [True: 1, False: 18] ------------------ 892| 1| CopyASETexture(*mat.pcInstance, mat.sTexShininess, aiTextureType_SHININESS); 893| | 894| | // store the name of the material itself, too 895| 19| if (mat.mName.length() > 0) { ------------------ | Branch (895:9): [True: 19, False: 0] ------------------ 896| 19| aiString tex; 897| 19| tex.Set(mat.mName); 898| | mat.pcInstance->AddProperty(&tex, AI_MATKEY_NAME); 899| 19| } 900| 19| return; 901| 19|} _ZN6Assimp11ASEImporter13ConvertMeshesERNS_3ASE4MeshERNSt3__16vectorIP6aiMeshNS4_9allocatorIS7_EEEE: 905| 22|void ASEImporter::ConvertMeshes(ASE::Mesh &mesh, std::vector &avOutMeshes) { 906| | // validate the material index of the mesh 907| 22| if (mesh.iMaterialIndex >= mParser->m_vMaterials.size()) { ------------------ | Branch (907:9): [True: 0, False: 22] ------------------ 908| 0| mesh.iMaterialIndex = (unsigned int)mParser->m_vMaterials.size() - 1; 909| 0| ASSIMP_LOG_WARN("Material index is out of range"); 910| 0| } 911| | 912| | // If the material the mesh is assigned to consists of submeshes, split it 913| 22| if (!mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials.empty()) { ------------------ | Branch (913:9): [True: 0, False: 22] ------------------ 914| 0| std::vector vSubMaterials = mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials; 915| | 916| 0| std::vector *aiSplit = new std::vector[vSubMaterials.size()]; 917| | 918| | // build a list of all faces per sub-material 919| 0| for (unsigned int i = 0; i < mesh.mFaces.size(); ++i) { ------------------ | Branch (919:34): [True: 0, False: 0] ------------------ 920| | // check range 921| 0| if (mesh.mFaces[i].iMaterial >= vSubMaterials.size()) { ------------------ | Branch (921:17): [True: 0, False: 0] ------------------ 922| 0| ASSIMP_LOG_WARN("Submaterial index is out of range"); 923| | 924| | // use the last material instead 925| 0| aiSplit[vSubMaterials.size() - 1].push_back(i); 926| 0| } else 927| 0| aiSplit[mesh.mFaces[i].iMaterial].push_back(i); 928| 0| } 929| | 930| | // now generate submeshes 931| 0| for (unsigned int p = 0; p < vSubMaterials.size(); ++p) { ------------------ | Branch (931:34): [True: 0, False: 0] ------------------ 932| 0| if (!aiSplit[p].empty()) { ------------------ | Branch (932:17): [True: 0, False: 0] ------------------ 933| | 934| 0| aiMesh *p_pcOut = new aiMesh(); 935| 0| p_pcOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; 936| | 937| | // let the sub material index 938| 0| p_pcOut->mMaterialIndex = p; 939| | 940| | // we will need this material 941| 0| mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials[p].bNeed = true; 942| | 943| | // store the real index here ... color channel 3 944| 0| p_pcOut->mColors[3] = (aiColor4D *)(uintptr_t)mesh.iMaterialIndex; 945| | 946| | // store a pointer to the mesh in color channel 2 947| 0| p_pcOut->mColors[2] = (aiColor4D *)&mesh; 948| 0| avOutMeshes.push_back(p_pcOut); 949| | 950| | // convert vertices 951| 0| p_pcOut->mNumVertices = (unsigned int)aiSplit[p].size() * 3; 952| 0| p_pcOut->mNumFaces = (unsigned int)aiSplit[p].size(); 953| | 954| | // receive output vertex weights 955| 0| std::vector> *avOutputBones = nullptr; 956| 0| if (!mesh.mBones.empty()) { ------------------ | Branch (956:21): [True: 0, False: 0] ------------------ 957| 0| avOutputBones = new std::vector>[mesh.mBones.size()]; 958| 0| } 959| | 960| | // allocate enough storage for faces 961| 0| p_pcOut->mFaces = new aiFace[p_pcOut->mNumFaces]; 962| | 963| 0| unsigned int iBase = 0, iIndex; 964| 0| if (p_pcOut->mNumVertices) { ------------------ | Branch (964:21): [True: 0, False: 0] ------------------ 965| 0| p_pcOut->mVertices = new aiVector3D[p_pcOut->mNumVertices]; 966| 0| p_pcOut->mNormals = new aiVector3D[p_pcOut->mNumVertices]; 967| 0| for (unsigned int q = 0; q < aiSplit[p].size(); ++q) { ------------------ | Branch (967:46): [True: 0, False: 0] ------------------ 968| | 969| 0| iIndex = aiSplit[p][q]; 970| | 971| 0| p_pcOut->mFaces[q].mIndices = new unsigned int[3]; 972| 0| p_pcOut->mFaces[q].mNumIndices = 3; 973| | 974| 0| for (unsigned int t = 0; t < 3; ++t, ++iBase) { ------------------ | Branch (974:50): [True: 0, False: 0] ------------------ 975| 0| const uint32_t iIndex2 = mesh.mFaces[iIndex].mIndices[t]; 976| | 977| 0| p_pcOut->mVertices[iBase] = mesh.mPositions[iIndex2]; 978| 0| p_pcOut->mNormals[iBase] = mesh.mNormals[iIndex2]; 979| | 980| | // convert bones, if existing 981| 0| if (!mesh.mBones.empty()) { ------------------ | Branch (981:33): [True: 0, False: 0] ------------------ 982| 0| ai_assert(avOutputBones); 983| | // check whether there is a vertex weight for this vertex index 984| 0| if (iIndex2 < mesh.mBoneVertices.size()) { ------------------ | Branch (984:37): [True: 0, False: 0] ------------------ 985| | 986| 0| for (std::vector>::const_iterator 987| 0| blubb = mesh.mBoneVertices[iIndex2].mBoneWeights.begin(); 988| 0| blubb != mesh.mBoneVertices[iIndex2].mBoneWeights.end(); ++blubb) { ------------------ | Branch (988:45): [True: 0, False: 0] ------------------ 989| | 990| | // NOTE: illegal cases have already been filtered out 991| 0| avOutputBones[(*blubb).first].emplace_back( 992| 0| iBase, (*blubb).second); 993| 0| } 994| 0| } 995| 0| } 996| 0| p_pcOut->mFaces[q].mIndices[t] = iBase; 997| 0| } 998| 0| } 999| 0| } 1000| | // convert texture coordinates (up to AI_MAX_NUMBER_OF_TEXTURECOORDS sets supported) 1001| 0| for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) { ------------------ | Branch (1001:42): [True: 0, False: 0] ------------------ 1002| 0| if (!mesh.amTexCoords[c].empty()) { ------------------ | Branch (1002:25): [True: 0, False: 0] ------------------ 1003| 0| p_pcOut->mTextureCoords[c] = new aiVector3D[p_pcOut->mNumVertices]; 1004| 0| iBase = 0; 1005| 0| for (unsigned int q = 0; q < aiSplit[p].size(); ++q) { ------------------ | Branch (1005:50): [True: 0, False: 0] ------------------ 1006| 0| iIndex = aiSplit[p][q]; 1007| 0| for (unsigned int t = 0; t < 3; ++t) { ------------------ | Branch (1007:54): [True: 0, False: 0] ------------------ 1008| 0| p_pcOut->mTextureCoords[c][iBase++] = mesh.amTexCoords[c][mesh.mFaces[iIndex].mIndices[t]]; 1009| 0| } 1010| 0| } 1011| | // Setup the number of valid vertex components 1012| 0| p_pcOut->mNumUVComponents[c] = mesh.mNumUVComponents[c]; 1013| 0| } 1014| 0| } 1015| | 1016| | // Convert vertex colors (only one set supported) 1017| 0| if (!mesh.mVertexColors.empty()) { ------------------ | Branch (1017:21): [True: 0, False: 0] ------------------ 1018| 0| p_pcOut->mColors[0] = new aiColor4D[p_pcOut->mNumVertices]; 1019| 0| iBase = 0; 1020| 0| for (unsigned int q = 0; q < aiSplit[p].size(); ++q) { ------------------ | Branch (1020:46): [True: 0, False: 0] ------------------ 1021| 0| iIndex = aiSplit[p][q]; 1022| 0| for (unsigned int t = 0; t < 3; ++t) { ------------------ | Branch (1022:50): [True: 0, False: 0] ------------------ 1023| 0| p_pcOut->mColors[0][iBase++] = mesh.mVertexColors[mesh.mFaces[iIndex].mIndices[t]]; 1024| 0| } 1025| 0| } 1026| 0| } 1027| | // Copy bones 1028| 0| if (!mesh.mBones.empty()) { ------------------ | Branch (1028:21): [True: 0, False: 0] ------------------ 1029| 0| p_pcOut->mNumBones = 0; 1030| 0| for (unsigned int mrspock = 0; mrspock < mesh.mBones.size(); ++mrspock) ------------------ | Branch (1030:52): [True: 0, False: 0] ------------------ 1031| 0| if (!avOutputBones[mrspock].empty()) p_pcOut->mNumBones++; ------------------ | Branch (1031:29): [True: 0, False: 0] ------------------ 1032| | 1033| 0| p_pcOut->mBones = new aiBone *[p_pcOut->mNumBones]; 1034| 0| aiBone **pcBone = p_pcOut->mBones; 1035| 0| for (unsigned int mrspock = 0; mrspock < mesh.mBones.size(); ++mrspock) { ------------------ | Branch (1035:52): [True: 0, False: 0] ------------------ 1036| 0| if (!avOutputBones[mrspock].empty()) { ------------------ | Branch (1036:29): [True: 0, False: 0] ------------------ 1037| | // we will need this bone. add it to the output mesh and 1038| | // add all per-vertex weights 1039| 0| aiBone *pc = *pcBone = new aiBone(); 1040| 0| pc->mName.Set(mesh.mBones[mrspock].mName); 1041| | 1042| 0| pc->mNumWeights = (unsigned int)avOutputBones[mrspock].size(); 1043| 0| pc->mWeights = new aiVertexWeight[pc->mNumWeights]; 1044| | 1045| 0| for (unsigned int captainkirk = 0; captainkirk < pc->mNumWeights; ++captainkirk) { ------------------ | Branch (1045:64): [True: 0, False: 0] ------------------ 1046| 0| const std::pair &ref = avOutputBones[mrspock][captainkirk]; 1047| 0| pc->mWeights[captainkirk].mVertexId = ref.first; 1048| 0| pc->mWeights[captainkirk].mWeight = ref.second; 1049| 0| } 1050| 0| ++pcBone; 1051| 0| } 1052| 0| } 1053| | // delete allocated storage 1054| 0| delete[] avOutputBones; 1055| 0| } 1056| 0| } 1057| 0| } 1058| | // delete storage 1059| 0| delete[] aiSplit; 1060| 22| } else { 1061| | // Otherwise we can simply copy the data to one output mesh 1062| | // This codepath needs less memory and uses fast memcpy()s 1063| | // to do the actual copying. So I think it is worth the 1064| | // effort here. 1065| | 1066| 22| aiMesh *p_pcOut = new aiMesh(); 1067| 22| p_pcOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; 1068| | 1069| | // set an empty sub material index 1070| 22| p_pcOut->mMaterialIndex = ASE::Face::DEFAULT_MATINDEX; 1071| 22| mParser->m_vMaterials[mesh.iMaterialIndex].bNeed = true; 1072| | 1073| | // store the real index here ... in color channel 3 1074| 22| p_pcOut->mColors[3] = (aiColor4D *)(uintptr_t)mesh.iMaterialIndex; 1075| | 1076| | // store a pointer to the mesh in color channel 2 1077| 22| p_pcOut->mColors[2] = (aiColor4D *)&mesh; 1078| 22| avOutMeshes.push_back(p_pcOut); 1079| | 1080| | // If the mesh hasn't faces or vertices, there are two cases 1081| | // possible: 1. the model is invalid. 2. This is a dummy 1082| | // helper object which we are going to remove later ... 1083| 22| if (mesh.mFaces.empty() || mesh.mPositions.empty()) { ------------------ | Branch (1083:13): [True: 6, False: 16] | Branch (1083:36): [True: 0, False: 16] ------------------ 1084| 6| return; 1085| 6| } 1086| | 1087| | // convert vertices 1088| 16| p_pcOut->mNumVertices = (unsigned int)mesh.mPositions.size(); 1089| 16| p_pcOut->mNumFaces = (unsigned int)mesh.mFaces.size(); 1090| | 1091| | // allocate enough storage for faces 1092| 16| p_pcOut->mFaces = new aiFace[p_pcOut->mNumFaces]; 1093| | 1094| | // copy vertices 1095| 16| p_pcOut->mVertices = new aiVector3D[mesh.mPositions.size()]; 1096| 16| memcpy(p_pcOut->mVertices, &mesh.mPositions[0], 1097| 16| mesh.mPositions.size() * sizeof(aiVector3D)); 1098| | 1099| | // copy normals 1100| 16| p_pcOut->mNormals = new aiVector3D[mesh.mNormals.size()]; 1101| 16| memcpy(p_pcOut->mNormals, &mesh.mNormals[0], 1102| 16| mesh.mNormals.size() * sizeof(aiVector3D)); 1103| | 1104| | // copy texture coordinates 1105| 144| for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) { ------------------ | Branch (1105:34): [True: 128, False: 16] ------------------ 1106| 128| if (!mesh.amTexCoords[c].empty()) { ------------------ | Branch (1106:17): [True: 11, False: 117] ------------------ 1107| 11| p_pcOut->mTextureCoords[c] = new aiVector3D[mesh.amTexCoords[c].size()]; 1108| 11| memcpy(p_pcOut->mTextureCoords[c], &mesh.amTexCoords[c][0], 1109| 11| mesh.amTexCoords[c].size() * sizeof(aiVector3D)); 1110| | 1111| | // setup the number of valid vertex components 1112| 11| p_pcOut->mNumUVComponents[c] = mesh.mNumUVComponents[c]; 1113| 11| } 1114| 128| } 1115| | 1116| | // copy vertex colors 1117| 16| if (!mesh.mVertexColors.empty()) { ------------------ | Branch (1117:13): [True: 0, False: 16] ------------------ 1118| 0| p_pcOut->mColors[0] = new aiColor4D[mesh.mVertexColors.size()]; 1119| 0| memcpy(p_pcOut->mColors[0], &mesh.mVertexColors[0], 1120| 0| mesh.mVertexColors.size() * sizeof(aiColor4D)); 1121| 0| } 1122| | 1123| | // copy faces 1124| 248| for (unsigned int iFace = 0; iFace < p_pcOut->mNumFaces; ++iFace) { ------------------ | Branch (1124:38): [True: 232, False: 16] ------------------ 1125| 232| p_pcOut->mFaces[iFace].mNumIndices = 3; 1126| 232| p_pcOut->mFaces[iFace].mIndices = new unsigned int[3]; 1127| | 1128| | // copy indices 1129| 232| p_pcOut->mFaces[iFace].mIndices[0] = mesh.mFaces[iFace].mIndices[0]; 1130| 232| p_pcOut->mFaces[iFace].mIndices[1] = mesh.mFaces[iFace].mIndices[1]; 1131| 232| p_pcOut->mFaces[iFace].mIndices[2] = mesh.mFaces[iFace].mIndices[2]; 1132| 232| } 1133| | 1134| | // copy vertex bones 1135| 16| if (!mesh.mBones.empty() && !mesh.mBoneVertices.empty()) { ------------------ | Branch (1135:13): [True: 0, False: 16] | Branch (1135:37): [True: 0, False: 0] ------------------ 1136| 0| std::vector> avBonesOut(mesh.mBones.size()); 1137| | 1138| | // find all vertex weights for this bone 1139| 0| unsigned int quak = 0; 1140| 0| for (std::vector::const_iterator harrypotter = mesh.mBoneVertices.begin(); 1141| 0| harrypotter != mesh.mBoneVertices.end(); ++harrypotter, ++quak) { ------------------ | Branch (1141:21): [True: 0, False: 0] ------------------ 1142| | 1143| 0| for (std::vector>::const_iterator 1144| 0| ronaldweasley = (*harrypotter).mBoneWeights.begin(); 1145| 0| ronaldweasley != (*harrypotter).mBoneWeights.end(); ++ronaldweasley) { ------------------ | Branch (1145:25): [True: 0, False: 0] ------------------ 1146| 0| aiVertexWeight weight; 1147| 0| weight.mVertexId = quak; 1148| 0| weight.mWeight = (*ronaldweasley).second; 1149| 0| avBonesOut[(*ronaldweasley).first].push_back(weight); 1150| 0| } 1151| 0| } 1152| | 1153| | // now build a final bone list 1154| 0| p_pcOut->mNumBones = 0; 1155| 0| for (unsigned int jfkennedy = 0; jfkennedy < mesh.mBones.size(); ++jfkennedy) ------------------ | Branch (1155:46): [True: 0, False: 0] ------------------ 1156| 0| if (!avBonesOut[jfkennedy].empty()) p_pcOut->mNumBones++; ------------------ | Branch (1156:21): [True: 0, False: 0] ------------------ 1157| | 1158| 0| p_pcOut->mBones = new aiBone *[p_pcOut->mNumBones]; 1159| 0| aiBone **pcBone = p_pcOut->mBones; 1160| 0| for (unsigned int jfkennedy = 0; jfkennedy < mesh.mBones.size(); ++jfkennedy) { ------------------ | Branch (1160:46): [True: 0, False: 0] ------------------ 1161| 0| if (!avBonesOut[jfkennedy].empty()) { ------------------ | Branch (1161:21): [True: 0, False: 0] ------------------ 1162| 0| aiBone *pc = *pcBone = new aiBone(); 1163| 0| pc->mName.Set(mesh.mBones[jfkennedy].mName); 1164| 0| pc->mNumWeights = (unsigned int)avBonesOut[jfkennedy].size(); 1165| 0| pc->mWeights = new aiVertexWeight[pc->mNumWeights]; 1166| 0| ::memcpy(pc->mWeights, &avBonesOut[jfkennedy][0], 1167| 0| sizeof(aiVertexWeight) * pc->mNumWeights); 1168| 0| ++pcBone; 1169| 0| } 1170| 0| } 1171| 0| } 1172| 16| } 1173| 22|} _ZN6Assimp11ASEImporter20BuildMaterialIndicesEv: 1177| 15|void ASEImporter::BuildMaterialIndices() { 1178| 15| ai_assert(nullptr != pcScene); 1179| | 1180| | // iterate through all materials and check whether we need them 1181| 34| for (unsigned int iMat = 0; iMat < mParser->m_vMaterials.size(); ++iMat) { ------------------ | Branch (1181:33): [True: 19, False: 15] ------------------ 1182| 19| ASE::Material &mat = mParser->m_vMaterials[iMat]; 1183| 19| if (mat.bNeed) { ------------------ | Branch (1183:13): [True: 19, False: 0] ------------------ 1184| | // Convert it to the aiMaterial layout 1185| 19| ConvertMaterial(mat); 1186| 19| ++pcScene->mNumMaterials; 1187| 19| } 1188| 19| for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size(); ++iSubMat) { ------------------ | Branch (1188:40): [True: 0, False: 19] ------------------ 1189| 0| ASE::Material &submat = mat.avSubMaterials[iSubMat]; 1190| 0| if (submat.bNeed) { ------------------ | Branch (1190:17): [True: 0, False: 0] ------------------ 1191| | // Convert it to the aiMaterial layout 1192| 0| ConvertMaterial(submat); 1193| 0| ++pcScene->mNumMaterials; 1194| 0| } 1195| 0| } 1196| 19| } 1197| | 1198| | // allocate the output material array 1199| 15| pcScene->mMaterials = new aiMaterial *[pcScene->mNumMaterials]; 1200| 15| D3DS::Material **pcIntMaterials = new D3DS::Material *[pcScene->mNumMaterials]; 1201| | 1202| 15| unsigned int iNum = 0; 1203| 34| for (unsigned int iMat = 0; iMat < mParser->m_vMaterials.size(); ++iMat) { ------------------ | Branch (1203:33): [True: 19, False: 15] ------------------ 1204| 19| ASE::Material &mat = mParser->m_vMaterials[iMat]; 1205| 19| if (mat.bNeed) { ------------------ | Branch (1205:13): [True: 19, False: 0] ------------------ 1206| 19| ai_assert(nullptr != mat.pcInstance); 1207| 19| pcScene->mMaterials[iNum] = mat.pcInstance; 1208| | 1209| | // Store the internal material, too 1210| 19| pcIntMaterials[iNum] = &mat; 1211| | 1212| | // Iterate through all meshes and search for one which is using 1213| | // this top-level material index 1214| 55| for (unsigned int iMesh = 0; iMesh < pcScene->mNumMeshes; ++iMesh) { ------------------ | Branch (1214:42): [True: 36, False: 19] ------------------ 1215| 36| aiMesh *mesh = pcScene->mMeshes[iMesh]; 1216| 36| if (ASE::Face::DEFAULT_MATINDEX == mesh->mMaterialIndex && ------------------ | Branch (1216:21): [True: 26, False: 10] ------------------ 1217| 26| iMat == (uintptr_t)mesh->mColors[3]) { ------------------ | Branch (1217:25): [True: 16, False: 10] ------------------ 1218| 16| mesh->mMaterialIndex = iNum; 1219| 16| mesh->mColors[3] = nullptr; 1220| 16| } 1221| 36| } 1222| 19| iNum++; 1223| 19| } 1224| 19| for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size(); ++iSubMat) { ------------------ | Branch (1224:40): [True: 0, False: 19] ------------------ 1225| 0| ASE::Material &submat = mat.avSubMaterials[iSubMat]; 1226| 0| if (submat.bNeed) { ------------------ | Branch (1226:17): [True: 0, False: 0] ------------------ 1227| 0| ai_assert(nullptr != submat.pcInstance); 1228| 0| pcScene->mMaterials[iNum] = submat.pcInstance; 1229| | 1230| | // Store the internal material, too 1231| 0| pcIntMaterials[iNum] = &submat; 1232| | 1233| | // Iterate through all meshes and search for one which is using 1234| | // this sub-level material index 1235| 0| for (unsigned int iMesh = 0; iMesh < pcScene->mNumMeshes; ++iMesh) { ------------------ | Branch (1235:46): [True: 0, False: 0] ------------------ 1236| 0| aiMesh *mesh = pcScene->mMeshes[iMesh]; 1237| | 1238| 0| if (iSubMat == mesh->mMaterialIndex && iMat == (uintptr_t)mesh->mColors[3]) { ------------------ | Branch (1238:25): [True: 0, False: 0] | Branch (1238:60): [True: 0, False: 0] ------------------ 1239| 0| mesh->mMaterialIndex = iNum; 1240| 0| mesh->mColors[3] = nullptr; 1241| 0| } 1242| 0| } 1243| 0| iNum++; 1244| 0| } 1245| 0| } 1246| 19| } 1247| | 1248| | // Delete our temporary array 1249| 15| delete[] pcIntMaterials; 1250| 15|} _ZN6Assimp11ASEImporter15GenerateNormalsERNS_3ASE4MeshE: 1254| 22|bool ASEImporter::GenerateNormals(ASE::Mesh &mesh) { 1255| | 1256| 22| if (!mesh.mNormals.empty() && !configRecomputeNormals) { ------------------ | Branch (1256:9): [True: 11, False: 11] | Branch (1256:35): [True: 0, False: 11] ------------------ 1257| | // Check whether there are only uninitialized normals. If there are 1258| | // some, skip all normals from the file and compute them on our own 1259| 0| for (std::vector::const_iterator qq = mesh.mNormals.begin(); qq != mesh.mNormals.end(); ++qq) { ------------------ | Branch (1259:82): [True: 0, False: 0] ------------------ 1260| 0| if ((*qq).x || (*qq).y || (*qq).z) { ------------------ | Branch (1260:17): [True: 0, False: 0] | Branch (1260:28): [True: 0, False: 0] | Branch (1260:39): [True: 0, False: 0] ------------------ 1261| 0| return true; 1262| 0| } 1263| 0| } 1264| 0| } 1265| | // The array is reused. 1266| 22| ComputeNormalsWithSmoothingsGroups(mesh); 1267| 22| return false; 1268| 22|} _ZN6Assimp3ASE6ParserC2EPKcmj: 115| 43| mFilePtr(nullptr), mEnd (nullptr) { 116| 43| ai_assert(file != nullptr); 117| | 118| 43| mFilePtr = file; 119| 43| mEnd = mFilePtr + fileLen; 120| 43| iFileFormat = fileFormatDefault; 121| | 122| | // make sure that the color values are invalid 123| 43| m_clrBackground.r = get_qnan(); 124| 43| m_clrAmbient.r = get_qnan(); 125| | 126| | // setup some default values 127| 43| iLineNumber = 0; 128| 43| iFirstFrame = 0; 129| 43| iLastFrame = 0; 130| 43| iFrameSpeed = 30; // use 30 as default value for this property 131| 43| iTicksPerFrame = 1; // use 1 as default value for this property 132| 43| bLastWasEndLine = false; // need to handle \r\n seqs due to binary file mapping 133| 43|} _ZN6Assimp3ASE6Parser10LogWarningEPKc: 136| 7.77k|void Parser::LogWarning(const char *szWarn) { 137| 7.77k| ai_assert(nullptr != szWarn); 138| | 139| 7.77k| char szTemp[2048]; 140| |#if _MSC_VER >= 1400 141| | sprintf_s(szTemp, "Line %u: %s", iLineNumber, szWarn); 142| |#else 143| 7.77k| ai_snprintf(szTemp, sizeof(szTemp), "Line %u: %s", iLineNumber, szWarn); 144| 7.77k|#endif 145| | 146| | // output the warning to the logger ... 147| | ASSIMP_LOG_WARN(szTemp); 148| 7.77k|} _ZN6Assimp3ASE6Parser7LogInfoEPKc: 151| 26|void Parser::LogInfo(const char *szWarn) { 152| 26| ai_assert(nullptr != szWarn); 153| | 154| 26| char szTemp[1024]; 155| |#if _MSC_VER >= 1400 156| | sprintf_s(szTemp, "Line %u: %s", iLineNumber, szWarn); 157| |#else 158| 26| ai_snprintf(szTemp, 1024, "Line %u: %s", iLineNumber, szWarn); 159| 26|#endif 160| | 161| | // output the information to the logger ... 162| | ASSIMP_LOG_INFO(szTemp); 163| 26|} _ZN6Assimp3ASE6Parser8LogErrorEPKc: 166| 20|AI_WONT_RETURN void Parser::LogError(const char *szWarn) { 167| 20| ai_assert(nullptr != szWarn); 168| | 169| 20| char szTemp[1024]; 170| |#if _MSC_VER >= 1400 171| | sprintf_s(szTemp, "Line %u: %s", iLineNumber, szWarn); 172| |#else 173| 20| ai_snprintf(szTemp, 1024, "Line %u: %s", iLineNumber, szWarn); 174| 20|#endif 175| | 176| | // throw an exception 177| 20| throw DeadlyImportError(szTemp); 178| 20|} _ZN6Assimp3ASE6Parser15SkipToNextTokenEv: 181| 940|bool Parser::SkipToNextToken() { 182| 21.4k| while (true) { ------------------ | Branch (182:12): [True: 21.4k, Folded] ------------------ 183| 21.4k| char me = *mFilePtr; 184| | 185| 21.4k| if (mFilePtr == mEnd) { ------------------ | Branch (185:13): [True: 0, False: 21.4k] ------------------ 186| 0| return false; 187| 0| } 188| | 189| | // increase the line number counter if necessary 190| 21.4k| if (IsLineEnd(me) && !bLastWasEndLine) { ------------------ | Branch (190:13): [True: 2.45k, False: 18.9k] | Branch (190:30): [True: 1.66k, False: 789] ------------------ 191| 1.66k| ++iLineNumber; 192| 1.66k| bLastWasEndLine = true; 193| 1.66k| } else 194| 19.7k| bLastWasEndLine = false; 195| 21.4k| if ('*' == me || '}' == me || '{' == me) { ------------------ | Branch (195:13): [True: 643, False: 20.8k] | Branch (195:26): [True: 251, False: 20.5k] | Branch (195:39): [True: 30, False: 20.5k] ------------------ 196| 924| return true; 197| 924| } 198| 20.5k| if ('\0' == me) { ------------------ | Branch (198:13): [True: 16, False: 20.5k] ------------------ 199| 16| return false; 200| 16| } 201| | 202| 20.5k| ++mFilePtr; 203| 20.5k| } 204| 940|} _ZN6Assimp3ASE6Parser11SkipSectionEv: 207| 5|bool Parser::SkipSection() { 208| | // must handle subsections ... 209| 5| int iCnt = 0; 210| 7.92k| while (true) { ------------------ | Branch (210:12): [True: 7.92k, Folded] ------------------ 211| 7.92k| if ('}' == *mFilePtr) { ------------------ | Branch (211:13): [True: 5, False: 7.91k] ------------------ 212| 5| --iCnt; 213| 5| if (0 == iCnt) { ------------------ | Branch (213:17): [True: 5, False: 0] ------------------ 214| | // go to the next valid token ... 215| 5| ++mFilePtr; 216| 5| SkipToNextToken(); 217| 5| return true; 218| 5| } 219| 7.91k| } else if ('{' == *mFilePtr) { ------------------ | Branch (219:20): [True: 5, False: 7.91k] ------------------ 220| 5| ++iCnt; 221| 7.91k| } else if ('\0' == *mFilePtr) { ------------------ | Branch (221:20): [True: 0, False: 7.91k] ------------------ 222| 0| LogWarning("Unable to parse block: Unexpected EOF, closing bracket \'}\' was expected [#1]"); 223| 0| return false; 224| 7.91k| } else if (IsLineEnd(*mFilePtr)) ------------------ | Branch (224:20): [True: 160, False: 7.75k] ------------------ 225| 160| ++iLineNumber; 226| 7.91k| ++mFilePtr; 227| 7.91k| } 228| 5|} _ZN6Assimp3ASE6Parser5ParseEv: 231| 43|void Parser::Parse() { 232| 43| AI_ASE_PARSER_INIT(); ------------------ | | 63| 43| int iDepth = 0; ------------------ 233| 6.07k| while (true) { ------------------ | Branch (233:12): [True: 6.04k, Folded] ------------------ 234| 6.04k| if ('*' == *mFilePtr) { ------------------ | Branch (234:13): [True: 434, False: 5.61k] ------------------ 235| 434| ++mFilePtr; 236| | 237| | // Version should be 200. Validate this ... 238| 434| if (TokenMatch(mFilePtr, "3DSMAX_ASCIIEXPORT", 18)) { ------------------ | Branch (238:17): [True: 34, False: 400] ------------------ 239| 34| unsigned int fmt; 240| 34| ParseLV4MeshLong(fmt); 241| | 242| 34| if (fmt > 200) { ------------------ | Branch (242:21): [True: 0, False: 34] ------------------ 243| 0| LogWarning("Unknown file format version: *3DSMAX_ASCIIEXPORT should \ 244| 0| be <= 200"); 245| 0| } 246| | // ************************************************************* 247| | // - fmt will be 0 if we're unable to read the version number 248| | // there are some faulty files without a version number ... 249| | // in this case we'll guess the exact file format by looking 250| | // at the file extension (ASE, ASK, ASC) 251| | // ************************************************************* 252| | 253| 34| if (fmt) { ------------------ | Branch (253:21): [True: 27, False: 7] ------------------ 254| 27| iFileFormat = fmt; 255| 27| } 256| 34| continue; 257| 34| } 258| | // main scene information 259| 400| if (TokenMatch(mFilePtr, "SCENE", 5)) { ------------------ | Branch (259:17): [True: 20, False: 380] ------------------ 260| 20| ParseLV1SceneBlock(); 261| 20| continue; 262| 20| } 263| | // "group" - no implementation yet, in facte 264| | // we're just ignoring them for the moment 265| 380| if (TokenMatch(mFilePtr, "GROUP", 5)) { ------------------ | Branch (265:17): [True: 0, False: 380] ------------------ 266| 0| Parse(); 267| 0| continue; 268| 0| } 269| | // material list 270| 380| if (TokenMatch(mFilePtr, "MATERIAL_LIST", 13)) { ------------------ | Branch (270:17): [True: 31, False: 349] ------------------ 271| 31| ParseLV1MaterialListBlock(); 272| 31| continue; 273| 31| } 274| | // geometric object (mesh) 275| 349| if (TokenMatch(mFilePtr, "GEOMOBJECT", 10)) ------------------ | Branch (275:17): [True: 41, False: 308] ------------------ 276| | 277| 41| { 278| 41| m_vMeshes.emplace_back("UNNAMED"); 279| 41| ParseLV1ObjectBlock(m_vMeshes.back()); 280| 41| continue; 281| 41| } 282| | // helper object = dummy in the hierarchy 283| 308| if (TokenMatch(mFilePtr, "HELPEROBJECT", 12)) ------------------ | Branch (283:17): [True: 0, False: 308] ------------------ 284| | 285| 0| { 286| 0| m_vDummies.emplace_back(); 287| 0| ParseLV1ObjectBlock(m_vDummies.back()); 288| 0| continue; 289| 0| } 290| | // light object 291| 308| if (TokenMatch(mFilePtr, "LIGHTOBJECT", 11)) ------------------ | Branch (291:17): [True: 5, False: 303] ------------------ 292| | 293| 5| { 294| 5| m_vLights.emplace_back("UNNAMED"); 295| 5| ParseLV1ObjectBlock(m_vLights.back()); 296| 5| continue; 297| 5| } 298| | // camera object 299| 303| if (TokenMatch(mFilePtr, "CAMERAOBJECT", 12)) { ------------------ | Branch (299:17): [True: 8, False: 295] ------------------ 300| 8| m_vCameras.emplace_back("UNNAMED"); 301| 8| ParseLV1ObjectBlock(m_vCameras.back()); 302| 8| continue; 303| 8| } 304| | // comment - print it on the console 305| 295| if (TokenMatch(mFilePtr, "COMMENT", 7)) { ------------------ | Branch (305:17): [True: 26, False: 269] ------------------ 306| 26| std::string out = ""; 307| 26| ParseString(out, "*COMMENT"); 308| 26| LogInfo(("Comment: " + out).c_str()); 309| 26| continue; 310| 26| } 311| | // ASC bone weights 312| 269| if (AI_ASE_IS_OLD_FILE_FORMAT() && TokenMatch(mFilePtr, "MESH_SOFTSKINVERTS", 18)) { ------------------ | | 380| 538|#define AI_ASE_IS_OLD_FILE_FORMAT() (iFileFormat < 200) | | ------------------ | | | Branch (380:37): [True: 1, False: 268] | | ------------------ ------------------ | Branch (312:48): [True: 1, False: 0] ------------------ 313| 1| ParseLV1SoftSkinBlock(); 314| 1| } 315| 269| } 316| 11.7k| AI_ASE_HANDLE_TOP_LEVEL_SECTION(); ------------------ | | 69| 6.04k| else if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (69:14): [True: 11, False: 5.60k] | | ------------------ | | 70| 5.61k| ++iDepth; \ | | 71| 5.61k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (71:14): [True: 25, False: 5.57k] | | ------------------ | | 72| 25| if (0 == --iDepth) { \ | | ------------------ | | | Branch (72:13): [True: 0, False: 25] | | ------------------ | | 73| 0| ++mFilePtr; \ | | 74| 0| SkipToNextToken(); \ | | 75| 0| return; \ | | 76| 0| } \ | | 77| 25| } \ | | 78| 6.04k| if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (78:9): [True: 19, False: 5.86k] | | ------------------ | | 79| 19| return; \ | | 80| 19| } \ | | 81| 5.88k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) {\ | | ------------------ | | | Branch (81:9): [True: 675, False: 5.19k] | | | Branch (81:33): [True: 459, False: 216] | | ------------------ | | 82| 459| ++iLineNumber; \ | | 83| 459| bLastWasEndLine = true; \ | | 84| 459| } else \ | | 85| 5.86k| bLastWasEndLine = false; \ | | 86| 5.86k| ++mFilePtr; ------------------ 317| 11.7k| } 318| 43|} _ZN6Assimp3ASE6Parser21ParseLV1SoftSkinBlockEv: 321| 1|void Parser::ParseLV1SoftSkinBlock() { 322| | // TODO: fix line counting here 323| | 324| | // ************************************************************** 325| | // The soft skin block is formatted differently. There are no 326| | // nested sections supported and the single elements aren't 327| | // marked by keywords starting with an asterisk. 328| | 329| | /** 330| | FORMAT BEGIN 331| | 332| | *MESH_SOFTSKINVERTS { 333| | 334| | 335| | 336| | [for times:] 337| | [for times:] 338| | } 339| | 340| | FORMAT END 341| | */ 342| | // ************************************************************** 343| 922| while (true) { ------------------ | Branch (343:12): [True: 922, Folded] ------------------ 344| 922| if (*mFilePtr == '}') { ------------------ | Branch (344:13): [True: 0, False: 922] ------------------ 345| 0| ++mFilePtr; 346| 0| return; 347| 922| } else if (*mFilePtr == '\0') ------------------ | Branch (347:20): [True: 0, False: 922] ------------------ 348| 0| return; 349| 922| else if (*mFilePtr == '{') ------------------ | Branch (349:18): [True: 0, False: 922] ------------------ 350| 0| ++mFilePtr; 351| | 352| 922| else // if (!IsSpace(*filePtr) && !IsLineEnd(*filePtr)) 353| 922| { 354| 922| ASE::Mesh *curMesh = nullptr; 355| 922| unsigned int numVerts = 0; 356| | 357| 922| const char *sz = mFilePtr; 358| 10.7k| while (!IsSpaceOrNewLine(*mFilePtr)) { ------------------ | Branch (358:20): [True: 9.85k, False: 922] ------------------ 359| 9.85k| ++mFilePtr; 360| 9.85k| } 361| | 362| 922| const unsigned int diff = (unsigned int)(mFilePtr - sz); 363| 922| if (diff) { ------------------ | Branch (363:17): [True: 910, False: 12] ------------------ 364| 910| std::string name = std::string(sz, diff); 365| 910| for (std::vector::iterator it = m_vMeshes.begin(); 366| 910| it != m_vMeshes.end(); ++it) { ------------------ | Branch (366:25): [True: 0, False: 910] ------------------ 367| 0| if ((*it).mName == name) { ------------------ | Branch (367:25): [True: 0, False: 0] ------------------ 368| 0| curMesh = &(*it); 369| 0| break; 370| 0| } 371| 0| } 372| 910| if (!curMesh) { ------------------ | Branch (372:21): [True: 910, False: 0] ------------------ 373| 910| LogWarning("Encountered unknown mesh in *MESH_SOFTSKINVERTS section"); 374| | 375| | // Skip the mesh data - until we find a new mesh 376| | // or the end of the *MESH_SOFTSKINVERTS section 377| 1.04k| while (true) { ------------------ | Branch (377:28): [True: 1.04k, Folded] ------------------ 378| 1.04k| SkipSpacesAndLineEnd(&mFilePtr, mEnd); 379| 1.04k| if (*mFilePtr == '}') { ------------------ | Branch (379:29): [True: 0, False: 1.04k] ------------------ 380| 0| ++mFilePtr; 381| 0| return; 382| 1.04k| } else if (!IsNumeric(*mFilePtr)) ------------------ | Branch (382:36): [True: 910, False: 139] ------------------ 383| 910| break; 384| | 385| 139| SkipLine(&mFilePtr, mEnd); 386| 139| } 387| 910| } else { 388| 0| SkipSpacesAndLineEnd(&mFilePtr, mEnd); 389| 0| ParseLV4MeshLong(numVerts); 390| | 391| | // Reserve enough storage 392| 0| curMesh->mBoneVertices.reserve(numVerts); 393| | 394| 0| for (unsigned int i = 0; i < numVerts; ++i) { ------------------ | Branch (394:46): [True: 0, False: 0] ------------------ 395| 0| SkipSpacesAndLineEnd(&mFilePtr, mEnd); 396| 0| unsigned int numWeights; 397| 0| ParseLV4MeshLong(numWeights); 398| | 399| 0| curMesh->mBoneVertices.emplace_back(); 400| 0| ASE::BoneVertex &vert = curMesh->mBoneVertices.back(); 401| | 402| | // Reserve enough storage 403| 0| vert.mBoneWeights.reserve(numWeights); 404| | 405| 0| std::string bone; 406| 0| for (unsigned int w = 0; w < numWeights; ++w) { ------------------ | Branch (406:50): [True: 0, False: 0] ------------------ 407| 0| bone.clear(); 408| 0| ParseString(bone, "*MESH_SOFTSKINVERTS.Bone"); 409| | 410| | // Find the bone in the mesh's list 411| 0| std::pair me; 412| 0| me.first = -1; 413| | 414| 0| for (unsigned int n = 0; n < curMesh->mBones.size(); ++n) { ------------------ | Branch (414:54): [True: 0, False: 0] ------------------ 415| 0| if (curMesh->mBones[n].mName == bone) { ------------------ | Branch (415:37): [True: 0, False: 0] ------------------ 416| 0| me.first = n; 417| 0| break; 418| 0| } 419| 0| } 420| 0| if (-1 == me.first) { ------------------ | Branch (420:33): [True: 0, False: 0] ------------------ 421| | // We don't have this bone yet, so add it to the list 422| 0| me.first = static_cast(curMesh->mBones.size()); 423| 0| curMesh->mBones.emplace_back(bone); 424| 0| } 425| 0| ParseLV4MeshReal(me.second); 426| | 427| | // Add the new bone weight to list 428| 0| vert.mBoneWeights.push_back(me); 429| 0| } 430| 0| } 431| 0| } 432| 910| } 433| 922| } 434| 922| if (*mFilePtr == '\0') ------------------ | Branch (434:13): [True: 1, False: 921] ------------------ 435| 1| return; 436| 921| ++mFilePtr; 437| 921| SkipSpacesAndLineEnd(&mFilePtr, mEnd); 438| 921| } 439| 1|} _ZN6Assimp3ASE6Parser18ParseLV1SceneBlockEv: 442| 20|void Parser::ParseLV1SceneBlock() { 443| 20| AI_ASE_PARSER_INIT(); ------------------ | | 63| 20| int iDepth = 0; ------------------ 444| 1.11k| while (true) { ------------------ | Branch (444:12): [True: 1.11k, Folded] ------------------ 445| 1.11k| if ('*' == *mFilePtr) { ------------------ | Branch (445:13): [True: 138, False: 980] ------------------ 446| 138| ++mFilePtr; 447| 138| if (TokenMatch(mFilePtr, "SCENE_BACKGROUND_STATIC", 23)) ------------------ | Branch (447:17): [True: 18, False: 120] ------------------ 448| | 449| 18| { 450| | // parse a color triple and assume it is really the bg color 451| 18| ParseLV4MeshFloatTriple(&m_clrBackground.r); 452| 18| continue; 453| 18| } 454| 120| if (TokenMatch(mFilePtr, "SCENE_AMBIENT_STATIC", 20)) ------------------ | Branch (454:17): [True: 20, False: 100] ------------------ 455| | 456| 20| { 457| | // parse a color triple and assume it is really the bg color 458| 20| ParseLV4MeshFloatTriple(&m_clrAmbient.r); 459| 20| continue; 460| 20| } 461| 100| if (TokenMatch(mFilePtr, "SCENE_FIRSTFRAME", 16)) { ------------------ | Branch (461:17): [True: 20, False: 80] ------------------ 462| 20| ParseLV4MeshLong(iFirstFrame); 463| 20| continue; 464| 20| } 465| 80| if (TokenMatch(mFilePtr, "SCENE_LASTFRAME", 15)) { ------------------ | Branch (465:17): [True: 20, False: 60] ------------------ 466| 20| ParseLV4MeshLong(iLastFrame); 467| 20| continue; 468| 20| } 469| 60| if (TokenMatch(mFilePtr, "SCENE_FRAMESPEED", 16)) { ------------------ | Branch (469:17): [True: 20, False: 40] ------------------ 470| 20| ParseLV4MeshLong(iFrameSpeed); 471| 20| continue; 472| 20| } 473| 40| if (TokenMatch(mFilePtr, "SCENE_TICKSPERFRAME", 19)) { ------------------ | Branch (473:17): [True: 18, False: 22] ------------------ 474| 18| ParseLV4MeshLong(iTicksPerFrame); 475| 18| continue; 476| 18| } 477| 40| } 478| 1.96k| AI_ASE_HANDLE_TOP_LEVEL_SECTION(); ------------------ | | 69| 1.11k| else if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (69:14): [True: 20, False: 960] | | ------------------ | | 70| 980| ++iDepth; \ | | 71| 980| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (71:14): [True: 20, False: 940] | | ------------------ | | 72| 20| if (0 == --iDepth) { \ | | ------------------ | | | Branch (72:13): [True: 20, False: 0] | | ------------------ | | 73| 20| ++mFilePtr; \ | | 74| 20| SkipToNextToken(); \ | | 75| 20| return; \ | | 76| 20| } \ | | 77| 20| } \ | | 78| 1.11k| if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (78:9): [True: 0, False: 982] | | ------------------ | | 79| 0| return; \ | | 80| 0| } \ | | 81| 982| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) {\ | | ------------------ | | | Branch (81:9): [True: 158, False: 824] | | | Branch (81:33): [True: 158, False: 0] | | ------------------ | | 82| 158| ++iLineNumber; \ | | 83| 158| bLastWasEndLine = true; \ | | 84| 158| } else \ | | 85| 982| bLastWasEndLine = false; \ | | 86| 982| ++mFilePtr; ------------------ 479| 1.96k| } 480| 20|} _ZN6Assimp3ASE6Parser25ParseLV1MaterialListBlockEv: 483| 31|void Parser::ParseLV1MaterialListBlock() { 484| 31| AI_ASE_PARSER_INIT(); ------------------ | | 63| 31| int iDepth = 0; ------------------ 485| | 486| 31| unsigned int iMaterialCount = 0; 487| 31| unsigned int iOldMaterialCount = (unsigned int)m_vMaterials.size(); 488| 25.0k| while (true) { ------------------ | Branch (488:12): [True: 25.0k, Folded] ------------------ 489| 25.0k| if ('*' == *mFilePtr) { ------------------ | Branch (489:13): [True: 40, False: 25.0k] ------------------ 490| 40| ++mFilePtr; 491| 40| if (TokenMatch(mFilePtr, "MATERIAL_COUNT", 14)) { ------------------ | Branch (491:17): [True: 27, False: 13] ------------------ 492| 27| ParseLV4MeshLong(iMaterialCount); 493| | 494| 27| if (UINT_MAX - iOldMaterialCount < iMaterialCount) { ------------------ | Branch (494:21): [True: 0, False: 27] ------------------ 495| 0| LogWarning("Out of range: material index is too large"); 496| 0| return; 497| 0| } 498| | 499| | // now allocate enough storage to hold all materials 500| 27| m_vMaterials.resize(iOldMaterialCount + iMaterialCount, Material("INVALID")); 501| 27| continue; 502| 27| } 503| 13| if (TokenMatch(mFilePtr, "MATERIAL", 8)) { ------------------ | Branch (503:17): [True: 12, False: 1] ------------------ 504| | // ensure we have at least one material allocated 505| 12| if (iMaterialCount == 0) { ------------------ | Branch (505:21): [True: 4, False: 8] ------------------ 506| 4| LogWarning("*MATERIAL_COUNT unspecified or 0"); 507| 4| iMaterialCount = 1; 508| 4| m_vMaterials.resize(iOldMaterialCount + iMaterialCount, Material("INVALID")); 509| 4| } 510| | 511| 12| unsigned int iIndex = 0; 512| 12| ParseLV4MeshLong(iIndex); 513| | 514| 12| if (iIndex >= iMaterialCount) { ------------------ | Branch (514:21): [True: 0, False: 12] ------------------ 515| 0| LogWarning("Out of range: material index is too large"); 516| 0| iIndex = iMaterialCount - 1; 517| 0| } 518| | 519| | // get a reference to the material 520| 12| Material &sMat = m_vMaterials[iIndex + iOldMaterialCount]; 521| | // parse the material block 522| 12| ParseLV2MaterialBlock(sMat); 523| 12| continue; 524| 12| } 525| 1| if( iDepth == 1 ){ ------------------ | Branch (525:17): [True: 1, False: 0] ------------------ 526| | // CRUDE HACK: support missing brace after "Ascii Scene Exporter v2.51" 527| 1| LogWarning("Missing closing brace in material list"); 528| 1| --mFilePtr; 529| 1| return; 530| 1| } 531| 1| } 532| 49.9k| AI_ASE_HANDLE_TOP_LEVEL_SECTION(); ------------------ | | 69| 25.0k| else if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (69:14): [True: 884, False: 24.1k] | | ------------------ | | 70| 25.0k| ++iDepth; \ | | 71| 25.0k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (71:14): [True: 26, False: 24.1k] | | ------------------ | | 72| 26| if (0 == --iDepth) { \ | | ------------------ | | | Branch (72:13): [True: 26, False: 0] | | ------------------ | | 73| 26| ++mFilePtr; \ | | 74| 26| SkipToNextToken(); \ | | 75| 26| return; \ | | 76| 26| } \ | | 77| 26| } \ | | 78| 25.0k| if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (78:9): [True: 0, False: 24.9k] | | ------------------ | | 79| 0| return; \ | | 80| 0| } \ | | 81| 24.9k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) {\ | | ------------------ | | | Branch (81:9): [True: 434, False: 24.5k] | | | Branch (81:33): [True: 417, False: 17] | | ------------------ | | 82| 417| ++iLineNumber; \ | | 83| 417| bLastWasEndLine = true; \ | | 84| 417| } else \ | | 85| 24.9k| bLastWasEndLine = false; \ | | 86| 24.9k| ++mFilePtr; ------------------ 533| 49.9k| } 534| 31|} _ZN6Assimp3ASE6Parser21ParseLV2MaterialBlockERNS0_8MaterialE: 537| 12|void Parser::ParseLV2MaterialBlock(ASE::Material &mat) { 538| 12| AI_ASE_PARSER_INIT(); ------------------ | | 63| 12| int iDepth = 0; ------------------ 539| | 540| 12| unsigned int iNumSubMaterials = 0; 541| 4.20k| while (true) { ------------------ | Branch (541:12): [True: 4.20k, Folded] ------------------ 542| 4.20k| if ('*' == *mFilePtr) { ------------------ | Branch (542:13): [True: 148, False: 4.05k] ------------------ 543| 148| ++mFilePtr; 544| 148| if (TokenMatch(mFilePtr, "MATERIAL_NAME", 13)) { ------------------ | Branch (544:17): [True: 8, False: 140] ------------------ 545| 8| if (!ParseString(mat.mName, "*MATERIAL_NAME")) ------------------ | Branch (545:21): [True: 0, False: 8] ------------------ 546| 0| SkipToNextToken(); 547| 8| continue; 548| 8| } 549| | // ambient material color 550| 140| if (TokenMatch(mFilePtr, "MATERIAL_AMBIENT", 16)) { ------------------ | Branch (550:17): [True: 8, False: 132] ------------------ 551| 8| ParseLV4MeshFloatTriple(&mat.mAmbient.r); 552| 8| continue; 553| 8| } 554| | // diffuse material color 555| 132| if (TokenMatch(mFilePtr, "MATERIAL_DIFFUSE", 16)) { ------------------ | Branch (555:17): [True: 8, False: 124] ------------------ 556| 8| ParseLV4MeshFloatTriple(&mat.mDiffuse.r); 557| 8| continue; 558| 8| } 559| | // specular material color 560| 124| if (TokenMatch(mFilePtr, "MATERIAL_SPECULAR", 17)) { ------------------ | Branch (560:17): [True: 8, False: 116] ------------------ 561| 8| ParseLV4MeshFloatTriple(&mat.mSpecular.r); 562| 8| continue; 563| 8| } 564| | // material shading type 565| 116| if (TokenMatch(mFilePtr, "MATERIAL_SHADING", 16)) { ------------------ | Branch (565:17): [True: 8, False: 108] ------------------ 566| 8| if (TokenMatch(mFilePtr, "Blinn", 5)) { ------------------ | Branch (566:21): [True: 8, False: 0] ------------------ 567| 8| mat.mShading = Discreet3DS::Blinn; 568| 8| } else if (TokenMatch(mFilePtr, "Phong", 5)) { ------------------ | Branch (568:28): [True: 0, False: 0] ------------------ 569| 0| mat.mShading = Discreet3DS::Phong; 570| 0| } else if (TokenMatch(mFilePtr, "Flat", 4)) { ------------------ | Branch (570:28): [True: 0, False: 0] ------------------ 571| 0| mat.mShading = Discreet3DS::Flat; 572| 0| } else if (TokenMatch(mFilePtr, "Wire", 4)) { ------------------ | Branch (572:28): [True: 0, False: 0] ------------------ 573| 0| mat.mShading = Discreet3DS::Wire; 574| 0| } else { 575| | // assume gouraud shading 576| 0| mat.mShading = Discreet3DS::Gouraud; 577| 0| SkipToNextToken(); 578| 0| } 579| 8| continue; 580| 8| } 581| | // material transparency 582| 108| if (TokenMatch(mFilePtr, "MATERIAL_TRANSPARENCY", 21)) { ------------------ | Branch (582:17): [True: 8, False: 100] ------------------ 583| 8| ParseLV4MeshReal(mat.mTransparency); 584| 8| mat.mTransparency = ai_real(1.0) - mat.mTransparency; 585| 8| continue; 586| 8| } 587| | // material self illumination 588| 100| if (TokenMatch(mFilePtr, "MATERIAL_SELFILLUM", 18)) { ------------------ | Branch (588:17): [True: 8, False: 92] ------------------ 589| 8| ai_real f = 0.0; 590| 8| ParseLV4MeshReal(f); 591| | 592| 8| mat.mEmissive.r = f; 593| 8| mat.mEmissive.g = f; 594| 8| mat.mEmissive.b = f; 595| 8| continue; 596| 8| } 597| | // material shininess 598| 92| if (TokenMatch(mFilePtr, "MATERIAL_SHINE", 14)) { ------------------ | Branch (598:17): [True: 8, False: 84] ------------------ 599| 8| ParseLV4MeshReal(mat.mSpecularExponent); 600| 8| mat.mSpecularExponent *= 15; 601| 8| continue; 602| 8| } 603| | // two-sided material 604| 84| if (TokenMatch(mFilePtr, "MATERIAL_TWOSIDED", 17)) { ------------------ | Branch (604:17): [True: 0, False: 84] ------------------ 605| 0| mat.mTwoSided = true; 606| 0| continue; 607| 0| } 608| | // material shininess strength 609| 84| if (TokenMatch(mFilePtr, "MATERIAL_SHINESTRENGTH", 22)) { ------------------ | Branch (609:17): [True: 8, False: 76] ------------------ 610| 8| ParseLV4MeshReal(mat.mShininessStrength); 611| 8| continue; 612| 8| } 613| | // diffuse color map 614| 76| if (TokenMatch(mFilePtr, "MAP_DIFFUSE", 11)) { ------------------ | Branch (614:17): [True: 4, False: 72] ------------------ 615| | // parse the texture block 616| 4| ParseLV3MapBlock(mat.sTexDiffuse); 617| 4| continue; 618| 4| } 619| | // ambient color map 620| 72| if (TokenMatch(mFilePtr, "MAP_AMBIENT", 11)) { ------------------ | Branch (620:17): [True: 0, False: 72] ------------------ 621| | // parse the texture block 622| 0| ParseLV3MapBlock(mat.sTexAmbient); 623| 0| continue; 624| 0| } 625| | // specular color map 626| 72| if (TokenMatch(mFilePtr, "MAP_SPECULAR", 12)) { ------------------ | Branch (626:17): [True: 0, False: 72] ------------------ 627| | // parse the texture block 628| 0| ParseLV3MapBlock(mat.sTexSpecular); 629| 0| continue; 630| 0| } 631| | // opacity map 632| 72| if (TokenMatch(mFilePtr, "MAP_OPACITY", 11)) { ------------------ | Branch (632:17): [True: 0, False: 72] ------------------ 633| | // parse the texture block 634| 0| ParseLV3MapBlock(mat.sTexOpacity); 635| 0| continue; 636| 0| } 637| | // emissive map 638| 72| if (TokenMatch(mFilePtr, "MAP_SELFILLUM", 13)) { ------------------ | Branch (638:17): [True: 0, False: 72] ------------------ 639| | // parse the texture block 640| 0| ParseLV3MapBlock(mat.sTexEmissive); 641| 0| continue; 642| 0| } 643| | // bump map 644| 72| if (TokenMatch(mFilePtr, "MAP_BUMP", 8)) { ------------------ | Branch (644:17): [True: 0, False: 72] ------------------ 645| | // parse the texture block 646| 0| ParseLV3MapBlock(mat.sTexBump); 647| 0| } 648| | // specular/shininess map 649| 72| if (TokenMatch(mFilePtr, "MAP_SHINESTRENGTH", 17)) { ------------------ | Branch (649:17): [True: 5, False: 67] ------------------ 650| | // parse the texture block 651| 5| ParseLV3MapBlock(mat.sTexShininess); 652| 5| continue; 653| 5| } 654| | // number of submaterials 655| 67| if (TokenMatch(mFilePtr, "NUMSUBMTLS", 10)) { ------------------ | Branch (655:17): [True: 6, False: 61] ------------------ 656| 6| ParseLV4MeshLong(iNumSubMaterials); 657| | 658| | // allocate enough storage 659| 6| mat.avSubMaterials.resize(iNumSubMaterials, Material("INVALID SUBMATERIAL")); 660| 6| } 661| | // submaterial chunks 662| 67| if (TokenMatch(mFilePtr, "SUBMATERIAL", 11)) { ------------------ | Branch (662:17): [True: 0, False: 67] ------------------ 663| | // ensure we have at least one material allocated 664| 0| if (iNumSubMaterials == 0) { ------------------ | Branch (664:21): [True: 0, False: 0] ------------------ 665| 0| LogWarning("*NUMSUBMTLS unspecified or 0"); 666| 0| iNumSubMaterials = 1; 667| 0| mat.avSubMaterials.resize(iNumSubMaterials, Material("INVALID SUBMATERIAL")); 668| 0| } 669| | 670| 0| unsigned int iIndex = 0; 671| 0| ParseLV4MeshLong(iIndex); 672| | 673| 0| if (iIndex >= iNumSubMaterials) { ------------------ | Branch (673:21): [True: 0, False: 0] ------------------ 674| 0| LogWarning("Out of range: submaterial index is too large"); 675| 0| iIndex = iNumSubMaterials - 1; 676| 0| } 677| | 678| | // get a reference to the material 679| 0| if (iIndex < mat.avSubMaterials.size()) { ------------------ | Branch (679:21): [True: 0, False: 0] ------------------ 680| 0| Material &sMat = mat.avSubMaterials[iIndex]; 681| | 682| | // parse the material block 683| 0| ParseLV2MaterialBlock(sMat); 684| 0| } 685| | 686| 0| continue; 687| 0| } 688| 67| } 689| 8.23k| AI_ASE_HANDLE_SECTION("2", "*MATERIAL"); ------------------ | | 94| 4.11k| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 17, False: 4.10k] | | ------------------ | | 95| 4.11k| iDepth++; \ | | 96| 4.11k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 13, False: 4.08k] | | ------------------ | | 97| 13| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 8, False: 5] | | ------------------ | | 98| 8| ++mFilePtr; \ | | 99| 8| SkipToNextToken(); \ | | 100| 8| return; \ | | 101| 8| } \ | | 102| 4.08k| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 1, False: 4.08k] | | ------------------ | | 103| 1| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 1| " chunk (Level " level ")"); \ | | 105| 1| } \ | | 106| 4.11k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 433, False: 3.67k] | | | Branch (106:33): [True: 321, False: 112] | | ------------------ | | 107| 321| ++iLineNumber; \ | | 108| 321| bLastWasEndLine = true; \ | | 109| 321| } else \ | | 110| 4.11k| bLastWasEndLine = false; \ | | 111| 4.11k| ++mFilePtr; ------------------ 690| 8.23k| } 691| 12|} _ZN6Assimp3ASE6Parser16ParseLV3MapBlockERNS_4D3DS7TextureE: 694| 9|void Parser::ParseLV3MapBlock(Texture &map) { 695| 9| AI_ASE_PARSER_INIT(); ------------------ | | 63| 9| int iDepth = 0; ------------------ 696| | 697| | // *********************************************************** 698| | // *BITMAP should not be there if *MAP_CLASS is not BITMAP, 699| | // but we need to expect that case ... if the path is 700| | // empty the texture won't be used later. 701| | // *********************************************************** 702| 9| bool parsePath = true; 703| 9| std::string temp; 704| 29.1k| while (true) { ------------------ | Branch (704:12): [True: 29.1k, Folded] ------------------ 705| 29.1k| if ('*' == *mFilePtr) { ------------------ | Branch (705:13): [True: 503, False: 28.6k] ------------------ 706| 503| ++mFilePtr; 707| | // type of map 708| 503| if (TokenMatch(mFilePtr, "MAP_CLASS", 9)) { ------------------ | Branch (708:17): [True: 23, False: 480] ------------------ 709| 23| temp.clear(); 710| 23| if (!ParseString(temp, "*MAP_CLASS")) ------------------ | Branch (710:21): [True: 18, False: 5] ------------------ 711| 18| SkipToNextToken(); 712| 23| if (temp != "Bitmap" && temp != "Normal Bump") { ------------------ | Branch (712:21): [True: 18, False: 5] | Branch (712:41): [True: 18, False: 0] ------------------ 713| 18| ASSIMP_LOG_WARN("ASE: Skipping unknown map type: ", temp); 714| 18| parsePath = false; 715| 18| } 716| 23| continue; 717| 23| } 718| | // path to the texture 719| 480| if (parsePath && TokenMatch(mFilePtr, "BITMAP", 6)) { ------------------ | Branch (719:17): [True: 194, False: 286] | Branch (719:30): [True: 20, False: 174] ------------------ 720| 20| if (!ParseString(map.mMapName, "*BITMAP")) ------------------ | Branch (720:21): [True: 1, False: 19] ------------------ 721| 1| SkipToNextToken(); 722| | 723| 20| if (map.mMapName == "None") { ------------------ | Branch (723:21): [True: 0, False: 20] ------------------ 724| | // Files with 'None' as map name are produced by 725| | // an Maja to ASE exporter which name I forgot .. 726| 0| ASSIMP_LOG_WARN("ASE: Skipping invalid map entry"); 727| 0| map.mMapName = std::string(); 728| 0| } 729| | 730| 20| continue; 731| 20| } 732| | // offset on the u axis 733| 460| if (TokenMatch(mFilePtr, "UVW_U_OFFSET", 12)) { ------------------ | Branch (733:17): [True: 5, False: 455] ------------------ 734| 5| ParseLV4MeshReal(map.mOffsetU); 735| 5| continue; 736| 5| } 737| | // offset on the v axis 738| 455| if (TokenMatch(mFilePtr, "UVW_V_OFFSET", 12)) { ------------------ | Branch (738:17): [True: 5, False: 450] ------------------ 739| 5| ParseLV4MeshReal(map.mOffsetV); 740| 5| continue; 741| 5| } 742| | // tiling on the u axis 743| 450| if (TokenMatch(mFilePtr, "UVW_U_TILING", 12)) { ------------------ | Branch (743:17): [True: 5, False: 445] ------------------ 744| 5| ParseLV4MeshReal(map.mScaleU); 745| 5| continue; 746| 5| } 747| | // tiling on the v axis 748| 445| if (TokenMatch(mFilePtr, "UVW_V_TILING", 12)) { ------------------ | Branch (748:17): [True: 5, False: 440] ------------------ 749| 5| ParseLV4MeshReal(map.mScaleV); 750| 5| continue; 751| 5| } 752| | // rotation around the z-axis 753| 440| if (TokenMatch(mFilePtr, "UVW_ANGLE", 9)) { ------------------ | Branch (753:17): [True: 7, False: 433] ------------------ 754| 7| ParseLV4MeshReal(map.mRotation); 755| 7| continue; 756| 7| } 757| | // map blending factor 758| 433| if (TokenMatch(mFilePtr, "MAP_AMOUNT", 10)) { ------------------ | Branch (758:17): [True: 5, False: 428] ------------------ 759| 5| ParseLV4MeshReal(map.mTextureBlend); 760| 5| continue; 761| 5| } 762| 433| } 763| 58.0k| AI_ASE_HANDLE_SECTION("3", "*MAP_XXXXXX"); ------------------ | | 94| 29.0k| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 152, False: 28.9k] | | ------------------ | | 95| 29.0k| iDepth++; \ | | 96| 29.0k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 59, False: 28.8k] | | ------------------ | | 97| 59| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 6, False: 53] | | ------------------ | | 98| 6| ++mFilePtr; \ | | 99| 6| SkipToNextToken(); \ | | 100| 6| return; \ | | 101| 6| } \ | | 102| 28.8k| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 3, False: 28.8k] | | ------------------ | | 103| 3| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 3| " chunk (Level " level ")"); \ | | 105| 3| } \ | | 106| 29.0k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 1.96k, False: 27.0k] | | | Branch (106:33): [True: 1.66k, False: 306] | | ------------------ | | 107| 1.66k| ++iLineNumber; \ | | 108| 1.66k| bLastWasEndLine = true; \ | | 109| 1.66k| } else \ | | 110| 29.0k| bLastWasEndLine = false; \ | | 111| 29.0k| ++mFilePtr; ------------------ 764| 58.0k| } 765| 9|} _ZN6Assimp3ASE6Parser11ParseStringERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKc: 768| 217|bool Parser::ParseString(std::string &out, const char *szName) { 769| 217| char szBuffer[1024]; 770| 217| if (!SkipSpaces(&mFilePtr, mEnd)) { ------------------ | Branch (770:9): [True: 0, False: 217] ------------------ 771| | 772| 0| ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Unexpected EOL", szName); 773| 0| LogWarning(szBuffer); 774| 0| return false; 775| 0| } 776| | // there must be '"' 777| 217| if ('\"' != *mFilePtr) { ------------------ | Branch (777:9): [True: 20, False: 197] ------------------ 778| | 779| 20| ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Strings are expected " 780| 20| "to be enclosed in double quotation marks", 781| 20| szName); 782| 20| LogWarning(szBuffer); 783| 20| return false; 784| 20| } 785| 197| ++mFilePtr; 786| 197| const char *sz = mFilePtr; 787| 8.94k| while (true) { ------------------ | Branch (787:12): [True: 8.94k, Folded] ------------------ 788| 8.94k| if ('\"' == *sz) ------------------ | Branch (788:13): [True: 197, False: 8.74k] ------------------ 789| 197| break; 790| 8.74k| else if ('\0' == *sz) { ------------------ | Branch (790:18): [True: 0, False: 8.74k] ------------------ 791| 0| ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Strings are expected to " 792| 0| "be enclosed in double quotation marks but EOF was reached before " 793| 0| "a closing quotation mark was encountered", 794| 0| szName); 795| 0| LogWarning(szBuffer); 796| 0| return false; 797| 0| } 798| 8.74k| sz++; 799| 8.74k| } 800| 197| out = std::string(mFilePtr, (uintptr_t)sz - (uintptr_t)mFilePtr); 801| 197| mFilePtr = sz + 1; 802| 197| return true; 803| 197|} _ZN6Assimp3ASE6Parser19ParseLV1ObjectBlockERNS0_8BaseNodeE: 806| 54|void Parser::ParseLV1ObjectBlock(ASE::BaseNode &node) { 807| 54| AI_ASE_PARSER_INIT(); ------------------ | | 63| 54| int iDepth = 0; ------------------ 808| 20.1k| while (true) { ------------------ | Branch (808:12): [True: 20.0k, Folded] ------------------ 809| 20.0k| if ('*' == *mFilePtr) { ------------------ | Branch (809:13): [True: 729, False: 19.3k] ------------------ 810| 729| ++mFilePtr; 811| | 812| | // first process common tokens such as node name and transform 813| | // name of the mesh/node 814| 729| if (TokenMatch(mFilePtr, "NODE_NAME", 9)) { ------------------ | Branch (814:17): [True: 49, False: 680] ------------------ 815| 49| if (!ParseString(node.mName, "*NODE_NAME")) ------------------ | Branch (815:21): [True: 0, False: 49] ------------------ 816| 0| SkipToNextToken(); 817| 49| continue; 818| 49| } 819| | // name of the parent of the node 820| 680| if (TokenMatch(mFilePtr, "NODE_PARENT", 11)) { ------------------ | Branch (820:17): [True: 1, False: 679] ------------------ 821| 1| if (!ParseString(node.mParent, "*NODE_PARENT")) ------------------ | Branch (821:21): [True: 0, False: 1] ------------------ 822| 0| SkipToNextToken(); 823| 1| continue; 824| 1| } 825| | // transformation matrix of the node 826| 679| if (TokenMatch(mFilePtr, "NODE_TM", 7)) { ------------------ | Branch (826:17): [True: 62, False: 617] ------------------ 827| 62| ParseLV2NodeTransformBlock(node); 828| 62| continue; 829| 62| } 830| | // animation data of the node 831| 617| if (TokenMatch(mFilePtr, "TM_ANIMATION", 12)) { ------------------ | Branch (831:17): [True: 30, False: 587] ------------------ 832| 30| ParseLV2AnimationBlock(node); 833| 30| continue; 834| 30| } 835| | 836| 587| if (node.mType == BaseNode::Light) { ------------------ | Branch (836:17): [True: 72, False: 515] ------------------ 837| | // light settings 838| 72| if (TokenMatch(mFilePtr, "LIGHT_SETTINGS", 14)) { ------------------ | Branch (838:21): [True: 3, False: 69] ------------------ 839| 3| ParseLV2LightSettingsBlock((ASE::Light &)node); 840| 3| continue; 841| 3| } 842| | // type of the light source 843| 69| if (TokenMatch(mFilePtr, "LIGHT_TYPE", 10)) { ------------------ | Branch (843:21): [True: 3, False: 66] ------------------ 844| 3| if (!ASSIMP_strincmp("omni", mFilePtr, 4)) { ------------------ | Branch (844:25): [True: 0, False: 3] ------------------ 845| 0| ((ASE::Light &)node).mLightType = ASE::Light::OMNI; 846| 3| } else if (!ASSIMP_strincmp("target", mFilePtr, 6)) { ------------------ | Branch (846:32): [True: 0, False: 3] ------------------ 847| 0| ((ASE::Light &)node).mLightType = ASE::Light::TARGET; 848| 3| } else if (!ASSIMP_strincmp("free", mFilePtr, 4)) { ------------------ | Branch (848:32): [True: 1, False: 2] ------------------ 849| 1| ((ASE::Light &)node).mLightType = ASE::Light::FREE; 850| 2| } else if (!ASSIMP_strincmp("directional", mFilePtr, 11)) { ------------------ | Branch (850:32): [True: 2, False: 0] ------------------ 851| 2| ((ASE::Light &)node).mLightType = ASE::Light::DIRECTIONAL; 852| 2| } else { 853| 0| LogWarning("Unknown kind of light source"); 854| 0| } 855| 3| continue; 856| 3| } 857| 515| } else if (node.mType == BaseNode::Camera) { ------------------ | Branch (857:24): [True: 64, False: 451] ------------------ 858| | // Camera settings 859| 64| if (TokenMatch(mFilePtr, "CAMERA_SETTINGS", 15)) { ------------------ | Branch (859:21): [True: 20, False: 44] ------------------ 860| 20| ParseLV2CameraSettingsBlock((ASE::Camera &)node); 861| 20| continue; 862| 44| } else if (TokenMatch(mFilePtr, "CAMERA_TYPE", 11)) { ------------------ | Branch (862:28): [True: 4, False: 40] ------------------ 863| 4| if (!ASSIMP_strincmp("target", mFilePtr, 6)) { ------------------ | Branch (863:25): [True: 4, False: 0] ------------------ 864| 4| ((ASE::Camera &)node).mCameraType = ASE::Camera::TARGET; 865| 4| } else if (!ASSIMP_strincmp("free", mFilePtr, 4)) { ------------------ | Branch (865:32): [True: 0, False: 0] ------------------ 866| 0| ((ASE::Camera &)node).mCameraType = ASE::Camera::FREE; 867| 0| } else { 868| 0| LogWarning("Unknown kind of camera"); 869| 0| } 870| 4| continue; 871| 4| } 872| 451| } else if (node.mType == BaseNode::Mesh) { ------------------ | Branch (872:24): [True: 451, False: 0] ------------------ 873| | // mesh data 874| | // FIX: Older files use MESH_SOFTSKIN 875| 451| if (TokenMatch(mFilePtr, "MESH", 4) || ------------------ | Branch (875:21): [True: 38, False: 413] ------------------ 876| 413| TokenMatch(mFilePtr, "MESH_SOFTSKIN", 13)) { ------------------ | Branch (876:25): [True: 1, False: 412] ------------------ 877| 39| ParseLV2MeshBlock((ASE::Mesh &)node); 878| 39| continue; 879| 39| } 880| | // mesh material index 881| 412| if (TokenMatch(mFilePtr, "MATERIAL_REF", 12)) { ------------------ | Branch (881:21): [True: 8, False: 404] ------------------ 882| 8| ParseLV4MeshLong(((ASE::Mesh &)node).iMaterialIndex); 883| 8| continue; 884| 8| } 885| 412| } 886| 587| } 887| 39.6k| AI_ASE_HANDLE_TOP_LEVEL_SECTION(); ------------------ | | 69| 20.0k| else if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (69:14): [True: 72, False: 19.2k] | | ------------------ | | 70| 19.3k| ++iDepth; \ | | 71| 19.3k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (71:14): [True: 1.44k, False: 17.8k] | | ------------------ | | 72| 1.44k| if (0 == --iDepth) { \ | | ------------------ | | | Branch (72:13): [True: 29, False: 1.42k] | | ------------------ | | 73| 29| ++mFilePtr; \ | | 74| 29| SkipToNextToken(); \ | | 75| 29| return; \ | | 76| 29| } \ | | 77| 1.44k| } \ | | 78| 20.0k| if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (78:9): [True: 5, False: 19.8k] | | ------------------ | | 79| 5| return; \ | | 80| 5| } \ | | 81| 19.8k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) {\ | | ------------------ | | | Branch (81:9): [True: 1.10k, False: 18.7k] | | | Branch (81:33): [True: 893, False: 216] | | ------------------ | | 82| 893| ++iLineNumber; \ | | 83| 893| bLastWasEndLine = true; \ | | 84| 893| } else \ | | 85| 19.8k| bLastWasEndLine = false; \ | | 86| 19.8k| ++mFilePtr; ------------------ 888| 39.6k| } 889| 54|} _ZN6Assimp3ASE6Parser27ParseLV2CameraSettingsBlockERNS0_6CameraE: 892| 20|void Parser::ParseLV2CameraSettingsBlock(ASE::Camera &camera) { 893| 20| AI_ASE_PARSER_INIT(); ------------------ | | 63| 20| int iDepth = 0; ------------------ 894| 33.5k| while (true) { ------------------ | Branch (894:12): [True: 33.5k, Folded] ------------------ 895| 33.5k| if ('*' == *mFilePtr) { ------------------ | Branch (895:13): [True: 740, False: 32.8k] ------------------ 896| 740| ++mFilePtr; 897| 740| if (TokenMatch(mFilePtr, "CAMERA_NEAR", 11)) { ------------------ | Branch (897:17): [True: 4, False: 736] ------------------ 898| 4| ParseLV4MeshReal(camera.mNear); 899| 4| continue; 900| 4| } 901| 736| if (TokenMatch(mFilePtr, "CAMERA_FAR", 10)) { ------------------ | Branch (901:17): [True: 4, False: 732] ------------------ 902| 4| ParseLV4MeshReal(camera.mFar); 903| 4| continue; 904| 4| } 905| 732| if (TokenMatch(mFilePtr, "CAMERA_FOV", 10)) { ------------------ | Branch (905:17): [True: 4, False: 728] ------------------ 906| 4| ParseLV4MeshReal(camera.mFOV); 907| 4| continue; 908| 4| } 909| 732| } 910| 67.1k| AI_ASE_HANDLE_SECTION("2", "CAMERA_SETTINGS"); ------------------ | | 94| 33.5k| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 190, False: 33.3k] | | ------------------ | | 95| 33.5k| iDepth++; \ | | 96| 33.5k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 610, False: 32.7k] | | ------------------ | | 97| 610| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 18, False: 592] | | ------------------ | | 98| 18| ++mFilePtr; \ | | 99| 18| SkipToNextToken(); \ | | 100| 18| return; \ | | 101| 18| } \ | | 102| 32.7k| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 2, False: 32.7k] | | ------------------ | | 103| 2| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 2| " chunk (Level " level ")"); \ | | 105| 2| } \ | | 106| 33.5k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 2.98k, False: 30.5k] | | | Branch (106:33): [True: 2.37k, False: 615] | | ------------------ | | 107| 2.37k| ++iLineNumber; \ | | 108| 2.37k| bLastWasEndLine = true; \ | | 109| 2.37k| } else \ | | 110| 33.5k| bLastWasEndLine = false; \ | | 111| 33.5k| ++mFilePtr; ------------------ 911| 67.1k| } 912| 20|} _ZN6Assimp3ASE6Parser26ParseLV2LightSettingsBlockERNS0_5LightE: 915| 3|void Parser::ParseLV2LightSettingsBlock(ASE::Light &light) { 916| 3| AI_ASE_PARSER_INIT(); ------------------ | | 63| 3| int iDepth = 0; ------------------ 917| 503| while (true) { ------------------ | Branch (917:12): [True: 503, Folded] ------------------ 918| 503| if ('*' == *mFilePtr) { ------------------ | Branch (918:13): [True: 33, False: 470] ------------------ 919| 33| ++mFilePtr; 920| 33| if (TokenMatch(mFilePtr, "LIGHT_COLOR", 11)) { ------------------ | Branch (920:17): [True: 3, False: 30] ------------------ 921| 3| ParseLV4MeshFloatTriple(&light.mColor.r); 922| 3| continue; 923| 3| } 924| 30| if (TokenMatch(mFilePtr, "LIGHT_INTENS", 12)) { ------------------ | Branch (924:17): [True: 3, False: 27] ------------------ 925| 3| ParseLV4MeshReal(light.mIntensity); 926| 3| continue; 927| 3| } 928| 27| if (TokenMatch(mFilePtr, "LIGHT_HOTSPOT", 13)) { ------------------ | Branch (928:17): [True: 3, False: 24] ------------------ 929| 3| ParseLV4MeshReal(light.mAngle); 930| 3| continue; 931| 3| } 932| 24| if (TokenMatch(mFilePtr, "LIGHT_FALLOFF", 13)) { ------------------ | Branch (932:17): [True: 3, False: 21] ------------------ 933| 3| ParseLV4MeshReal(light.mFalloff); 934| 3| continue; 935| 3| } 936| 24| } 937| 979| AI_ASE_HANDLE_SECTION("2", "LIGHT_SETTINGS"); ------------------ | | 94| 491| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 3, False: 488] | | ------------------ | | 95| 491| iDepth++; \ | | 96| 491| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 3, False: 485] | | ------------------ | | 97| 3| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 3, False: 0] | | ------------------ | | 98| 3| ++mFilePtr; \ | | 99| 3| SkipToNextToken(); \ | | 100| 3| return; \ | | 101| 3| } \ | | 102| 485| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 0, False: 485] | | ------------------ | | 103| 0| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 0| " chunk (Level " level ")"); \ | | 105| 0| } \ | | 106| 491| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 36, False: 452] | | | Branch (106:33): [True: 36, False: 0] | | ------------------ | | 107| 36| ++iLineNumber; \ | | 108| 36| bLastWasEndLine = true; \ | | 109| 36| } else \ | | 110| 488| bLastWasEndLine = false; \ | | 111| 488| ++mFilePtr; ------------------ 938| 979| } 939| 3|} _ZN6Assimp3ASE6Parser22ParseLV2AnimationBlockERNS0_8BaseNodeE: 942| 30|void Parser::ParseLV2AnimationBlock(ASE::BaseNode &mesh) { 943| 30| AI_ASE_PARSER_INIT(); ------------------ | | 63| 30| int iDepth = 0; ------------------ 944| | 945| 30| ASE::Animation *anim = &mesh.mAnim; 946| 6.64k| while (true) { ------------------ | Branch (946:12): [True: 6.63k, Folded] ------------------ 947| 6.63k| if ('*' == *mFilePtr) { ------------------ | Branch (947:13): [True: 189, False: 6.45k] ------------------ 948| 189| ++mFilePtr; 949| 189| if (TokenMatch(mFilePtr, "NODE_NAME", 9)) { ------------------ | Branch (949:17): [True: 25, False: 164] ------------------ 950| 25| std::string temp; 951| 25| if (!ParseString(temp, "*NODE_NAME")) ------------------ | Branch (951:21): [True: 0, False: 25] ------------------ 952| 0| SkipToNextToken(); 953| | 954| | // If the name of the node contains .target it 955| | // represents an animated camera or spot light 956| | // target. 957| 25| if (std::string::npos != temp.find(".Target")) { ------------------ | Branch (957:21): [True: 8, False: 17] ------------------ 958| 8| if ((mesh.mType != BaseNode::Camera || ((ASE::Camera &)mesh).mCameraType != ASE::Camera::TARGET) && ------------------ | Branch (958:26): [True: 5, False: 3] | Branch (958:60): [True: 0, False: 3] ------------------ 959| 5| (mesh.mType != BaseNode::Light || ((ASE::Light &)mesh).mLightType != ASE::Light::TARGET)) { ------------------ | Branch (959:30): [True: 5, False: 0] | Branch (959:63): [True: 0, False: 0] ------------------ 960| | 961| 5| ASSIMP_LOG_ERROR("ASE: Found target animation channel " 962| 5| "but the node is neither a camera nor a spot light"); 963| 5| anim = nullptr; 964| 5| } else 965| 3| anim = &mesh.mTargetAnim; 966| 8| } 967| 25| continue; 968| 25| } 969| | 970| | // position keyframes 971| 164| if (TokenMatch(mFilePtr, "CONTROL_POS_TRACK", 17) || ------------------ | Branch (971:17): [True: 20, False: 144] ------------------ 972| 144| TokenMatch(mFilePtr, "CONTROL_POS_BEZIER", 18) || ------------------ | Branch (972:21): [True: 0, False: 144] ------------------ 973| 144| TokenMatch(mFilePtr, "CONTROL_POS_TCB", 15)) { ------------------ | Branch (973:21): [True: 0, False: 144] ------------------ 974| 20| if (!anim) ------------------ | Branch (974:21): [True: 5, False: 15] ------------------ 975| 5| SkipSection(); 976| 15| else 977| 15| ParseLV3PosAnimationBlock(*anim); 978| 20| continue; 979| 20| } 980| | // scaling keyframes 981| 144| if (TokenMatch(mFilePtr, "CONTROL_SCALE_TRACK", 19) || ------------------ | Branch (981:17): [True: 1, False: 143] ------------------ 982| 143| TokenMatch(mFilePtr, "CONTROL_SCALE_BEZIER", 20) || ------------------ | Branch (982:21): [True: 0, False: 143] ------------------ 983| 143| TokenMatch(mFilePtr, "CONTROL_SCALE_TCB", 17)) { ------------------ | Branch (983:21): [True: 0, False: 143] ------------------ 984| 1| if (!anim || anim == &mesh.mTargetAnim) { ------------------ | Branch (984:21): [True: 0, False: 1] | Branch (984:30): [True: 0, False: 1] ------------------ 985| | // Target animation channels may have no rotation channels 986| 0| ASSIMP_LOG_ERROR("ASE: Ignoring scaling channel in target animation"); 987| 0| SkipSection(); 988| 0| } else 989| 1| ParseLV3ScaleAnimationBlock(*anim); 990| 1| continue; 991| 1| } 992| | // rotation keyframes 993| 143| if (TokenMatch(mFilePtr, "CONTROL_ROT_TRACK", 17) || ------------------ | Branch (993:17): [True: 13, False: 130] ------------------ 994| 130| TokenMatch(mFilePtr, "CONTROL_ROT_BEZIER", 18) || ------------------ | Branch (994:21): [True: 5, False: 125] ------------------ 995| 125| TokenMatch(mFilePtr, "CONTROL_ROT_TCB", 15)) { ------------------ | Branch (995:21): [True: 0, False: 125] ------------------ 996| 18| if (!anim || anim == &mesh.mTargetAnim) { ------------------ | Branch (996:21): [True: 0, False: 18] | Branch (996:30): [True: 0, False: 18] ------------------ 997| | // Target animation channels may have no rotation channels 998| 0| ASSIMP_LOG_ERROR("ASE: Ignoring rotation channel in target animation"); 999| 0| SkipSection(); 1000| 0| } else 1001| 18| ParseLV3RotAnimationBlock(*anim); 1002| 18| continue; 1003| 18| } 1004| 143| } 1005| 13.1k| AI_ASE_HANDLE_SECTION("2", "TM_ANIMATION"); ------------------ | | 94| 6.57k| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 31, False: 6.54k] | | ------------------ | | 95| 6.57k| iDepth++; \ | | 96| 6.57k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 29, False: 6.51k] | | ------------------ | | 97| 29| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 25, False: 4] | | ------------------ | | 98| 25| ++mFilePtr; \ | | 99| 25| SkipToNextToken(); \ | | 100| 25| return; \ | | 101| 25| } \ | | 102| 6.51k| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 1, False: 6.51k] | | ------------------ | | 103| 1| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 1| " chunk (Level " level ")"); \ | | 105| 1| } \ | | 106| 6.57k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 279, False: 6.27k] | | | Branch (106:33): [True: 239, False: 40] | | ------------------ | | 107| 239| ++iLineNumber; \ | | 108| 239| bLastWasEndLine = true; \ | | 109| 239| } else \ | | 110| 6.55k| bLastWasEndLine = false; \ | | 111| 6.55k| ++mFilePtr; ------------------ 1006| 13.1k| } 1007| 30|} _ZN6Assimp3ASE6Parser27ParseLV3ScaleAnimationBlockERNS0_9AnimationE: 1009| 1|void Parser::ParseLV3ScaleAnimationBlock(ASE::Animation &anim) { 1010| 1| AI_ASE_PARSER_INIT(); ------------------ | | 63| 1| int iDepth = 0; ------------------ 1011| 1| unsigned int iIndex; 1012| | 1013| 1.47k| while (true) { ------------------ | Branch (1013:12): [True: 1.47k, Folded] ------------------ 1014| 1.47k| if ('*' == *mFilePtr) { ------------------ | Branch (1014:13): [True: 45, False: 1.43k] ------------------ 1015| 45| ++mFilePtr; 1016| | 1017| 45| bool b = false; 1018| | 1019| | // For the moment we're just reading the three floats - 1020| | // we ignore the additional information for bezier's and TCBs 1021| | 1022| | // simple scaling keyframe 1023| 45| if (TokenMatch(mFilePtr, "CONTROL_SCALE_SAMPLE", 20)) { ------------------ | Branch (1023:17): [True: 45, False: 0] ------------------ 1024| 45| b = true; 1025| 45| anim.mScalingType = ASE::Animation::TRACK; 1026| 45| } 1027| | 1028| | // Bezier scaling keyframe 1029| 45| if (TokenMatch(mFilePtr, "CONTROL_BEZIER_SCALE_KEY", 24)) { ------------------ | Branch (1029:17): [True: 0, False: 45] ------------------ 1030| 0| b = true; 1031| 0| anim.mScalingType = ASE::Animation::BEZIER; 1032| 0| } 1033| | // TCB scaling keyframe 1034| 45| if (TokenMatch(mFilePtr, "CONTROL_TCB_SCALE_KEY", 21)) { ------------------ | Branch (1034:17): [True: 0, False: 45] ------------------ 1035| 0| b = true; 1036| 0| anim.mScalingType = ASE::Animation::TCB; 1037| 0| } 1038| 45| if (b) { ------------------ | Branch (1038:17): [True: 45, False: 0] ------------------ 1039| 45| anim.akeyScaling.emplace_back(); 1040| 45| aiVectorKey &key = anim.akeyScaling.back(); 1041| 45| ParseLV4MeshRealTriple(&key.mValue.x, iIndex); 1042| 45| key.mTime = (double)iIndex; 1043| 45| } 1044| 45| } 1045| 1.47k| AI_ASE_HANDLE_SECTION("3", "*CONTROL_POS_TRACK"); ------------------ | | 94| 1.47k| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 1, False: 1.47k] | | ------------------ | | 95| 1.47k| iDepth++; \ | | 96| 1.47k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 1, False: 1.47k] | | ------------------ | | 97| 1| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 1, False: 0] | | ------------------ | | 98| 1| ++mFilePtr; \ | | 99| 1| SkipToNextToken(); \ | | 100| 1| return; \ | | 101| 1| } \ | | 102| 1.47k| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 0, False: 1.47k] | | ------------------ | | 103| 0| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 0| " chunk (Level " level ")"); \ | | 105| 0| } \ | | 106| 1.47k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 46, False: 1.43k] | | | Branch (106:33): [True: 46, False: 0] | | ------------------ | | 107| 46| ++iLineNumber; \ | | 108| 46| bLastWasEndLine = true; \ | | 109| 46| } else \ | | 110| 1.47k| bLastWasEndLine = false; \ | | 111| 1.47k| ++mFilePtr; ------------------ 1046| 1.47k| } 1047| 1|} _ZN6Assimp3ASE6Parser25ParseLV3PosAnimationBlockERNS0_9AnimationE: 1049| 15|void Parser::ParseLV3PosAnimationBlock(ASE::Animation &anim) { 1050| 15| AI_ASE_PARSER_INIT(); ------------------ | | 63| 15| int iDepth = 0; ------------------ 1051| 15| unsigned int iIndex; 1052| 3.45k| while (true) { ------------------ | Branch (1052:12): [True: 3.45k, Folded] ------------------ 1053| 3.45k| if ('*' == *mFilePtr) { ------------------ | Branch (1053:13): [True: 839, False: 2.61k] ------------------ 1054| 839| ++mFilePtr; 1055| | 1056| 839| bool b = false; 1057| | 1058| | // For the moment we're just reading the three floats - 1059| | // we ignore the additional information for bezier's and TCBs 1060| | 1061| | // simple scaling keyframe 1062| 839| if (TokenMatch(mFilePtr, "CONTROL_POS_SAMPLE", 18)) { ------------------ | Branch (1062:17): [True: 837, False: 2] ------------------ 1063| 837| b = true; 1064| 837| anim.mPositionType = ASE::Animation::TRACK; 1065| 837| } 1066| | 1067| | // Bezier scaling keyframe 1068| 839| if (TokenMatch(mFilePtr, "CONTROL_BEZIER_POS_KEY", 22)) { ------------------ | Branch (1068:17): [True: 0, False: 839] ------------------ 1069| 0| b = true; 1070| 0| anim.mPositionType = ASE::Animation::BEZIER; 1071| 0| } 1072| | // TCB scaling keyframe 1073| 839| if (TokenMatch(mFilePtr, "CONTROL_TCB_POS_KEY", 19)) { ------------------ | Branch (1073:17): [True: 0, False: 839] ------------------ 1074| 0| b = true; 1075| 0| anim.mPositionType = ASE::Animation::TCB; 1076| 0| } 1077| 839| if (b) { ------------------ | Branch (1077:17): [True: 837, False: 2] ------------------ 1078| 837| anim.akeyPositions.emplace_back(); 1079| 837| aiVectorKey &key = anim.akeyPositions.back(); 1080| 837| ParseLV4MeshRealTriple(&key.mValue.x, iIndex); 1081| 837| key.mTime = (double)iIndex; 1082| 837| } 1083| 839| } 1084| 3.45k| AI_ASE_HANDLE_SECTION("3", "*CONTROL_POS_TRACK"); ------------------ | | 94| 3.45k| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 15, False: 3.43k] | | ------------------ | | 95| 3.45k| iDepth++; \ | | 96| 3.45k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 14, False: 3.42k] | | ------------------ | | 97| 14| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 14, False: 0] | | ------------------ | | 98| 14| ++mFilePtr; \ | | 99| 14| SkipToNextToken(); \ | | 100| 14| return; \ | | 101| 14| } \ | | 102| 3.42k| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 1, False: 3.42k] | | ------------------ | | 103| 1| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 1| " chunk (Level " level ")"); \ | | 105| 1| } \ | | 106| 3.45k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 851, False: 2.58k] | | | Branch (106:33): [True: 851, False: 0] | | ------------------ | | 107| 851| ++iLineNumber; \ | | 108| 851| bLastWasEndLine = true; \ | | 109| 851| } else \ | | 110| 3.43k| bLastWasEndLine = false; \ | | 111| 3.43k| ++mFilePtr; ------------------ 1085| 3.43k| } 1086| 15|} _ZN6Assimp3ASE6Parser25ParseLV3RotAnimationBlockERNS0_9AnimationE: 1088| 18|void Parser::ParseLV3RotAnimationBlock(ASE::Animation &anim) { 1089| 18| AI_ASE_PARSER_INIT(); ------------------ | | 63| 18| int iDepth = 0; ------------------ 1090| 18| unsigned int iIndex; 1091| 48.0k| while (true) { ------------------ | Branch (1091:12): [True: 48.0k, Folded] ------------------ 1092| 48.0k| if ('*' == *mFilePtr) { ------------------ | Branch (1092:13): [True: 2.75k, False: 45.2k] ------------------ 1093| 2.75k| ++mFilePtr; 1094| | 1095| 2.75k| bool b = false; 1096| | 1097| | // For the moment we're just reading the floats - 1098| | // we ignore the additional information for bezier's and TCBs 1099| | 1100| | // simple scaling keyframe 1101| 2.75k| if (TokenMatch(mFilePtr, "CONTROL_ROT_SAMPLE", 18)) { ------------------ | Branch (1101:17): [True: 1.98k, False: 768] ------------------ 1102| 1.98k| b = true; 1103| 1.98k| anim.mRotationType = ASE::Animation::TRACK; 1104| 1.98k| } 1105| | 1106| | // Bezier scaling keyframe 1107| 2.75k| if (TokenMatch(mFilePtr, "CONTROL_BEZIER_ROT_KEY", 22)) { ------------------ | Branch (1107:17): [True: 26, False: 2.72k] ------------------ 1108| 26| b = true; 1109| 26| anim.mRotationType = ASE::Animation::BEZIER; 1110| 26| } 1111| | // TCB scaling keyframe 1112| 2.75k| if (TokenMatch(mFilePtr, "CONTROL_TCB_ROT_KEY", 19)) { ------------------ | Branch (1112:17): [True: 0, False: 2.75k] ------------------ 1113| 0| b = true; 1114| 0| anim.mRotationType = ASE::Animation::TCB; 1115| 0| } 1116| 2.75k| if (b) { ------------------ | Branch (1116:17): [True: 2.01k, False: 742] ------------------ 1117| 2.01k| anim.akeyRotations.emplace_back(); 1118| 2.01k| aiQuatKey &key = anim.akeyRotations.back(); 1119| 2.01k| aiVector3D v; 1120| 2.01k| ai_real f; 1121| 2.01k| ParseLV4MeshRealTriple(&v.x, iIndex); 1122| 2.01k| ParseLV4MeshReal(f); 1123| 2.01k| key.mTime = (double)iIndex; 1124| 2.01k| key.mValue = aiQuaternion(v, f); 1125| 2.01k| } 1126| 2.75k| } 1127| 48.0k| AI_ASE_HANDLE_SECTION("3", "*CONTROL_ROT_TRACK"); ------------------ | | 94| 48.0k| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 43, False: 48.0k] | | ------------------ | | 95| 48.0k| iDepth++; \ | | 96| 48.0k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 44, False: 47.9k] | | ------------------ | | 97| 44| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 15, False: 29] | | ------------------ | | 98| 15| ++mFilePtr; \ | | 99| 15| SkipToNextToken(); \ | | 100| 15| return; \ | | 101| 15| } \ | | 102| 47.9k| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 2, False: 47.9k] | | ------------------ | | 103| 2| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 2| " chunk (Level " level ")"); \ | | 105| 2| } \ | | 106| 48.0k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 16.7k, False: 31.2k] | | | Branch (106:33): [True: 10.5k, False: 6.23k] | | ------------------ | | 107| 10.5k| ++iLineNumber; \ | | 108| 10.5k| bLastWasEndLine = true; \ | | 109| 10.5k| } else \ | | 110| 48.0k| bLastWasEndLine = false; \ | | 111| 48.0k| ++mFilePtr; ------------------ 1128| 48.0k| } 1129| 18|} _ZN6Assimp3ASE6Parser26ParseLV2NodeTransformBlockERNS0_8BaseNodeE: 1131| 62|void Parser::ParseLV2NodeTransformBlock(ASE::BaseNode &mesh) { 1132| 62| AI_ASE_PARSER_INIT(); ------------------ | | 63| 62| int iDepth = 0; ------------------ 1133| 62| int mode = 0; 1134| 26.3k| while (true) { ------------------ | Branch (1134:12): [True: 26.3k, Folded] ------------------ 1135| 26.3k| if ('*' == *mFilePtr) { ------------------ | Branch (1135:13): [True: 1.08k, False: 25.2k] ------------------ 1136| 1.08k| ++mFilePtr; 1137| | // name of the node 1138| 1.08k| if (TokenMatch(mFilePtr, "NODE_NAME", 9)) { ------------------ | Branch (1138:17): [True: 65, False: 1.01k] ------------------ 1139| 65| std::string temp; 1140| 65| if (!ParseString(temp, "*NODE_NAME")) ------------------ | Branch (1140:21): [True: 0, False: 65] ------------------ 1141| 0| SkipToNextToken(); 1142| | 1143| 65| std::string::size_type s; 1144| 65| if (temp == mesh.mName) { ------------------ | Branch (1144:21): [True: 47, False: 18] ------------------ 1145| 47| mode = 1; 1146| 47| } else if (std::string::npos != (s = temp.find(".Target")) && ------------------ | Branch (1146:28): [True: 14, False: 4] | Branch (1146:28): [True: 12, False: 6] ------------------ 1147| 14| mesh.mName == temp.substr(0, s)) { ------------------ | Branch (1147:28): [True: 12, False: 2] ------------------ 1148| | // This should be either a target light or a target camera 1149| 12| if ((mesh.mType == BaseNode::Light && ((ASE::Light &)mesh).mLightType == ASE::Light::TARGET) || ------------------ | Branch (1149:26): [True: 0, False: 12] | Branch (1149:59): [True: 0, False: 0] ------------------ 1150| 12| (mesh.mType == BaseNode::Camera && ((ASE::Camera &)mesh).mCameraType == ASE::Camera::TARGET)) { ------------------ | Branch (1150:30): [True: 4, False: 8] | Branch (1150:64): [True: 4, False: 0] ------------------ 1151| 4| mode = 2; 1152| 8| } else { 1153| 8| ASSIMP_LOG_ERROR("ASE: Ignoring target transform, " 1154| 8| "this is no spot light or target camera"); 1155| 8| } 1156| 12| } else { 1157| 6| ASSIMP_LOG_ERROR("ASE: Unknown node transformation: ", temp); 1158| | // mode = 0 1159| 6| } 1160| 65| continue; 1161| 65| } 1162| 1.01k| if (mode) { ------------------ | Branch (1162:17): [True: 663, False: 354] ------------------ 1163| | // fourth row of the transformation matrix - and also the 1164| | // only information here that is interesting for targets 1165| 663| if (TokenMatch(mFilePtr, "TM_ROW3", 7)) { ------------------ | Branch (1165:21): [True: 51, False: 612] ------------------ 1166| 51| ParseLV4MeshRealTriple((mode == 1 ? mesh.mTransform[3] : &mesh.mTargetPosition.x)); ------------------ | Branch (1166:45): [True: 47, False: 4] ------------------ 1167| 51| continue; 1168| 51| } 1169| 612| if (mode == 1) { ------------------ | Branch (1169:21): [True: 564, False: 48] ------------------ 1170| | // first row of the transformation matrix 1171| 564| if (TokenMatch(mFilePtr, "TM_ROW0", 7)) { ------------------ | Branch (1171:25): [True: 47, False: 517] ------------------ 1172| 47| ParseLV4MeshRealTriple(mesh.mTransform[0]); 1173| 47| continue; 1174| 47| } 1175| | // second row of the transformation matrix 1176| 517| if (TokenMatch(mFilePtr, "TM_ROW1", 7)) { ------------------ | Branch (1176:25): [True: 47, False: 470] ------------------ 1177| 47| ParseLV4MeshRealTriple(mesh.mTransform[1]); 1178| 47| continue; 1179| 47| } 1180| | // third row of the transformation matrix 1181| 470| if (TokenMatch(mFilePtr, "TM_ROW2", 7)) { ------------------ | Branch (1181:25): [True: 47, False: 423] ------------------ 1182| 47| ParseLV4MeshRealTriple(mesh.mTransform[2]); 1183| 47| continue; 1184| 47| } 1185| | // inherited position axes 1186| 423| if (TokenMatch(mFilePtr, "INHERIT_POS", 11)) { ------------------ | Branch (1186:25): [True: 47, False: 376] ------------------ 1187| 47| unsigned int aiVal[3]; 1188| 47| ParseLV4MeshLongTriple(aiVal); 1189| | 1190| 188| for (unsigned int i = 0; i < 3; ++i) ------------------ | Branch (1190:50): [True: 141, False: 47] ------------------ 1191| 141| mesh.inherit.abInheritPosition[i] = aiVal[i] != 0; 1192| 47| continue; 1193| 47| } 1194| | // inherited rotation axes 1195| 376| if (TokenMatch(mFilePtr, "INHERIT_ROT", 11)) { ------------------ | Branch (1195:25): [True: 47, False: 329] ------------------ 1196| 47| unsigned int aiVal[3]; 1197| 47| ParseLV4MeshLongTriple(aiVal); 1198| | 1199| 188| for (unsigned int i = 0; i < 3; ++i) ------------------ | Branch (1199:50): [True: 141, False: 47] ------------------ 1200| 141| mesh.inherit.abInheritRotation[i] = aiVal[i] != 0; 1201| 47| continue; 1202| 47| } 1203| | // inherited scaling axes 1204| 329| if (TokenMatch(mFilePtr, "INHERIT_SCL", 11)) { ------------------ | Branch (1204:25): [True: 47, False: 282] ------------------ 1205| 47| unsigned int aiVal[3]; 1206| 47| ParseLV4MeshLongTriple(aiVal); 1207| | 1208| 188| for (unsigned int i = 0; i < 3; ++i) ------------------ | Branch (1208:50): [True: 141, False: 47] ------------------ 1209| 141| mesh.inherit.abInheritScaling[i] = aiVal[i] != 0; 1210| 47| continue; 1211| 47| } 1212| 329| } 1213| 612| } 1214| 1.01k| } 1215| 51.8k| AI_ASE_HANDLE_SECTION("2", "*NODE_TM"); ------------------ | | 94| 25.9k| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 70, False: 25.8k] | | ------------------ | | 95| 25.9k| iDepth++; \ | | 96| 25.9k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 70, False: 25.8k] | | ------------------ | | 97| 70| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 62, False: 8] | | ------------------ | | 98| 62| ++mFilePtr; \ | | 99| 62| SkipToNextToken(); \ | | 100| 62| return; \ | | 101| 62| } \ | | 102| 25.8k| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 0, False: 25.8k] | | ------------------ | | 103| 0| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 0| " chunk (Level " level ")"); \ | | 105| 0| } \ | | 106| 25.9k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 1.15k, False: 24.7k] | | | Branch (106:33): [True: 1.15k, False: 0] | | ------------------ | | 107| 1.15k| ++iLineNumber; \ | | 108| 1.15k| bLastWasEndLine = true; \ | | 109| 1.15k| } else \ | | 110| 25.8k| bLastWasEndLine = false; \ | | 111| 25.8k| ++mFilePtr; ------------------ 1216| 51.8k| } 1217| 62|} _ZN6Assimp3ASE6Parser17ParseLV2MeshBlockERNS0_4MeshE: 1219| 39|void Parser::ParseLV2MeshBlock(ASE::Mesh &mesh) { 1220| 39| AI_ASE_PARSER_INIT(); ------------------ | | 63| 39| int iDepth = 0; ------------------ 1221| | 1222| 39| unsigned int iNumVertices = 0; 1223| 39| unsigned int iNumFaces = 0; 1224| 39| unsigned int iNumTVertices = 0; 1225| 39| unsigned int iNumTFaces = 0; 1226| 39| unsigned int iNumCVertices = 0; 1227| 39| unsigned int iNumCFaces = 0; 1228| 77.8k| while (true) { ------------------ | Branch (1228:12): [True: 77.8k, Folded] ------------------ 1229| 77.8k| if ('*' == *mFilePtr) { ------------------ | Branch (1229:13): [True: 2.61k, False: 75.2k] ------------------ 1230| 2.61k| ++mFilePtr; 1231| | // Number of vertices in the mesh 1232| 2.61k| if (TokenMatch(mFilePtr, "MESH_NUMVERTEX", 14)) { ------------------ | Branch (1232:17): [True: 48, False: 2.56k] ------------------ 1233| 48| ParseLV4MeshLong(iNumVertices); 1234| 48| continue; 1235| 48| } 1236| | // Number of texture coordinates in the mesh 1237| 2.56k| if (TokenMatch(mFilePtr, "MESH_NUMTVERTEX", 15)) { ------------------ | Branch (1237:17): [True: 22, False: 2.54k] ------------------ 1238| 22| ParseLV4MeshLong(iNumTVertices); 1239| 22| continue; 1240| 22| } 1241| | // Number of vertex colors in the mesh 1242| 2.54k| if (TokenMatch(mFilePtr, "MESH_NUMCVERTEX", 15)) { ------------------ | Branch (1242:17): [True: 21, False: 2.52k] ------------------ 1243| 21| ParseLV4MeshLong(iNumCVertices); 1244| 21| continue; 1245| 21| } 1246| | // Number of regular faces in the mesh 1247| 2.52k| if (TokenMatch(mFilePtr, "MESH_NUMFACES", 13)) { ------------------ | Branch (1247:17): [True: 48, False: 2.47k] ------------------ 1248| 48| ParseLV4MeshLong(iNumFaces); 1249| 48| continue; 1250| 48| } 1251| | // Number of UVWed faces in the mesh 1252| 2.47k| if (TokenMatch(mFilePtr, "MESH_NUMTVFACES", 15)) { ------------------ | Branch (1252:17): [True: 22, False: 2.45k] ------------------ 1253| 22| ParseLV4MeshLong(iNumTFaces); 1254| 22| continue; 1255| 22| } 1256| | // Number of colored faces in the mesh 1257| 2.45k| if (TokenMatch(mFilePtr, "MESH_NUMCVFACES", 15)) { ------------------ | Branch (1257:17): [True: 0, False: 2.45k] ------------------ 1258| 0| ParseLV4MeshLong(iNumCFaces); 1259| 0| continue; 1260| 0| } 1261| | // mesh vertex list block 1262| 2.45k| if (TokenMatch(mFilePtr, "MESH_VERTEX_LIST", 16)) { ------------------ | Branch (1262:17): [True: 48, False: 2.40k] ------------------ 1263| 48| ParseLV3MeshVertexListBlock(iNumVertices, mesh); 1264| 48| continue; 1265| 48| } 1266| | // mesh face list block 1267| 2.40k| if (TokenMatch(mFilePtr, "MESH_FACE_LIST", 14)) { ------------------ | Branch (1267:17): [True: 22, False: 2.38k] ------------------ 1268| 22| ParseLV3MeshFaceListBlock(iNumFaces, mesh); 1269| 22| continue; 1270| 22| } 1271| | // mesh texture vertex list block 1272| 2.38k| if (TokenMatch(mFilePtr, "MESH_TVERTLIST", 14)) { ------------------ | Branch (1272:17): [True: 22, False: 2.36k] ------------------ 1273| 22| ParseLV3MeshTListBlock(iNumTVertices, mesh); 1274| 22| continue; 1275| 22| } 1276| | // mesh texture face block 1277| 2.36k| if (TokenMatch(mFilePtr, "MESH_TFACELIST", 14)) { ------------------ | Branch (1277:17): [True: 24, False: 2.33k] ------------------ 1278| 24| ParseLV3MeshTFaceListBlock(iNumTFaces, mesh); 1279| 24| continue; 1280| 24| } 1281| | // mesh color vertex list block 1282| 2.33k| if (TokenMatch(mFilePtr, "MESH_CVERTLIST", 14)) { ------------------ | Branch (1282:17): [True: 0, False: 2.33k] ------------------ 1283| 0| ParseLV3MeshCListBlock(iNumCVertices, mesh); 1284| 0| continue; 1285| 0| } 1286| | // mesh color face block 1287| 2.33k| if (TokenMatch(mFilePtr, "MESH_CFACELIST", 14)) { ------------------ | Branch (1287:17): [True: 0, False: 2.33k] ------------------ 1288| 0| ParseLV3MeshCFaceListBlock(iNumCFaces, mesh); 1289| 0| continue; 1290| 0| } 1291| | // mesh normals 1292| 2.33k| if (TokenMatch(mFilePtr, "MESH_NORMALS", 12)) { ------------------ | Branch (1292:17): [True: 21, False: 2.31k] ------------------ 1293| 21| ParseLV3MeshNormalListBlock(mesh); 1294| 21| continue; 1295| 21| } 1296| | // another mesh UV channel ... 1297| 2.31k| if (TokenMatch(mFilePtr, "MESH_MAPPINGCHANNEL", 19)) { ------------------ | Branch (1297:17): [True: 0, False: 2.31k] ------------------ 1298| 0| unsigned int iIndex(0); 1299| 0| ParseLV4MeshLong(iIndex); 1300| 0| if (0 == iIndex) { ------------------ | Branch (1300:21): [True: 0, False: 0] ------------------ 1301| 0| LogWarning("Mapping channel has an invalid index. Skipping UV channel"); 1302| | // skip it ... 1303| 0| SkipSection(); 1304| 0| } else { 1305| 0| if (iIndex < 2) { ------------------ | Branch (1305:25): [True: 0, False: 0] ------------------ 1306| 0| LogWarning("Mapping channel has an invalid index. Skipping UV channel"); 1307| | // skip it ... 1308| 0| SkipSection(); 1309| 0| } 1310| 0| if (iIndex > AI_MAX_NUMBER_OF_TEXTURECOORDS) { ------------------ | Branch (1310:25): [True: 0, False: 0] ------------------ 1311| 0| LogWarning("Too many UV channels specified. Skipping channel .."); 1312| | // skip it ... 1313| 0| SkipSection(); 1314| 0| } else { 1315| | // parse the mapping channel 1316| 0| ParseLV3MappingChannel(iIndex - 1, mesh); 1317| 0| } 1318| 0| continue; 1319| 0| } 1320| 0| } 1321| | // mesh animation keyframe. Not supported 1322| 2.31k| if (TokenMatch(mFilePtr, "MESH_ANIMATION", 14)) { ------------------ | Branch (1322:17): [True: 0, False: 2.31k] ------------------ 1323| | 1324| 0| LogWarning("Found *MESH_ANIMATION element in ASE/ASK file. " 1325| 0| "Keyframe animation is not supported by Assimp, this element " 1326| 0| "will be ignored"); 1327| | //SkipSection(); 1328| 0| continue; 1329| 0| } 1330| 2.31k| if (TokenMatch(mFilePtr, "MESH_WEIGHTS", 12)) { ------------------ | Branch (1330:17): [True: 1, False: 2.31k] ------------------ 1331| 1| ParseLV3MeshWeightsBlock(mesh); 1332| 1| continue; 1333| 1| } 1334| 2.31k| } 1335| 155k| AI_ASE_HANDLE_SECTION("2", "*MESH"); ------------------ | | 94| 77.5k| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 74, False: 77.4k] | | ------------------ | | 95| 77.5k| iDepth++; \ | | 96| 77.5k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 52, False: 77.4k] | | ------------------ | | 97| 52| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 26, False: 26] | | ------------------ | | 98| 26| ++mFilePtr; \ | | 99| 26| SkipToNextToken(); \ | | 100| 26| return; \ | | 101| 26| } \ | | 102| 77.4k| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 1, False: 77.4k] | | ------------------ | | 103| 1| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 1| " chunk (Level " level ")"); \ | | 105| 1| } \ | | 106| 77.5k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 3.99k, False: 73.5k] | | | Branch (106:33): [True: 2.76k, False: 1.22k] | | ------------------ | | 107| 2.76k| ++iLineNumber; \ | | 108| 2.76k| bLastWasEndLine = true; \ | | 109| 2.76k| } else \ | | 110| 77.5k| bLastWasEndLine = false; \ | | 111| 77.5k| ++mFilePtr; ------------------ 1336| 155k| } 1337| 39|} _ZN6Assimp3ASE6Parser24ParseLV3MeshWeightsBlockERNS0_4MeshE: 1339| 1|void Parser::ParseLV3MeshWeightsBlock(ASE::Mesh &mesh) { 1340| 1| AI_ASE_PARSER_INIT(); ------------------ | | 63| 1| int iDepth = 0; ------------------ 1341| | 1342| 1| unsigned int iNumVertices = 0, iNumBones = 0; 1343| 41| while (true) { ------------------ | Branch (1343:12): [True: 41, Folded] ------------------ 1344| 41| if ('*' == *mFilePtr) { ------------------ | Branch (1344:13): [True: 1, False: 40] ------------------ 1345| 1| ++mFilePtr; 1346| | 1347| | // Number of bone vertices ... 1348| 1| if (TokenMatch(mFilePtr, "MESH_NUMVERTEX", 14)) { ------------------ | Branch (1348:17): [True: 0, False: 1] ------------------ 1349| 0| ParseLV4MeshLong(iNumVertices); 1350| 0| continue; 1351| 0| } 1352| | // Number of bones 1353| 1| if (TokenMatch(mFilePtr, "MESH_NUMBONE", 12)) { ------------------ | Branch (1353:17): [True: 0, False: 1] ------------------ 1354| 0| ParseLV4MeshLong(iNumBones); 1355| 0| continue; 1356| 0| } 1357| | // parse the list of bones 1358| 1| if (TokenMatch(mFilePtr, "MESH_BONE_LIST", 14)) { ------------------ | Branch (1358:17): [True: 0, False: 1] ------------------ 1359| 0| ParseLV4MeshBones(iNumBones, mesh); 1360| 0| continue; 1361| 0| } 1362| | // parse the list of bones vertices 1363| 1| if (TokenMatch(mFilePtr, "MESH_BONE_VERTEX_LIST", 21)) { ------------------ | Branch (1363:17): [True: 0, False: 1] ------------------ 1364| 0| ParseLV4MeshBonesVertices(iNumVertices, mesh); 1365| 0| continue; 1366| 0| } 1367| 1| } 1368| 81| AI_ASE_HANDLE_SECTION("3", "*MESH_WEIGHTS"); ------------------ | | 94| 41| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 1, False: 40] | | ------------------ | | 95| 41| iDepth++; \ | | 96| 41| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 1, False: 39] | | ------------------ | | 97| 1| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 1, False: 0] | | ------------------ | | 98| 1| ++mFilePtr; \ | | 99| 1| SkipToNextToken(); \ | | 100| 1| return; \ | | 101| 1| } \ | | 102| 39| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 0, False: 39] | | ------------------ | | 103| 0| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 0| " chunk (Level " level ")"); \ | | 105| 0| } \ | | 106| 41| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 2, False: 38] | | | Branch (106:33): [True: 1, False: 1] | | ------------------ | | 107| 1| ++iLineNumber; \ | | 108| 1| bLastWasEndLine = true; \ | | 109| 1| } else \ | | 110| 40| bLastWasEndLine = false; \ | | 111| 40| ++mFilePtr; ------------------ 1369| 81| } 1370| 1|} _ZN6Assimp3ASE6Parser27ParseLV3MeshVertexListBlockEjRNS0_4MeshE: 1445| 48| unsigned int iNumVertices, ASE::Mesh &mesh) { 1446| 48| AI_ASE_PARSER_INIT(); ------------------ | | 63| 48| int iDepth = 0; ------------------ 1447| | 1448| | // allocate enough storage in the array 1449| 48| mesh.mPositions.resize(iNumVertices); 1450| 129k| while (true) { ------------------ | Branch (1450:12): [True: 129k, Folded] ------------------ 1451| 129k| if ('*' == *mFilePtr) { ------------------ | Branch (1451:13): [True: 2.70k, False: 127k] ------------------ 1452| 2.70k| ++mFilePtr; 1453| | 1454| | // Vertex entry 1455| 2.70k| if (TokenMatch(mFilePtr, "MESH_VERTEX", 11)) { ------------------ | Branch (1455:17): [True: 267, False: 2.43k] ------------------ 1456| | 1457| 267| aiVector3D vTemp; 1458| 267| unsigned int iIndex; 1459| 267| ParseLV4MeshRealTriple(&vTemp.x, iIndex); 1460| | 1461| 267| if (iIndex >= iNumVertices) { ------------------ | Branch (1461:21): [True: 0, False: 267] ------------------ 1462| 0| LogWarning("Invalid vertex index. It will be ignored"); 1463| 0| } else 1464| 267| mesh.mPositions[iIndex] = vTemp; 1465| 267| continue; 1466| 267| } 1467| 2.70k| } 1468| 259k| AI_ASE_HANDLE_SECTION("3", "*MESH_VERTEX_LIST"); ------------------ | | 94| 129k| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 77, False: 129k] | | ------------------ | | 95| 129k| iDepth++; \ | | 96| 129k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 77, False: 129k] | | ------------------ | | 97| 77| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 48, False: 29] | | ------------------ | | 98| 48| ++mFilePtr; \ | | 99| 48| SkipToNextToken(); \ | | 100| 48| return; \ | | 101| 48| } \ | | 102| 129k| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 0, False: 129k] | | ------------------ | | 103| 0| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 0| " chunk (Level " level ")"); \ | | 105| 0| } \ | | 106| 129k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 2.39k, False: 127k] | | | Branch (106:33): [True: 2.37k, False: 17] | | ------------------ | | 107| 2.37k| ++iLineNumber; \ | | 108| 2.37k| bLastWasEndLine = true; \ | | 109| 2.37k| } else \ | | 110| 129k| bLastWasEndLine = false; \ | | 111| 129k| ++mFilePtr; ------------------ 1469| 259k| } 1470| 48|} _ZN6Assimp3ASE6Parser25ParseLV3MeshFaceListBlockEjRNS0_4MeshE: 1472| 22|void Parser::ParseLV3MeshFaceListBlock(unsigned int iNumFaces, ASE::Mesh &mesh) { 1473| 22| AI_ASE_PARSER_INIT(); ------------------ | | 63| 22| int iDepth = 0; ------------------ 1474| | 1475| | // allocate enough storage in the face array 1476| 22| mesh.mFaces.resize(iNumFaces); 1477| 50.0k| while (true) { ------------------ | Branch (1477:12): [True: 50.0k, Folded] ------------------ 1478| 50.0k| if ('*' == *mFilePtr) { ------------------ | Branch (1478:13): [True: 2.95k, False: 47.0k] ------------------ 1479| 2.95k| ++mFilePtr; 1480| | 1481| | // Face entry 1482| 2.95k| if (TokenMatch(mFilePtr, "MESH_FACE", 9)) { ------------------ | Branch (1482:17): [True: 852, False: 2.09k] ------------------ 1483| | 1484| 852| ASE::Face mFace; 1485| 852| ParseLV4MeshFace(mFace); 1486| | 1487| 852| if (mFace.iFace >= iNumFaces) { ------------------ | Branch (1487:21): [True: 578, False: 274] ------------------ 1488| 578| LogWarning("Face has an invalid index. It will be ignored"); 1489| 578| } else 1490| 274| mesh.mFaces[mFace.iFace] = mFace; 1491| 852| continue; 1492| 852| } 1493| 2.95k| } 1494| 98.3k| AI_ASE_HANDLE_SECTION("3", "*MESH_FACE_LIST"); ------------------ | | 94| 49.1k| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 372, False: 48.8k] | | ------------------ | | 95| 49.1k| iDepth++; \ | | 96| 49.1k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 1.06k, False: 47.7k] | | ------------------ | | 97| 1.06k| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 18, False: 1.04k] | | ------------------ | | 98| 18| ++mFilePtr; \ | | 99| 18| SkipToNextToken(); \ | | 100| 18| return; \ | | 101| 18| } \ | | 102| 47.7k| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 4, False: 47.7k] | | ------------------ | | 103| 4| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 4| " chunk (Level " level ")"); \ | | 105| 4| } \ | | 106| 49.1k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 2.33k, False: 46.8k] | | | Branch (106:33): [True: 2.08k, False: 246] | | ------------------ | | 107| 2.08k| ++iLineNumber; \ | | 108| 2.08k| bLastWasEndLine = true; \ | | 109| 2.08k| } else \ | | 110| 49.1k| bLastWasEndLine = false; \ | | 111| 49.1k| ++mFilePtr; ------------------ 1495| 98.3k| } 1496| 22|} _ZN6Assimp3ASE6Parser22ParseLV3MeshTListBlockEjRNS0_4MeshEj: 1499| 22| ASE::Mesh &mesh, unsigned int iChannel) { 1500| 22| AI_ASE_PARSER_INIT(); ------------------ | | 63| 22| int iDepth = 0; ------------------ 1501| | 1502| | // allocate enough storage in the array 1503| 22| mesh.amTexCoords[iChannel].resize(iNumVertices); 1504| 1.77k| while (true) { ------------------ | Branch (1504:12): [True: 1.77k, Folded] ------------------ 1505| 1.77k| if ('*' == *mFilePtr) { ------------------ | Branch (1505:13): [True: 333, False: 1.44k] ------------------ 1506| 333| ++mFilePtr; 1507| | 1508| | // Vertex entry 1509| 333| if (TokenMatch(mFilePtr, "MESH_TVERT", 10)) { ------------------ | Branch (1509:17): [True: 333, False: 0] ------------------ 1510| 333| aiVector3D vTemp; 1511| 333| unsigned int iIndex; 1512| 333| ParseLV4MeshRealTriple(&vTemp.x, iIndex); 1513| | 1514| 333| if (iIndex >= iNumVertices) { ------------------ | Branch (1514:21): [True: 0, False: 333] ------------------ 1515| 0| LogWarning("Tvertex has an invalid index. It will be ignored"); 1516| 0| } else 1517| 333| mesh.amTexCoords[iChannel][iIndex] = vTemp; 1518| | 1519| 333| if (0.0f != vTemp.z) { ------------------ | Branch (1519:21): [True: 0, False: 333] ------------------ 1520| | // we need 3 coordinate channels 1521| 0| mesh.mNumUVComponents[iChannel] = 3; 1522| 0| } 1523| 333| continue; 1524| 333| } 1525| 333| } 1526| 2.86k| AI_ASE_HANDLE_SECTION("3", "*MESH_TVERT_LIST"); ------------------ | | 94| 1.44k| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 22, False: 1.42k] | | ------------------ | | 95| 1.44k| iDepth++; \ | | 96| 1.44k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 22, False: 1.39k] | | ------------------ | | 97| 22| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 22, False: 0] | | ------------------ | | 98| 22| ++mFilePtr; \ | | 99| 22| SkipToNextToken(); \ | | 100| 22| return; \ | | 101| 22| } \ | | 102| 1.39k| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 0, False: 1.39k] | | ------------------ | | 103| 0| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 0| " chunk (Level " level ")"); \ | | 105| 0| } \ | | 106| 1.44k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 355, False: 1.06k] | | | Branch (106:33): [True: 355, False: 0] | | ------------------ | | 107| 355| ++iLineNumber; \ | | 108| 355| bLastWasEndLine = true; \ | | 109| 355| } else \ | | 110| 1.42k| bLastWasEndLine = false; \ | | 111| 1.42k| ++mFilePtr; ------------------ 1527| 2.86k| } 1528| 22|} _ZN6Assimp3ASE6Parser26ParseLV3MeshTFaceListBlockEjRNS0_4MeshEj: 1531| 24| ASE::Mesh &mesh, unsigned int iChannel) { 1532| 24| AI_ASE_PARSER_INIT(); ------------------ | | 63| 24| int iDepth = 0; ------------------ 1533| 40.5k| while (true) { ------------------ | Branch (1533:12): [True: 40.5k, Folded] ------------------ 1534| 40.5k| if ('*' == *mFilePtr) { ------------------ | Branch (1534:13): [True: 2.41k, False: 38.1k] ------------------ 1535| 2.41k| ++mFilePtr; 1536| | 1537| | // Face entry 1538| 2.41k| if (TokenMatch(mFilePtr, "MESH_TFACE", 10)) { ------------------ | Branch (1538:17): [True: 549, False: 1.86k] ------------------ 1539| 549| unsigned int aiValues[3]; 1540| 549| unsigned int iIndex = 0; 1541| | 1542| 549| ParseLV4MeshLongTriple(aiValues, iIndex); 1543| 549| if (iIndex >= iNumFaces || iIndex >= mesh.mFaces.size()) { ------------------ | Branch (1543:21): [True: 254, False: 295] | Branch (1543:44): [True: 79, False: 216] ------------------ 1544| 333| LogWarning("UV-Face has an invalid index. It will be ignored"); 1545| 333| } else { 1546| | // copy UV indices 1547| 216| mesh.mFaces[iIndex].amUVIndices[iChannel][0] = aiValues[0]; 1548| 216| mesh.mFaces[iIndex].amUVIndices[iChannel][1] = aiValues[1]; 1549| 216| mesh.mFaces[iIndex].amUVIndices[iChannel][2] = aiValues[2]; 1550| 216| } 1551| 549| continue; 1552| 549| } 1553| 2.41k| } 1554| 79.9k| AI_ASE_HANDLE_SECTION("3", "*MESH_TFACE_LIST"); ------------------ | | 94| 39.9k| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 22, False: 39.9k] | | ------------------ | | 95| 39.9k| iDepth++; \ | | 96| 39.9k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 22, False: 39.9k] | | ------------------ | | 97| 22| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 22, False: 0] | | ------------------ | | 98| 22| ++mFilePtr; \ | | 99| 22| SkipToNextToken(); \ | | 100| 22| return; \ | | 101| 22| } \ | | 102| 39.9k| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 2, False: 39.9k] | | ------------------ | | 103| 2| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 2| " chunk (Level " level ")"); \ | | 105| 2| } \ | | 106| 39.9k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 3.88k, False: 36.0k] | | | Branch (106:33): [True: 2.60k, False: 1.27k] | | ------------------ | | 107| 2.60k| ++iLineNumber; \ | | 108| 2.60k| bLastWasEndLine = true; \ | | 109| 2.60k| } else \ | | 110| 39.9k| bLastWasEndLine = false; \ | | 111| 39.9k| ++mFilePtr; ------------------ 1555| 79.9k| } 1556| 24|} _ZN6Assimp3ASE6Parser27ParseLV3MeshNormalListBlockERNS0_4MeshE: 1646| 21|void Parser::ParseLV3MeshNormalListBlock(ASE::Mesh &sMesh) { 1647| 21| AI_ASE_PARSER_INIT(); ------------------ | | 63| 21| int iDepth = 0; ------------------ 1648| | 1649| | // Allocate enough storage for the normals 1650| 21| sMesh.mNormals.resize(sMesh.mFaces.size() * 3, aiVector3D(0.f, 0.f, 0.f)); 1651| 21| unsigned int index, faceIdx = UINT_MAX; 1652| | 1653| | // FIXME: rewrite this and find out how to interpret the normals 1654| | // correctly. This is crap. 1655| | 1656| | // Smooth the vertex and face normals together. The result 1657| | // will be edgy then, but otherwise everything would be soft ... 1658| 55.5k| while (true) { ------------------ | Branch (1658:12): [True: 55.5k, Folded] ------------------ 1659| 55.5k| if ('*' == *mFilePtr) { ------------------ | Branch (1659:13): [True: 1.83k, False: 53.7k] ------------------ 1660| 1.83k| ++mFilePtr; 1661| 1.83k| if (faceIdx != UINT_MAX && TokenMatch(mFilePtr, "MESH_VERTEXNORMAL", 17)) { ------------------ | Branch (1661:17): [True: 1.81k, False: 21] | Branch (1661:40): [True: 673, False: 1.14k] ------------------ 1662| 673| aiVector3D vNormal; 1663| 673| ParseLV4MeshRealTriple(&vNormal.x, index); 1664| 673| if (faceIdx >= sMesh.mFaces.size()) ------------------ | Branch (1664:21): [True: 17, False: 656] ------------------ 1665| 17| continue; 1666| | 1667| | // Make sure we assign it to the correct face 1668| 656| const ASE::Face &face = sMesh.mFaces[faceIdx]; 1669| 656| if (index == face.mIndices[0]) ------------------ | Branch (1669:21): [True: 214, False: 442] ------------------ 1670| 214| index = 0; 1671| 442| else if (index == face.mIndices[1]) ------------------ | Branch (1671:26): [True: 214, False: 228] ------------------ 1672| 214| index = 1; 1673| 228| else if (index == face.mIndices[2]) ------------------ | Branch (1673:26): [True: 212, False: 16] ------------------ 1674| 212| index = 2; 1675| 16| else { 1676| 16| ASSIMP_LOG_ERROR("ASE: Invalid vertex index in MESH_VERTEXNORMAL section"); 1677| 16| continue; 1678| 16| } 1679| | // We'll renormalize later 1680| 640| sMesh.mNormals[faceIdx * 3 + index] += vNormal; 1681| 640| continue; 1682| 656| } 1683| 1.16k| if (TokenMatch(mFilePtr, "MESH_FACENORMAL", 15)) { ------------------ | Branch (1683:17): [True: 671, False: 491] ------------------ 1684| 671| aiVector3D vNormal; 1685| 671| ParseLV4MeshRealTriple(&vNormal.x, faceIdx); 1686| | 1687| 671| if (faceIdx >= sMesh.mFaces.size()) { ------------------ | Branch (1687:21): [True: 450, False: 221] ------------------ 1688| 450| ASSIMP_LOG_ERROR("ASE: Invalid vertex index in MESH_FACENORMAL section"); 1689| 450| continue; 1690| 450| } 1691| | 1692| | // We'll renormalize later 1693| 221| sMesh.mNormals[faceIdx * 3] += vNormal; 1694| 221| sMesh.mNormals[faceIdx * 3 + 1] += vNormal; 1695| 221| sMesh.mNormals[faceIdx * 3 + 2] += vNormal; 1696| 221| continue; 1697| 671| } 1698| 1.16k| } 1699| 108k| AI_ASE_HANDLE_SECTION("3", "*MESH_NORMALS"); ------------------ | | 94| 54.2k| if ('{' == *mFilePtr) \ | | ------------------ | | | Branch (94:9): [True: 22, False: 54.2k] | | ------------------ | | 95| 54.2k| iDepth++; \ | | 96| 54.2k| else if ('}' == *mFilePtr) { \ | | ------------------ | | | Branch (96:14): [True: 16, False: 54.1k] | | ------------------ | | 97| 16| if (0 == --iDepth) { \ | | ------------------ | | | Branch (97:13): [True: 15, False: 1] | | ------------------ | | 98| 15| ++mFilePtr; \ | | 99| 15| SkipToNextToken(); \ | | 100| 15| return; \ | | 101| 15| } \ | | 102| 54.1k| } else if ('\0' == *mFilePtr) { \ | | ------------------ | | | Branch (102:16): [True: 3, False: 54.1k] | | ------------------ | | 103| 3| LogError("Encountered unexpected EOL while parsing a " msg \ | | 104| 3| " chunk (Level " level ")"); \ | | 105| 3| } \ | | 106| 54.2k| if (IsLineEnd(*mFilePtr) && !bLastWasEndLine) { \ | | ------------------ | | | Branch (106:9): [True: 1.84k, False: 52.3k] | | | Branch (106:33): [True: 1.84k, False: 0] | | ------------------ | | 107| 1.84k| ++iLineNumber; \ | | 108| 1.84k| bLastWasEndLine = true; \ | | 109| 1.84k| } else \ | | 110| 54.2k| bLastWasEndLine = false; \ | | 111| 54.2k| ++mFilePtr; ------------------ 1700| 108k| } 1701| 21|} _ZN6Assimp3ASE6Parser16ParseLV4MeshFaceERNS0_4FaceE: 1703| 852|void Parser::ParseLV4MeshFace(ASE::Face &out) { 1704| | // skip spaces and tabs 1705| 852| if (!SkipSpaces(&mFilePtr, mEnd)) { ------------------ | Branch (1705:9): [True: 11, False: 841] ------------------ 1706| 11| LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL [#1]"); 1707| 11| SkipToNextToken(); 1708| 11| return; 1709| 11| } 1710| | 1711| | // parse the face index 1712| 841| out.iFace = strtoul10(mFilePtr, &mFilePtr); 1713| | 1714| | // next character should be ':' 1715| 841| if (!SkipSpaces(&mFilePtr, mEnd)) { ------------------ | Branch (1715:9): [True: 0, False: 841] ------------------ 1716| | // FIX: there are some ASE files which haven't got : here .... 1717| 0| LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL. \':\' expected [#2]"); 1718| 0| SkipToNextToken(); 1719| 0| return; 1720| 0| } 1721| | // FIX: There are some ASE files which haven't got ':' here 1722| 841| if (':' == *mFilePtr) ++mFilePtr; ------------------ | Branch (1722:9): [True: 273, False: 568] ------------------ 1723| | 1724| | // Parse all mesh indices 1725| 2.13k| for (unsigned int i = 0; i < 3; ++i) { ------------------ | Branch (1725:30): [True: 1.80k, False: 328] ------------------ 1726| 1.80k| unsigned int iIndex = 0; 1727| 1.80k| if (!SkipSpaces(&mFilePtr, mEnd)) { ------------------ | Branch (1727:13): [True: 53, False: 1.75k] ------------------ 1728| 53| LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL"); 1729| 53| SkipToNextToken(); 1730| 53| return; 1731| 53| } 1732| 1.75k| switch (*mFilePtr) { 1733| 807| case 'A': ------------------ | Branch (1733:9): [True: 807, False: 947] ------------------ 1734| 816| case 'a': ------------------ | Branch (1734:9): [True: 9, False: 1.74k] ------------------ 1735| 816| break; 1736| 336| case 'B': ------------------ | Branch (1736:9): [True: 336, False: 1.41k] ------------------ 1737| 432| case 'b': ------------------ | Branch (1737:9): [True: 96, False: 1.65k] ------------------ 1738| 432| iIndex = 1; 1739| 432| break; 1740| 280| case 'C': ------------------ | Branch (1740:9): [True: 280, False: 1.47k] ------------------ 1741| 355| case 'c': ------------------ | Branch (1741:9): [True: 75, False: 1.67k] ------------------ 1742| 355| iIndex = 2; 1743| 355| break; 1744| 151| default: ------------------ | Branch (1744:9): [True: 151, False: 1.60k] ------------------ 1745| 151| LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL. " 1746| 151| "A,B or C expected [#3]"); 1747| 151| SkipToNextToken(); 1748| 151| return; 1749| 1.75k| }; 1750| 1.60k| ++mFilePtr; 1751| | 1752| | // next character should be ':' 1753| 1.60k| if (!SkipSpaces(&mFilePtr, mEnd) || ':' != *mFilePtr) { ------------------ | Branch (1753:13): [True: 96, False: 1.50k] | Branch (1753:45): [True: 163, False: 1.34k] ------------------ 1754| 259| LogWarning("Unable to parse *MESH_FACE Element: " 1755| 259| "Unexpected EOL. \':\' expected [#2]"); 1756| 259| SkipToNextToken(); 1757| 259| return; 1758| 259| } 1759| | 1760| 1.34k| ++mFilePtr; 1761| 1.34k| if (!SkipSpaces(&mFilePtr, mEnd)) { ------------------ | Branch (1761:13): [True: 50, False: 1.29k] ------------------ 1762| 50| LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL. " 1763| 50| "Vertex index expected [#4]"); 1764| 50| SkipToNextToken(); 1765| 50| return; 1766| 50| } 1767| 1.29k| out.mIndices[iIndex] = strtoul10(mFilePtr, &mFilePtr); 1768| 1.29k| } 1769| | 1770| | // now we need to skip the AB, BC, CA blocks. 1771| 8.28k| while (true) { ------------------ | Branch (1771:12): [True: 8.28k, Folded] ------------------ 1772| 8.28k| if ('*' == *mFilePtr) break; ------------------ | Branch (1772:13): [True: 328, False: 7.95k] ------------------ 1773| 7.95k| if (IsLineEnd(*mFilePtr)) { ------------------ | Branch (1773:13): [True: 0, False: 7.95k] ------------------ 1774| | //iLineNumber++; 1775| 0| return; 1776| 0| } 1777| 7.95k| mFilePtr++; 1778| 7.95k| } 1779| | 1780| | // parse the smoothing group of the face 1781| 328| if (TokenMatch(mFilePtr, "*MESH_SMOOTHING", 15)) { ------------------ | Branch (1781:9): [True: 312, False: 16] ------------------ 1782| 312| if (!SkipSpaces(&mFilePtr, mEnd)) { ------------------ | Branch (1782:13): [True: 0, False: 312] ------------------ 1783| 0| LogWarning("Unable to parse *MESH_SMOOTHING Element: " 1784| 0| "Unexpected EOL. Smoothing group(s) expected [#5]"); 1785| 0| SkipToNextToken(); 1786| 0| return; 1787| 0| } 1788| | 1789| | // Parse smoothing groups until we don't anymore see commas 1790| | // FIX: There needn't always be a value, sad but true 1791| 336| while (true) { ------------------ | Branch (1791:16): [True: 336, Folded] ------------------ 1792| 336| if (*mFilePtr < '9' && *mFilePtr >= '0') { ------------------ | Branch (1792:17): [True: 321, False: 15] | Branch (1792:36): [True: 287, False: 34] ------------------ 1793| 287| uint32_t value = strtoul10(mFilePtr, &mFilePtr); 1794| 287| if (value < 32) { ------------------ | Branch (1794:21): [True: 287, False: 0] ------------------ 1795| 287| out.iSmoothGroup |= (1 << strtoul10(mFilePtr, &mFilePtr)); 1796| 287| } else { 1797| 0| const std::string message = std::string("Unable to set smooth group, value with ") + ai_to_string(value) + std::string(" out of range"); 1798| 0| LogWarning(message.c_str()); 1799| 0| } 1800| 287| } 1801| 336| SkipSpaces(&mFilePtr, mEnd); 1802| 336| if (',' != *mFilePtr) { ------------------ | Branch (1802:17): [True: 312, False: 24] ------------------ 1803| 312| break; 1804| 312| } 1805| 24| ++mFilePtr; 1806| 24| SkipSpaces(&mFilePtr, mEnd); 1807| 24| } 1808| 312| } 1809| | 1810| | // *MESH_MTLID is optional, too 1811| 534| while (true) { ------------------ | Branch (1811:12): [True: 534, Folded] ------------------ 1812| 534| if ('*' == *mFilePtr) { ------------------ | Branch (1812:13): [True: 328, False: 206] ------------------ 1813| 328| break; 1814| 328| } 1815| 206| if (IsLineEnd(*mFilePtr)) { ------------------ | Branch (1815:13): [True: 0, False: 206] ------------------ 1816| 0| return; 1817| 0| } 1818| 206| mFilePtr++; 1819| 206| } 1820| | 1821| 328| if (TokenMatch(mFilePtr, "*MESH_MTLID", 11)) { ------------------ | Branch (1821:9): [True: 287, False: 41] ------------------ 1822| 287| if (!SkipSpaces(&mFilePtr, mEnd)) { ------------------ | Branch (1822:13): [True: 13, False: 274] ------------------ 1823| 13| LogWarning("Unable to parse *MESH_MTLID Element: Unexpected EOL. " 1824| 13| "Material index expected [#6]"); 1825| 13| SkipToNextToken(); 1826| 13| return; 1827| 13| } 1828| 274| out.iMaterial = strtoul10(mFilePtr, &mFilePtr); 1829| 274| } 1830| 315| return; 1831| 328|} _ZN6Assimp3ASE6Parser22ParseLV4MeshLongTripleEPj: 1833| 690|void Parser::ParseLV4MeshLongTriple(unsigned int *apOut) { 1834| 690| ai_assert(nullptr != apOut); 1835| | 1836| 2.76k| for (unsigned int i = 0; i < 3; ++i) ------------------ | Branch (1836:30): [True: 2.07k, False: 690] ------------------ 1837| 2.07k| ParseLV4MeshLong(apOut[i]); 1838| 690|} _ZN6Assimp3ASE6Parser22ParseLV4MeshLongTripleEPjRj: 1840| 549|void Parser::ParseLV4MeshLongTriple(unsigned int *apOut, unsigned int &rIndexOut) { 1841| 549| ai_assert(nullptr != apOut); 1842| | 1843| | // parse the index 1844| 549| ParseLV4MeshLong(rIndexOut); 1845| | 1846| | // parse the three others 1847| 549| ParseLV4MeshLongTriple(apOut); 1848| 549|} _ZN6Assimp3ASE6Parser22ParseLV4MeshRealTripleEPfRj: 1850| 4.83k|void Parser::ParseLV4MeshRealTriple(ai_real *apOut, unsigned int &rIndexOut) { 1851| 4.83k| ai_assert(nullptr != apOut); 1852| | 1853| | // parse the index 1854| 4.83k| ParseLV4MeshLong(rIndexOut); 1855| | 1856| | // parse the three others 1857| 4.83k| ParseLV4MeshRealTriple(apOut); 1858| 4.83k|} _ZN6Assimp3ASE6Parser22ParseLV4MeshRealTripleEPf: 1870| 5.02k|void Parser::ParseLV4MeshRealTriple(ai_real *apOut) { 1871| 5.02k| ai_assert(nullptr != apOut); 1872| | 1873| 20.1k| for (unsigned int i = 0; i < 3; ++i) { ------------------ | Branch (1873:30): [True: 15.0k, False: 5.02k] ------------------ 1874| 15.0k| ParseLV4MeshReal(apOut[i]); 1875| 15.0k| } 1876| 5.02k|} _ZN6Assimp3ASE6Parser23ParseLV4MeshFloatTripleEPf: 1878| 65|void Parser::ParseLV4MeshFloatTriple(float* apOut) { 1879| 65| ai_assert(nullptr != apOut); 1880| | 1881| 260| for (unsigned int i = 0; i < 3; ++i) { ------------------ | Branch (1881:30): [True: 195, False: 65] ------------------ 1882| 195| ParseLV4MeshFloat(apOut[i]); 1883| 195| } 1884| 65|} _ZN6Assimp3ASE6Parser16ParseLV4MeshRealERf: 1886| 17.1k|void Parser::ParseLV4MeshReal(ai_real &fOut) { 1887| | // skip spaces and tabs 1888| 17.1k| if (!SkipSpaces(&mFilePtr, mEnd)) { ------------------ | Branch (1888:9): [True: 3.60k, False: 13.5k] ------------------ 1889| | // LOG 1890| 3.60k| LogWarning("Unable to parse float: unexpected EOL [#1]"); 1891| 3.60k| fOut = 0.0; 1892| 3.60k| ++iLineNumber; 1893| 3.60k| return; 1894| 3.60k| } 1895| | // parse the first float 1896| 13.5k| mFilePtr = fast_atoreal_move(mFilePtr, fOut); 1897| 13.5k|} _ZN6Assimp3ASE6Parser17ParseLV4MeshFloatERf: 1899| 195|void Parser::ParseLV4MeshFloat(float &fOut) { 1900| | // skip spaces and tabs 1901| 195| if (!SkipSpaces(&mFilePtr, mEnd)) { ------------------ | Branch (1901:9): [True: 0, False: 195] ------------------ 1902| | // LOG 1903| 0| LogWarning("Unable to parse float: unexpected EOL [#1]"); 1904| 0| fOut = 0.0; 1905| 0| ++iLineNumber; 1906| 0| return; 1907| 0| } 1908| | // parse the first float 1909| 195| mFilePtr = fast_atoreal_move(mFilePtr, fOut); 1910| 195|} _ZN6Assimp3ASE6Parser16ParseLV4MeshLongERj: 1912| 7.78k|void Parser::ParseLV4MeshLong(unsigned int &iOut) { 1913| | // Skip spaces and tabs 1914| 7.78k| if (!SkipSpaces(&mFilePtr, mEnd)) { ------------------ | Branch (1914:9): [True: 1.78k, False: 5.99k] ------------------ 1915| | // LOG 1916| 1.78k| LogWarning("Unable to parse long: unexpected EOL [#1]"); 1917| 1.78k| iOut = 0; 1918| 1.78k| ++iLineNumber; 1919| 1.78k| return; 1920| 1.78k| } 1921| | // parse the value 1922| 5.99k| iOut = strtoul10(mFilePtr, &mFilePtr); 1923| 5.99k|} _ZN6Assimp3ASE8MaterialC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 72| 50| D3DS::Material(name), 73| 50| pcInstance(nullptr), 74| 50| bNeed(false) { 75| | // empty 76| 50| } _ZN6Assimp3ASE4FaceC2Ev: 134| 1.12k| : iMaterial(DEFAULT_MATINDEX), 135| 1.12k| iFace(0) { 136| | // empty 137| 1.12k| } _ZN6Assimp3ASE9AnimationC2Ev: 194| 108| : mRotationType(TRACK), 195| 108| mScalingType(TRACK), 196| 108| mPositionType(TRACK) { 197| | // empty 198| 108| } _ZN6Assimp3ASE15InheritanceInfoC2Ev: 214| 54| InheritanceInfo() AI_NO_EXCEPT { 215| 216| for (size_t i = 0; i < 3; ++i) { ------------------ | Branch (215:28): [True: 162, False: 54] ------------------ 216| 162| abInheritPosition[i] = abInheritRotation[i] = abInheritScaling[i] = true; 217| 162| } 218| 54| } _ZN6Assimp3ASE8BaseNodeC2ENS1_4TypeERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 242| 54| mType(_mType), mName(name), mProcessed(false) { 243| | // Set mTargetPosition to qnan 244| 54| const ai_real qnan = get_qnan(); 245| 54| mTargetPosition.x = qnan; 246| 54| } _ZN6Assimp3ASE4MeshC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 283| 41| BaseNode(BaseNode::Mesh, name), mVertexColors(), mBoneVertices(), mBones(), iMaterialIndex(Face::DEFAULT_MATINDEX), bSkip(false) { 284| 369| for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) { ------------------ | Branch (284:34): [True: 328, False: 41] ------------------ 285| 328| this->mNumUVComponents[c] = 2; 286| 328| } 287| 41| } _ZN6Assimp3ASE5LightC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 326| 5| BaseNode(BaseNode::Light, name), mLightType(OMNI), mColor(1.f, 1.f, 1.f), mIntensity(1.f) // light is white by default 327| | , 328| 5| mAngle(45.f), 329| 5| mFalloff(0.f) { 330| 5| } _ZN6Assimp3ASE6CameraC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 352| 8| BaseNode(BaseNode::Camera, name), mFOV(0.75f) // in radians 353| | , 354| 8| mNear(0.1f), 355| 8| mFar(1000.f) // could be zero 356| | , 357| 8| mCameraType(FREE) { 358| 8| } _ZN6Assimp3ASE8MaterialD2Ev: 117| 77| ~Material() override = default; _ZN6Assimp3ASE8MaterialC2ERKS1_: 78| 27| Material(const Material &other) = default; _ZNK6Assimp14AssbinImporter7GetInfoEv: 82| 634|const aiImporterDesc *AssbinImporter::GetInfo() const { 83| 634| return &desc; 84| 634|} _ZNK6Assimp14AssbinImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 87| 49|bool AssbinImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 88| 49| IOStream *in = pIOHandler->Open(pFile); 89| 49| if (nullptr == in) { ------------------ | Branch (89:9): [True: 0, False: 49] ------------------ 90| 0| return false; 91| 0| } 92| | 93| 49| char s[32]; 94| 49| const size_t read = in->Read(s, sizeof(char), 32); 95| | 96| 49| pIOHandler->Close(in); 97| | 98| 49| if (read < 19) { ------------------ | Branch (98:9): [True: 0, False: 49] ------------------ 99| 0| return false; 100| 0| } 101| | 102| 49| return strncmp(s, "ASSIMP.binary-dump.", 19) == 0; 103| 49|} _ZN6Assimp11B3DImporterD2Ev: 91| 624|B3DImporter::~B3DImporter() = default; _ZNK6Assimp11B3DImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 94| 320|bool B3DImporter::CanRead(const std::string &pFile, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const { 95| 320| size_t pos = pFile.find_last_of('.'); 96| 320| if (pos == string::npos) { ------------------ | Branch (96:9): [True: 17, False: 303] ------------------ 97| 17| return false; 98| 17| } 99| | 100| 303| string ext = pFile.substr(pos + 1); 101| 303| if (ext.size() != 3) { ------------------ | Branch (101:9): [True: 303, False: 0] ------------------ 102| 303| return false; 103| 303| } 104| | 105| 0| return (ext[0] == 'b' || ext[0] == 'B') && (ext[1] == '3') && (ext[2] == 'd' || ext[2] == 'D'); ------------------ | Branch (105:13): [True: 0, False: 0] | Branch (105:30): [True: 0, False: 0] | Branch (105:48): [True: 0, False: 0] | Branch (105:68): [True: 0, False: 0] | Branch (105:85): [True: 0, False: 0] ------------------ 106| 303|} _ZNK6Assimp11B3DImporter7GetInfoEv: 110| 634|const aiImporterDesc *B3DImporter::GetInfo() const { 111| 634| return &desc; 112| 634|} _ZN6Assimp11B3DImporterC2Ev: 66| 624| B3DImporter() = default; _ZN6Assimp9BVHLoaderC2Ev: 86| 624| noSkeletonMesh() { 87| | // empty 88| 624|} _ZNK6Assimp9BVHLoader7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 92| 347|bool BVHLoader::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 93| 347| static const char *tokens[] = { "HIERARCHY" }; 94| | return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); 95| 347|} _ZNK6Assimp9BVHLoader7GetInfoEv: 104| 634|const aiImporterDesc *BVHLoader::GetInfo() const { 105| 634| return &desc; 106| 634|} _ZN6Assimp9BVHLoaderD2Ev: 88| 624| ~BVHLoader() override = default; _ZN6Assimp7Blender9readMVertEPNS0_8ElemBaseEmRKNS0_12FileDatabaseE: 30| 42| bool read##ty(ElemBase *v, const size_t cnt, const FileDatabase &db) { \ 31| 42| ty *ptr = dynamic_cast(v); \ 32| 42| if (nullptr == ptr) { \ ------------------ | Branch (32:13): [True: 0, False: 42] ------------------ 33| 0| return false; \ 34| 0| } \ 35| 42| return read(db.dna[#ty], ptr, cnt, db); \ 36| 42| } _ZN6Assimp7Blender11createMVertEm: 39| 42| ElemBase *create##ty(const size_t cnt) { \ 40| 42| return new ty[cnt]; \ 41| 42| } _ZN6Assimp7Blender12destroyMVertEPNS0_8ElemBaseE: 44| 42| void destroy##ty(ElemBase *pE) { \ 45| 42| ty *p = dynamic_cast(pE); \ 46| 42| delete[] p; \ 47| 42| } _ZN6Assimp7Blender9readMEdgeEPNS0_8ElemBaseEmRKNS0_12FileDatabaseE: 30| 42| bool read##ty(ElemBase *v, const size_t cnt, const FileDatabase &db) { \ 31| 42| ty *ptr = dynamic_cast(v); \ 32| 42| if (nullptr == ptr) { \ ------------------ | Branch (32:13): [True: 0, False: 42] ------------------ 33| 0| return false; \ 34| 0| } \ 35| 42| return read(db.dna[#ty], ptr, cnt, db); \ 36| 42| } _ZN6Assimp7Blender11createMEdgeEm: 39| 42| ElemBase *create##ty(const size_t cnt) { \ 40| 42| return new ty[cnt]; \ 41| 42| } _ZN6Assimp7Blender12destroyMEdgeEPNS0_8ElemBaseE: 44| 42| void destroy##ty(ElemBase *pE) { \ 45| 42| ty *p = dynamic_cast(pE); \ 46| 42| delete[] p; \ 47| 42| } _ZN6Assimp7Blender9readMFaceEPNS0_8ElemBaseEmRKNS0_12FileDatabaseE: 30| 31| bool read##ty(ElemBase *v, const size_t cnt, const FileDatabase &db) { \ 31| 31| ty *ptr = dynamic_cast(v); \ 32| 31| if (nullptr == ptr) { \ ------------------ | Branch (32:13): [True: 0, False: 31] ------------------ 33| 0| return false; \ 34| 0| } \ 35| 31| return read(db.dna[#ty], ptr, cnt, db); \ 36| 31| } _ZN6Assimp7Blender11createMFaceEm: 39| 31| ElemBase *create##ty(const size_t cnt) { \ 40| 31| return new ty[cnt]; \ 41| 31| } _ZN6Assimp7Blender12destroyMFaceEPNS0_8ElemBaseE: 44| 31| void destroy##ty(ElemBase *pE) { \ 45| 31| ty *p = dynamic_cast(pE); \ 46| 31| delete[] p; \ 47| 31| } _ZN6Assimp7Blender10readMTFaceEPNS0_8ElemBaseEmRKNS0_12FileDatabaseE: 30| 4| bool read##ty(ElemBase *v, const size_t cnt, const FileDatabase &db) { \ 31| 4| ty *ptr = dynamic_cast(v); \ 32| 4| if (nullptr == ptr) { \ ------------------ | Branch (32:13): [True: 0, False: 4] ------------------ 33| 0| return false; \ 34| 0| } \ 35| 4| return read(db.dna[#ty], ptr, cnt, db); \ 36| 4| } _ZN6Assimp7Blender12createMTFaceEm: 39| 4| ElemBase *create##ty(const size_t cnt) { \ 40| 4| return new ty[cnt]; \ 41| 4| } _ZN6Assimp7Blender13destroyMTFaceEPNS0_8ElemBaseE: 44| 4| void destroy##ty(ElemBase *pE) { \ 45| 4| ty *p = dynamic_cast(pE); \ 46| 4| delete[] p; \ 47| 4| } _ZN6Assimp7Blender12readMTexPolyEPNS0_8ElemBaseEmRKNS0_12FileDatabaseE: 30| 3| bool read##ty(ElemBase *v, const size_t cnt, const FileDatabase &db) { \ 31| 3| ty *ptr = dynamic_cast(v); \ 32| 3| if (nullptr == ptr) { \ ------------------ | Branch (32:13): [True: 0, False: 3] ------------------ 33| 0| return false; \ 34| 0| } \ 35| 3| return read(db.dna[#ty], ptr, cnt, db); \ 36| 3| } _ZN6Assimp7Blender14createMTexPolyEm: 39| 3| ElemBase *create##ty(const size_t cnt) { \ 40| 3| return new ty[cnt]; \ 41| 3| } _ZN6Assimp7Blender15destroyMTexPolyEPNS0_8ElemBaseE: 44| 3| void destroy##ty(ElemBase *pE) { \ 45| 3| ty *p = dynamic_cast(pE); \ 46| 3| delete[] p; \ 47| 3| } _ZN6Assimp7Blender11readMLoopUVEPNS0_8ElemBaseEmRKNS0_12FileDatabaseE: 30| 4| bool read##ty(ElemBase *v, const size_t cnt, const FileDatabase &db) { \ 31| 4| ty *ptr = dynamic_cast(v); \ 32| 4| if (nullptr == ptr) { \ ------------------ | Branch (32:13): [True: 0, False: 4] ------------------ 33| 0| return false; \ 34| 0| } \ 35| 4| return read(db.dna[#ty], ptr, cnt, db); \ 36| 4| } _ZN6Assimp7Blender13createMLoopUVEm: 39| 4| ElemBase *create##ty(const size_t cnt) { \ 40| 4| return new ty[cnt]; \ 41| 4| } _ZN6Assimp7Blender14destroyMLoopUVEPNS0_8ElemBaseE: 44| 4| void destroy##ty(ElemBase *pE) { \ 45| 4| ty *p = dynamic_cast(pE); \ 46| 4| delete[] p; \ 47| 4| } _ZN6Assimp7Blender9readMPolyEPNS0_8ElemBaseEmRKNS0_12FileDatabaseE: 30| 11| bool read##ty(ElemBase *v, const size_t cnt, const FileDatabase &db) { \ 31| 11| ty *ptr = dynamic_cast(v); \ 32| 11| if (nullptr == ptr) { \ ------------------ | Branch (32:13): [True: 0, False: 11] ------------------ 33| 0| return false; \ 34| 0| } \ 35| 11| return read(db.dna[#ty], ptr, cnt, db); \ 36| 11| } _ZN6Assimp7Blender11createMPolyEm: 39| 11| ElemBase *create##ty(const size_t cnt) { \ 40| 11| return new ty[cnt]; \ 41| 11| } _ZN6Assimp7Blender12destroyMPolyEPNS0_8ElemBaseE: 44| 11| void destroy##ty(ElemBase *pE) { \ 45| 11| ty *p = dynamic_cast(pE); \ 46| 11| delete[] p; \ 47| 11| } _ZN6Assimp7Blender9readMLoopEPNS0_8ElemBaseEmRKNS0_12FileDatabaseE: 30| 11| bool read##ty(ElemBase *v, const size_t cnt, const FileDatabase &db) { \ 31| 11| ty *ptr = dynamic_cast(v); \ 32| 11| if (nullptr == ptr) { \ ------------------ | Branch (32:13): [True: 0, False: 11] ------------------ 33| 0| return false; \ 34| 0| } \ 35| 11| return read(db.dna[#ty], ptr, cnt, db); \ 36| 11| } _ZN6Assimp7Blender11createMLoopEm: 39| 11| ElemBase *create##ty(const size_t cnt) { \ 40| 11| return new ty[cnt]; \ 41| 11| } _ZN6Assimp7Blender12destroyMLoopEPNS0_8ElemBaseE: 44| 11| void destroy##ty(ElemBase *pE) { \ 45| 11| ty *p = dynamic_cast(pE); \ 46| 11| delete[] p; \ 47| 11| } _ZN6Assimp7Blender21isValidCustomDataTypeEi: 148| 151|bool isValidCustomDataType(const int cdtype) { 149| 151| return cdtype >= 0 && cdtype < CD_NUMTYPES; ------------------ | Branch (149:12): [True: 151, False: 0] | Branch (149:27): [True: 150, False: 1] ------------------ 150| 151|} _ZN6Assimp7Blender14readCustomDataERNSt3__110shared_ptrINS0_8ElemBaseEEEimRKNS0_12FileDatabaseE: 152| 151|bool readCustomData(std::shared_ptr &out, const int cdtype, const size_t cnt, const FileDatabase &db) { 153| 151| if (!isValidCustomDataType(cdtype)) { ------------------ | Branch (153:9): [True: 1, False: 150] ------------------ 154| 1| throw Error("CustomData.type ", cdtype, " out of index"); 155| 1| } 156| | 157| 150| const CustomDataTypeDescription cdtd = customDataTypeDescriptions[cdtype]; 158| 150| if (cdtd.Read && cdtd.Create && cdtd.Destroy && cnt > 0) { ------------------ | Branch (158:9): [True: 148, False: 2] | Branch (158:22): [True: 148, False: 0] | Branch (158:37): [True: 148, False: 0] | Branch (158:53): [True: 148, False: 0] ------------------ 159| | // allocate cnt elements and parse them from file 160| 148| out.reset(cdtd.Create(cnt), cdtd.Destroy); 161| 148| return cdtd.Read(out.get(), cnt, db); 162| 148| } 163| 2| return false; 164| 150|} _ZN6Assimp7Blender18getCustomDataLayerERKNS0_10CustomDataENS0_14CustomDataTypeERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 166| 2|std::shared_ptr getCustomDataLayer(const CustomData &customdata, const CustomDataType cdtype, const std::string &name) { 167| 3| for (auto it = customdata.layers.begin(); it != customdata.layers.end(); ++it) { ------------------ | Branch (167:47): [True: 3, False: 0] ------------------ 168| 3| if (it->get()->type == cdtype && name == it->get()->name) { ------------------ | Branch (168:13): [True: 3, False: 0] | Branch (168:42): [True: 2, False: 1] ------------------ 169| 2| return *it; 170| 2| } 171| 3| } 172| 0| return nullptr; 173| 2|} _ZN6Assimp7Blender22getCustomDataLayerDataERKNS0_10CustomDataENS0_14CustomDataTypeERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 175| 2|const ElemBase *getCustomDataLayerData(const CustomData &customdata, const CustomDataType cdtype, const std::string &name) { 176| 2| const std::shared_ptr pLayer = getCustomDataLayer(customdata, cdtype, name); 177| 2| if (pLayer && pLayer->data) { ------------------ | Branch (177:9): [True: 2, False: 0] | Branch (177:19): [True: 2, False: 0] ------------------ 178| 2| return pLayer->data.get(); 179| 2| } 180| 0| return nullptr; 181| 2|} _ZN6Assimp7Blender25CustomDataTypeDescriptionC2EPFbPNS0_8ElemBaseEmRKNS0_12FileDatabaseEEPFS3_mEPFvS3_E: 77| 84| Read(read), Create(create), Destroy(destroy) {} _ZN6Assimp7Blender4readINS0_5MVertEEEbRKNS0_9StructureEPT_mRKNS0_12FileDatabaseE: 12| 42|bool read(const Structure &s, T *p, const size_t cnt, const FileDatabase &db) { 13| 9.05k| for (size_t i = 0; i < cnt; ++i) { ------------------ | Branch (13:24): [True: 9.01k, False: 42] ------------------ 14| 9.01k| T read; 15| 9.01k| s.Convert(read, db); 16| 9.01k| *p = read; 17| 9.01k| p++; 18| 9.01k| } 19| 42| return true; 20| 42|} _ZN6Assimp7Blender4readINS0_5MEdgeEEEbRKNS0_9StructureEPT_mRKNS0_12FileDatabaseE: 12| 42|bool read(const Structure &s, T *p, const size_t cnt, const FileDatabase &db) { 13| 17.0k| for (size_t i = 0; i < cnt; ++i) { ------------------ | Branch (13:24): [True: 16.9k, False: 42] ------------------ 14| 16.9k| T read; 15| 16.9k| s.Convert(read, db); 16| 16.9k| *p = read; 17| 16.9k| p++; 18| 16.9k| } 19| 42| return true; 20| 42|} _ZN6Assimp7Blender4readINS0_5MFaceEEEbRKNS0_9StructureEPT_mRKNS0_12FileDatabaseE: 12| 31|bool read(const Structure &s, T *p, const size_t cnt, const FileDatabase &db) { 13| 7.54k| for (size_t i = 0; i < cnt; ++i) { ------------------ | Branch (13:24): [True: 7.51k, False: 31] ------------------ 14| 7.51k| T read; 15| 7.51k| s.Convert(read, db); 16| 7.51k| *p = read; 17| 7.51k| p++; 18| 7.51k| } 19| 31| return true; 20| 31|} _ZN6Assimp7Blender4readINS0_6MTFaceEEEbRKNS0_9StructureEPT_mRKNS0_12FileDatabaseE: 12| 4|bool read(const Structure &s, T *p, const size_t cnt, const FileDatabase &db) { 13| 18| for (size_t i = 0; i < cnt; ++i) { ------------------ | Branch (13:24): [True: 14, False: 4] ------------------ 14| 14| T read; 15| 14| s.Convert(read, db); 16| 14| *p = read; 17| 14| p++; 18| 14| } 19| 4| return true; 20| 4|} _ZN6Assimp7Blender4readINS0_8MTexPolyEEEbRKNS0_9StructureEPT_mRKNS0_12FileDatabaseE: 12| 3|bool read(const Structure &s, T *p, const size_t cnt, const FileDatabase &db) { 13| 49| for (size_t i = 0; i < cnt; ++i) { ------------------ | Branch (13:24): [True: 46, False: 3] ------------------ 14| 46| T read; 15| 46| s.Convert(read, db); 16| 46| *p = read; 17| 46| p++; 18| 46| } 19| 3| return true; 20| 3|} _ZN6Assimp7Blender4readINS0_7MLoopUVEEEbRKNS0_9StructureEPT_mRKNS0_12FileDatabaseE: 12| 4|bool read(const Structure &s, T *p, const size_t cnt, const FileDatabase &db) { 13| 168| for (size_t i = 0; i < cnt; ++i) { ------------------ | Branch (13:24): [True: 164, False: 4] ------------------ 14| 164| T read; 15| 164| s.Convert(read, db); 16| 164| *p = read; 17| 164| p++; 18| 164| } 19| 4| return true; 20| 4|} _ZN6Assimp7Blender4readINS0_5MPolyEEEbRKNS0_9StructureEPT_mRKNS0_12FileDatabaseE: 12| 11|bool read(const Structure &s, T *p, const size_t cnt, const FileDatabase &db) { 13| 694| for (size_t i = 0; i < cnt; ++i) { ------------------ | Branch (13:24): [True: 683, False: 11] ------------------ 14| 683| T read; 15| 683| s.Convert(read, db); 16| 683| *p = read; 17| 683| p++; 18| 683| } 19| 11| return true; 20| 11|} _ZN6Assimp7Blender4readINS0_5MLoopEEEbRKNS0_9StructureEPT_mRKNS0_12FileDatabaseE: 12| 11|bool read(const Structure &s, T *p, const size_t cnt, const FileDatabase &db) { 13| 2.66k| for (size_t i = 0; i < cnt; ++i) { ------------------ | Branch (13:24): [True: 2.65k, False: 11] ------------------ 14| 2.65k| T read; 15| 2.65k| s.Convert(read, db); 16| 2.65k| *p = read; 17| 2.65k| p++; 18| 2.65k| } 19| 11| return true; 20| 11|} _ZN6Assimp7Blender9DNAParser5ParseEv: 73| 28|void DNAParser::Parse() { 74| 28| StreamReaderAny &stream = *db.reader; 75| 28| DNA &dna = db.dna; 76| | 77| 28| if (!match4(stream, "SDNA")) { ------------------ | Branch (77:9): [True: 0, False: 28] ------------------ 78| 0| throw DeadlyImportError("BlenderDNA: Expected SDNA chunk"); 79| 0| } 80| | 81| | // name dictionary 82| 28| if (!match4(stream, "NAME")) { ------------------ | Branch (82:9): [True: 0, False: 28] ------------------ 83| 0| throw DeadlyImportError("BlenderDNA: Expected NAME field"); 84| 0| } 85| | 86| 28| std::vector names(stream.GetI4()); 87| 87.9k| for (std::string &s : names) { ------------------ | Branch (87:25): [True: 87.9k, False: 28] ------------------ 88| 891k| while (char c = stream.GetI1()) { ------------------ | Branch (88:21): [True: 803k, False: 87.9k] ------------------ 89| 803k| s += c; 90| 803k| } 91| 87.9k| } 92| | 93| | // type dictionary 94| 76| for (; stream.GetCurrentPos() & 0x3; stream.GetI1()) ------------------ | Branch (94:12): [True: 48, False: 28] ------------------ 95| 48| ; 96| 28| if (!match4(stream, "TYPE")) { ------------------ | Branch (96:9): [True: 0, False: 28] ------------------ 97| 0| throw DeadlyImportError("BlenderDNA: Expected TYPE field"); 98| 0| } 99| | 100| 28| std::vector types(stream.GetI4()); 101| 13.8k| for (Type &s : types) { ------------------ | Branch (101:18): [True: 13.8k, False: 28] ------------------ 102| 189k| while (char c = stream.GetI1()) { ------------------ | Branch (102:21): [True: 175k, False: 13.8k] ------------------ 103| 175k| s.name += c; 104| 175k| } 105| 13.8k| } 106| | 107| | // type length dictionary 108| 60| for (; stream.GetCurrentPos() & 0x3; stream.GetI1()) ------------------ | Branch (108:12): [True: 32, False: 28] ------------------ 109| 32| ; 110| 28| if (!match4(stream, "TLEN")) { ------------------ | Branch (110:9): [True: 0, False: 28] ------------------ 111| 0| throw DeadlyImportError("BlenderDNA: Expected TLEN field"); 112| 0| } 113| | 114| 13.8k| for (Type &s : types) { ------------------ | Branch (114:18): [True: 13.8k, False: 28] ------------------ 115| 13.8k| s.size = stream.GetI2(); 116| 13.8k| } 117| | 118| | // structures dictionary 119| 58| for (; stream.GetCurrentPos() & 0x3; stream.GetI1()) ------------------ | Branch (119:12): [True: 30, False: 28] ------------------ 120| 30| ; 121| 28| if (!match4(stream, "STRC")) { ------------------ | Branch (121:9): [True: 0, False: 28] ------------------ 122| 0| throw DeadlyImportError("BlenderDNA: Expected STRC field"); 123| 0| } 124| | 125| 28| size_t end = stream.GetI4(), fields = 0; 126| | 127| 28| dna.structures.reserve(end); 128| 11.9k| for (size_t i = 0; i != end; ++i) { ------------------ | Branch (128:24): [True: 11.8k, False: 26] ------------------ 129| | 130| 11.8k| uint16_t n = stream.GetI2(); 131| 11.8k| if (n >= types.size()) { ------------------ | Branch (131:13): [True: 1, False: 11.8k] ------------------ 132| 1| throw DeadlyImportError("BlenderDNA: Invalid type index in structure name", n, " (there are only ", types.size(), " entries)"); 133| 1| } 134| | 135| | // maintain separate indexes 136| 11.8k| dna.indices[types[n].name] = dna.structures.size(); 137| | 138| 11.8k| dna.structures.push_back(Structure()); 139| 11.8k| Structure &s = dna.structures.back(); 140| 11.8k| s.name = types[n].name; 141| | 142| 11.8k| n = stream.GetI2(); 143| 11.8k| s.fields.reserve(n); 144| | 145| 11.8k| size_t offset = 0; 146| 153k| for (size_t m = 0; m < n; ++m, ++fields) { ------------------ | Branch (146:28): [True: 141k, False: 11.8k] ------------------ 147| | 148| 141k| uint16_t j = stream.GetI2(); 149| 141k| if (j >= types.size()) { ------------------ | Branch (149:17): [True: 0, False: 141k] ------------------ 150| 0| throw DeadlyImportError("BlenderDNA: Invalid type index in structure field ", j, " (there are only ", types.size(), " entries)"); 151| 0| } 152| 141k| s.fields.push_back(Field()); 153| 141k| Field &f = s.fields.back(); 154| 141k| f.offset = offset; 155| | 156| 141k| f.type = types[j].name; 157| 141k| f.size = types[j].size; 158| | 159| 141k| j = stream.GetI2(); 160| 141k| if (j >= names.size()) { ------------------ | Branch (160:17): [True: 1, False: 141k] ------------------ 161| 1| throw DeadlyImportError("BlenderDNA: Invalid name index in structure field ", j, " (there are only ", names.size(), " entries)"); 162| 1| } 163| | 164| 141k| f.name = names[j]; 165| 141k| f.flags = 0u; 166| | 167| | // pointers always specify the size of the pointee instead of their own. 168| | // The pointer asterisk remains a property of the lookup name. 169| 141k| if (f.name[0] == '*') { ------------------ | Branch (169:17): [True: 23.9k, False: 117k] ------------------ 170| 23.9k| f.size = db.i64bit ? 8 : 4; ------------------ | Branch (170:26): [True: 15.9k, False: 7.99k] ------------------ 171| 23.9k| f.flags |= FieldFlag_Pointer; 172| 23.9k| } 173| | 174| | // arrays, however, specify the size of a single element so we 175| | // need to parse the (possibly multi-dimensional) array declaration 176| | // in order to obtain the actual size of the array in the file. 177| | // Also we need to alter the lookup name to include no array 178| | // brackets anymore or size fixup won't work (if our size does 179| | // not match the size read from the DNA). 180| 141k| if (*f.name.rbegin() == ']') { ------------------ | Branch (180:17): [True: 19.3k, False: 122k] ------------------ 181| 19.3k| const std::string::size_type rb = f.name.find('['); 182| 19.3k| if (rb == std::string::npos) { ------------------ | Branch (182:21): [True: 0, False: 19.3k] ------------------ 183| 0| throw DeadlyImportError("BlenderDNA: Encountered invalid array declaration ", f.name); 184| 0| } 185| | 186| 19.3k| f.flags |= FieldFlag_Array; 187| 19.3k| DNA::ExtractArraySize(f.name, f.array_sizes); 188| 19.3k| f.name = f.name.substr(0, rb); 189| | 190| 19.3k| f.size *= f.array_sizes[0] * f.array_sizes[1]; 191| 19.3k| } 192| | 193| | // maintain separate indexes 194| 141k| s.indices[f.name] = s.fields.size() - 1; 195| 141k| offset += f.size; 196| 141k| } 197| 11.8k| s.size = offset; 198| 11.8k| } 199| | 200| 28| ASSIMP_LOG_DEBUG("BlenderDNA: Got ", dna.structures.size(), " structures with totally ", fields, " fields"); 201| | 202| |#if ASSIMP_BUILD_BLENDER_DEBUG_DNA 203| | dna.DumpToFile(); 204| |#endif 205| | 206| 26| dna.AddPrimitiveStructures(); 207| 26| dna.RegisterConverters(); 208| 26|} _ZN6Assimp7Blender3DNA16ExtractArraySizeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPm: 244| 19.3k| size_t array_sizes[2]) { 245| 19.3k| array_sizes[0] = array_sizes[1] = 1; 246| 19.3k| std::string::size_type pos = out.find('['); 247| 19.3k| if (pos++ == std::string::npos) { ------------------ | Branch (247:9): [True: 0, False: 19.3k] ------------------ 248| 0| return; 249| 0| } 250| 19.3k| array_sizes[0] = strtoul10(&out[pos]); 251| | 252| 19.3k| pos = out.find('[', pos); 253| 19.3k| if (pos++ == std::string::npos) { ------------------ | Branch (253:9): [True: 18.0k, False: 1.23k] ------------------ 254| 18.0k| return; 255| 18.0k| } 256| 1.23k| array_sizes[1] = strtoul10(&out[pos]); 257| 1.23k|} _ZNK6Assimp7Blender3DNA27GetBlobToStructureConverterERKNS0_9StructureERKNS0_12FileDatabaseE: 278| 116|) const { 279| 116| std::map::const_iterator it = converters.find(structure.name); 280| 116| return it == converters.end() ? FactoryPair() : (*it).second; ------------------ | Branch (280:12): [True: 0, False: 116] ------------------ 281| 116|} _ZN6Assimp7Blender3DNA22AddPrimitiveStructuresEv: 285| 26|void DNA ::AddPrimitiveStructures() { 286| | // NOTE: these are just dummies. Their presence enforces 287| | // Structure::Convert to be called on these 288| | // empty structures. These converters are special 289| | // overloads which scan the name of the structure and 290| | // perform the required data type conversion if one 291| | // of these special names is found in the structure 292| | // in question. 293| | 294| 26| indices["int"] = structures.size(); 295| 26| structures.push_back(Structure()); 296| 26| structures.back().name = "int"; 297| 26| structures.back().size = 4; 298| | 299| 26| indices["short"] = structures.size(); 300| 26| structures.push_back(Structure()); 301| 26| structures.back().name = "short"; 302| 26| structures.back().size = 2; 303| | 304| 26| indices["char"] = structures.size(); 305| 26| structures.push_back(Structure()); 306| 26| structures.back().name = "char"; 307| 26| structures.back().size = 1; 308| | 309| 26| indices["float"] = structures.size(); 310| 26| structures.push_back(Structure()); 311| 26| structures.back().name = "float"; 312| 26| structures.back().size = 4; 313| | 314| 26| indices["double"] = structures.size(); 315| 26| structures.push_back(Structure()); 316| 26| structures.back().name = "double"; 317| 26| structures.back().size = 8; 318| | 319| | // no long, seemingly. 320| 26|} _ZN6Assimp7Blender13SectionParser4NextEv: 323| 21.5k|void SectionParser ::Next() { 324| 21.5k| stream.SetCurrentPos(current.start + current.size); 325| | 326| 21.5k| const char tmp[] = { 327| 21.5k| (char)stream.GetI1(), 328| 21.5k| (char)stream.GetI1(), 329| 21.5k| (char)stream.GetI1(), 330| 21.5k| (char)stream.GetI1() 331| 21.5k| }; 332| 21.5k| current.id = std::string(tmp, tmp[3] ? 4 : tmp[2] ? 3 : tmp[1] ? 2 : 1); ------------------ | Branch (332:35): [True: 20.4k, False: 1.08k] | Branch (332:48): [True: 3, False: 1.07k] | Branch (332:61): [True: 1.07k, False: 9] ------------------ 333| | 334| 21.5k| current.size = stream.GetI4(); 335| 21.5k| current.address.val = ptr64 ? stream.GetU8() : stream.GetU4(); ------------------ | Branch (335:27): [True: 14.6k, False: 6.86k] ------------------ 336| | 337| 21.5k| current.dna_index = stream.GetI4(); 338| 21.5k| current.num = stream.GetI4(); 339| | 340| 21.5k| current.start = stream.GetCurrentPos(); 341| 21.5k| if (stream.GetRemainingSizeToLimit() < current.size) { ------------------ | Branch (341:9): [True: 4, False: 21.5k] ------------------ 342| 4| throw DeadlyImportError("BLEND: invalid size of file block"); 343| 4| } 344| | 345| 21.5k|#ifdef ASSIMP_BUILD_BLENDER_DEBUG 346| 21.5k| ASSIMP_LOG_VERBOSE_DEBUG(current.id); 347| 21.5k|#endif 348| 21.5k|} BlenderDNA.cpp:_ZL6match4RN6Assimp12StreamReaderILb1ELb1EEEPKc: 57| 140|static bool match4(StreamReaderAny &stream, const char *string) { 58| 140| ai_assert(nullptr != string); 59| 140| char tmp[4]; 60| 140| tmp[0] = (stream).GetI1(); 61| 140| tmp[1] = (stream).GetI1(); 62| 140| tmp[2] = (stream).GetI1(); 63| 140| tmp[3] = (stream).GetI1(); 64| 140| return (tmp[0] == string[0] && tmp[1] == string[1] && tmp[2] == string[2] && tmp[3] == string[3]); ------------------ | Branch (64:13): [True: 140, False: 0] | Branch (64:36): [True: 140, False: 0] | Branch (64:59): [True: 140, False: 0] | Branch (64:82): [True: 140, False: 0] ------------------ 65| 140|} _ZN6Assimp7Blender12FileDatabaseC2Ev: 703| 32| _cacheArrays(*this), _cache(*this), next_cache_idx() {} _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEEC2ERKNS0_12FileDatabaseE: 681| 32| explicit ObjectCache(const FileDatabase &) {} _ZN6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEEC2ERKNS0_12FileDatabaseE: 642| 32| explicit ObjectCache(const FileDatabase &db) : db(db) { 643| | // currently there are only ~400 structure records per blend file. 644| | // we read only a small part of them and don't cache objects 645| | // which we don't need, so this should suffice. 646| 32| caches.reserve(64); 647| 32| } _ZN6Assimp7Blender8ElemBaseC2Ev: 104| 112k| dna_type(nullptr) { 105| | // empty 106| 112k| } _ZN6Assimp7Blender8ElemBaseD2Ev: 108| 112k| virtual ~ElemBase() = default; _ZN6Assimp7Blender9DNAParserC2ERNS0_12FileDatabaseE: 753| 32| explicit DNAParser(FileDatabase &db) : db(db) { 754| | // empty 755| 32| } _ZN6Assimp7Blender13SectionParserC2ERNS_12StreamReaderILb1ELb1EEEb: 586| 32| stream(stream), ptr64(ptr64) { 587| 32| current.size = current.start = 0; 588| 32| } _ZNK6Assimp7Blender13SectionParser10GetCurrentEv: 592| 21.5k| const FileBlockHead &GetCurrent() const { 593| 21.5k| return current; 594| 21.5k| } _ZNK6Assimp7Blender9DNAParser6GetDNAEv: 768| 26| const Blender::DNA &GetDNA() const { 769| 26| return db.dna; 770| 26| } _ZNK6Assimp7Blender12FileDatabase5statsEv: 705| 366k| Statistics &stats() const { 706| 366k| return _stats; 707| 366k| } _ZNK6Assimp7Blender13FileBlockHeadltERKS1_: 560| 220k| bool operator<(const FileBlockHead &o) const { 561| 220k| return address.val < o.address.val; 562| 220k| } _ZNK6Assimp7Blender6vectorINSt3__110shared_ptrINS0_8MaterialEEEEcvbEv: 153| 39| operator bool() const { 154| 39| return !empty(); 155| 39| } _ZNK6Assimp7Blender6vectorINS0_6MTFaceEEcvbEv: 153| 46| operator bool() const { 154| 46| return !empty(); 155| 46| } _ZNK6Assimp7Blender6vectorINS0_7MLoopUVEEcvbEv: 153| 40| operator bool() const { 154| 40| return !empty(); 155| 40| } _ZNK6Assimp7Blender6vectorINS0_5TFaceEEcvbEv: 153| 38| operator bool() const { 154| 38| return !empty(); 155| 38| } _ZNK6Assimp7Blender6vectorINS0_4MColEEcvbEv: 153| 40| operator bool() const { 154| 40| return !empty(); 155| 40| } _ZNK6Assimp7Blender6vectorINS0_8MLoopColEEcvbEv: 153| 37| operator bool() const { 154| 37| return !empty(); 155| 37| } _ZN6Assimp7Blender9StructureC2Ev: 216| 12.0k| cache_idx(static_cast(-1)) { 217| | // empty 218| 12.0k| } _ZNK6Assimp7Blender9StructureneERKS1_: 243| 602| inline bool operator!=(const Structure &other) const { 244| 602| return name != other.name; 245| 602| } _ZNK6Assimp7Blender13FileBlockHeadcvRKNS0_7PointerEEv: 565| 10.3k| operator const Pointer &() const { 566| 10.3k| return address; 567| 10.3k| } _ZN6Assimp7BlenderltERKNS0_7PointerES3_: 571| 11.8k|inline bool operator<(const Pointer &a, const Pointer &b) { 572| 11.8k| return a.val < b.val; 573| 11.8k|} _ZNK6Assimp7Blender12FileDatabase5cacheINS0_8ElemBaseEEERNS0_11ObjectCacheINSt3__110shared_ptrEEERNS6_IT_EE: 714| 280| ObjectCache &cache(std::shared_ptr & /*in*/) const { 715| 280| return _cache; 716| 280| } _ZN6Assimp7Blender5ErrorC2IJRA39_KcRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEERA17_S3_SE_RA2_S3_EEEDpOT_: 94| 1.94k| DeadlyImportError(args...) { 95| 1.94k| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi1EEclIfEEvRT_PKc: 395| 289| void operator()(T &out, const char *reason = "") { 396| 289| ASSIMP_LOG_WARN(reason); 397| | 398| | // ... and let the show go on 399| 289| _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); 400| 289| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi0EEclIfEEvRT_PKc: 382| 289| void operator()(T &out, const char * = nullptr) { 383| 289| out = T(); 384| 289| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi1EEclIcEEvRT_PKc: 395| 299k| void operator()(T &out, const char *reason = "") { 396| 299k| ASSIMP_LOG_WARN(reason); 397| | 398| | // ... and let the show go on 399| 299k| _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); 400| 299k| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi0EEclIcEEvRT_PKc: 382| 299k| void operator()(T &out, const char * = nullptr) { 383| 299k| out = T(); 384| 299k| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_6ObjectEEERNS0_11ObjectCacheINSt3__110shared_ptrEEERNS6_IT_EE: 714| 235| ObjectCache &cache(std::shared_ptr & /*in*/) const { 715| 235| return _cache; 716| 235| } _ZNK6Assimp7Blender9Structure9_allocateINS0_6ObjectEEEPT_RNSt3__110shared_ptrIS4_EERm: 349| 100| T *_allocate(std::shared_ptr &out, size_t &s) const { 350| 100| out = std::shared_ptr(new T()); 351| 100| s = 1; 352| 100| return out.get(); 353| 100| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi1EEclINSt3__110shared_ptrINS0_5GroupEEEEEvRT_PKc: 395| 1| void operator()(T &out, const char *reason = "") { 396| 1| ASSIMP_LOG_WARN(reason); 397| | 398| | // ... and let the show go on 399| 1| _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); 400| 1| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi0EEclINSt3__110shared_ptrINS0_5GroupEEEEEvRT_PKc: 382| 1| void operator()(T &out, const char * = nullptr) { 383| 1| out = T(); 384| 1| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi1EEclIiEEvRT_PKc: 395| 1.30k| void operator()(T &out, const char *reason = "") { 396| 1.30k| ASSIMP_LOG_WARN(reason); 397| | 398| | // ... and let the show go on 399| 1.30k| _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); 400| 1.30k| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi0EEclIiEEvRT_PKc: 382| 1.30k| void operator()(T &out, const char * = nullptr) { 383| 1.30k| out = T(); 384| 1.30k| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_16CollectionObjectEEERNS0_11ObjectCacheINSt3__110shared_ptrEEERNS6_IT_EE: 714| 4| ObjectCache &cache(std::shared_ptr & /*in*/) const { 715| 4| return _cache; 716| 4| } _ZNK6Assimp7Blender9Structure9_allocateINS0_16CollectionObjectEEEPT_RNSt3__110shared_ptrIS4_EERm: 349| 2| T *_allocate(std::shared_ptr &out, size_t &s) const { 350| 2| out = std::shared_ptr(new T()); 351| 2| s = 1; 352| 2| return out.get(); 353| 2| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi1EEclINSt3__110shared_ptrINS0_10CollectionEEEEEvRT_PKc: 395| 24| void operator()(T &out, const char *reason = "") { 396| 24| ASSIMP_LOG_WARN(reason); 397| | 398| | // ... and let the show go on 399| 24| _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); 400| 24| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi0EEclINSt3__110shared_ptrINS0_10CollectionEEEEEvRT_PKc: 382| 24| void operator()(T &out, const char * = nullptr) { 383| 24| out = T(); 384| 24| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_10CollectionEEERNS0_11ObjectCacheINSt3__110shared_ptrEEERNS6_IT_EE: 714| 4| ObjectCache &cache(std::shared_ptr & /*in*/) const { 715| 4| return _cache; 716| 4| } _ZNK6Assimp7Blender9Structure9_allocateINS0_10CollectionEEEPT_RNSt3__110shared_ptrIS4_EERm: 349| 2| T *_allocate(std::shared_ptr &out, size_t &s) const { 350| 2| out = std::shared_ptr(new T()); 351| 2| s = 1; 352| 2| return out.get(); 353| 2| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_3TexEEERNS0_11ObjectCacheINSt3__110shared_ptrEEERNS6_IT_EE: 714| 52| ObjectCache &cache(std::shared_ptr & /*in*/) const { 715| 52| return _cache; 716| 52| } _ZNK6Assimp7Blender9Structure9_allocateINS0_3TexEEEPT_RNSt3__110shared_ptrIS4_EERm: 349| 24| T *_allocate(std::shared_ptr &out, size_t &s) const { 350| 24| out = std::shared_ptr(new T()); 351| 24| s = 1; 352| 24| return out.get(); 353| 24| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi1EEclIsEEvRT_PKc: 395| 117| void operator()(T &out, const char *reason = "") { 396| 117| ASSIMP_LOG_WARN(reason); 397| | 398| | // ... and let the show go on 399| 117| _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); 400| 117| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi0EEclIsEEvRT_PKc: 382| 117| void operator()(T &out, const char * = nullptr) { 383| 117| out = T(); 384| 117| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_4BaseEEERNS0_11ObjectCacheINSt3__110shared_ptrEEERNS6_IT_EE: 714| 182| ObjectCache &cache(std::shared_ptr & /*in*/) const { 715| 182| return _cache; 716| 182| } _ZNK6Assimp7Blender9Structure9_allocateINS0_4BaseEEEPT_RNSt3__110shared_ptrIS4_EERm: 349| 88| T *_allocate(std::shared_ptr &out, size_t &s) const { 350| 88| out = std::shared_ptr(new T()); 351| 88| s = 1; 352| 88| return out.get(); 353| 88| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi1EEclIA18_NSt3__110shared_ptrINS0_4MTexEEEEEvRT_PKc: 395| 1| void operator()(T &out, const char *reason = "") { 396| 1| ASSIMP_LOG_WARN(reason); 397| | 398| | // ... and let the show go on 399| 1| _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); 400| 1| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi0EEclINSt3__110shared_ptrINS0_4MTexEEELj18EEEvRAT0__T_PKc: 366| 1| void operator()(T (&out)[N], const char * = nullptr) { 367| 19| for (unsigned int i = 0; i < N; ++i) { ------------------ | Branch (367:38): [True: 18, False: 1] ------------------ 368| 18| out[i] = T(); 369| 18| } 370| 1| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_4MTexEEERNS0_11ObjectCacheINSt3__110shared_ptrEEERNS6_IT_EE: 714| 56| ObjectCache &cache(std::shared_ptr & /*in*/) const { 715| 56| return _cache; 716| 56| } _ZNK6Assimp7Blender9Structure9_allocateINS0_4MTexEEEPT_RNSt3__110shared_ptrIS4_EERm: 349| 28| T *_allocate(std::shared_ptr &out, size_t &s) const { 350| 28| out = std::shared_ptr(new T()); 351| 28| s = 1; 352| 28| return out.get(); 353| 28| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_5ImageEEERNS0_11ObjectCacheINSt3__110shared_ptrEEERNS6_IT_EE: 714| 108| ObjectCache &cache(std::shared_ptr & /*in*/) const { 715| 108| return _cache; 716| 108| } _ZNK6Assimp7Blender9Structure9_allocateINS0_5ImageEEEPT_RNSt3__110shared_ptrIS4_EERm: 349| 8| T *_allocate(std::shared_ptr &out, size_t &s) const { 350| 8| out = std::shared_ptr(new T()); 351| 8| s = 1; 352| 8| return out.get(); 353| 8| } _ZN6Assimp7Blender6vectorINS0_5MFaceEE5resetEv: 149| 42| void reset() { 150| 42| resize(0); 151| 42| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_5MFaceEEERNS0_11ObjectCacheINS0_6vectorEEERNS5_IT_EE: 719| 62| ObjectCache &cache(vector & /*in*/) const { 720| 62| return _cacheArrays; 721| 62| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3getINS0_5MFaceEEEvRKNS0_9StructureERNS2_IT_EERKNS0_7PointerE: 684| 31| void get(const Structure &, vector &, const Pointer &) {} _ZNK6Assimp7Blender6vectorINS0_5MFaceEEcvbEv: 153| 62| operator bool() const { 154| 62| return !empty(); 155| 62| } _ZNK6Assimp7Blender9Structure9_allocateINS0_5MFaceEEEPT_RNS0_6vectorIS4_EERm: 356| 31| T *_allocate(vector &out, size_t &s) const { 357| 31| out.resize(s); 358| 31| return s ? &out.front() : nullptr; ------------------ | Branch (358:16): [True: 31, False: 0] ------------------ 359| 31| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3setINS0_5MFaceEEEvRKNS0_9StructureERKNS2_IT_EERKNS0_7PointerE: 686| 31| void set(const Structure &, const vector &, const Pointer &) {} _ZN6Assimp7Blender6vectorINS0_6MTFaceEE5resetEv: 149| 42| void reset() { 150| 42| resize(0); 151| 42| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_6MTFaceEEERNS0_11ObjectCacheINS0_6vectorEEERNS5_IT_EE: 719| 8| ObjectCache &cache(vector & /*in*/) const { 720| 8| return _cacheArrays; 721| 8| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3getINS0_6MTFaceEEEvRKNS0_9StructureERNS2_IT_EERKNS0_7PointerE: 684| 4| void get(const Structure &, vector &, const Pointer &) {} _ZNK6Assimp7Blender9Structure9_allocateINS0_6MTFaceEEEPT_RNS0_6vectorIS4_EERm: 356| 4| T *_allocate(vector &out, size_t &s) const { 357| 4| out.resize(s); 358| 4| return s ? &out.front() : nullptr; ------------------ | Branch (358:16): [True: 4, False: 0] ------------------ 359| 4| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3setINS0_6MTFaceEEEvRKNS0_9StructureERKNS2_IT_EERKNS0_7PointerE: 686| 4| void set(const Structure &, const vector &, const Pointer &) {} _ZN6Assimp7Blender6vectorINS0_5TFaceEE5resetEv: 149| 42| void reset() { 150| 42| resize(0); 151| 42| } _ZN6Assimp7Blender6vectorINS0_5MVertEE5resetEv: 149| 42| void reset() { 150| 42| resize(0); 151| 42| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_5MVertEEERNS0_11ObjectCacheINS0_6vectorEEERNS5_IT_EE: 719| 84| ObjectCache &cache(vector & /*in*/) const { 720| 84| return _cacheArrays; 721| 84| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3getINS0_5MVertEEEvRKNS0_9StructureERNS2_IT_EERKNS0_7PointerE: 684| 42| void get(const Structure &, vector &, const Pointer &) {} _ZNK6Assimp7Blender6vectorINS0_5MVertEEcvbEv: 153| 84| operator bool() const { 154| 84| return !empty(); 155| 84| } _ZNK6Assimp7Blender9Structure9_allocateINS0_5MVertEEEPT_RNS0_6vectorIS4_EERm: 356| 42| T *_allocate(vector &out, size_t &s) const { 357| 42| out.resize(s); 358| 42| return s ? &out.front() : nullptr; ------------------ | Branch (358:16): [True: 42, False: 0] ------------------ 359| 42| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3setINS0_5MVertEEEvRKNS0_9StructureERKNS2_IT_EERKNS0_7PointerE: 686| 42| void set(const Structure &, const vector &, const Pointer &) {} _ZN6Assimp7Blender6vectorINS0_5MEdgeEE5resetEv: 149| 42| void reset() { 150| 42| resize(0); 151| 42| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_5MEdgeEEERNS0_11ObjectCacheINS0_6vectorEEERNS5_IT_EE: 719| 84| ObjectCache &cache(vector & /*in*/) const { 720| 84| return _cacheArrays; 721| 84| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3getINS0_5MEdgeEEEvRKNS0_9StructureERNS2_IT_EERKNS0_7PointerE: 684| 42| void get(const Structure &, vector &, const Pointer &) {} _ZNK6Assimp7Blender6vectorINS0_5MEdgeEEcvbEv: 153| 84| operator bool() const { 154| 84| return !empty(); 155| 84| } _ZNK6Assimp7Blender9Structure9_allocateINS0_5MEdgeEEEPT_RNS0_6vectorIS4_EERm: 356| 42| T *_allocate(vector &out, size_t &s) const { 357| 42| out.resize(s); 358| 42| return s ? &out.front() : nullptr; ------------------ | Branch (358:16): [True: 42, False: 0] ------------------ 359| 42| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3setINS0_5MEdgeEEEvRKNS0_9StructureERKNS2_IT_EERKNS0_7PointerE: 686| 42| void set(const Structure &, const vector &, const Pointer &) {} _ZN6Assimp7Blender9Structure19_defaultInitializerILi1EEclINS0_6vectorINS0_5MLoopEEEEEvRT_PKc: 395| 30| void operator()(T &out, const char *reason = "") { 396| 30| ASSIMP_LOG_WARN(reason); 397| | 398| | // ... and let the show go on 399| 30| _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); 400| 30| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi0EEclINS0_6vectorINS0_5MLoopEEEEEvRT_PKc: 382| 30| void operator()(T &out, const char * = nullptr) { 383| 30| out = T(); 384| 30| } _ZN6Assimp7Blender6vectorINS0_5MLoopEE5resetEv: 149| 42| void reset() { 150| 42| resize(0); 151| 42| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_5MLoopEEERNS0_11ObjectCacheINS0_6vectorEEERNS5_IT_EE: 719| 22| ObjectCache &cache(vector & /*in*/) const { 720| 22| return _cacheArrays; 721| 22| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3getINS0_5MLoopEEEvRKNS0_9StructureERNS2_IT_EERKNS0_7PointerE: 684| 11| void get(const Structure &, vector &, const Pointer &) {} _ZNK6Assimp7Blender6vectorINS0_5MLoopEEcvbEv: 153| 22| operator bool() const { 154| 22| return !empty(); 155| 22| } _ZNK6Assimp7Blender9Structure9_allocateINS0_5MLoopEEEPT_RNS0_6vectorIS4_EERm: 356| 11| T *_allocate(vector &out, size_t &s) const { 357| 11| out.resize(s); 358| 11| return s ? &out.front() : nullptr; ------------------ | Branch (358:16): [True: 11, False: 0] ------------------ 359| 11| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3setINS0_5MLoopEEEvRKNS0_9StructureERKNS2_IT_EERKNS0_7PointerE: 686| 11| void set(const Structure &, const vector &, const Pointer &) {} _ZN6Assimp7Blender9Structure19_defaultInitializerILi1EEclINS0_6vectorINS0_7MLoopUVEEEEEvRT_PKc: 395| 30| void operator()(T &out, const char *reason = "") { 396| 30| ASSIMP_LOG_WARN(reason); 397| | 398| | // ... and let the show go on 399| 30| _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); 400| 30| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi0EEclINS0_6vectorINS0_7MLoopUVEEEEEvRT_PKc: 382| 30| void operator()(T &out, const char * = nullptr) { 383| 30| out = T(); 384| 30| } _ZN6Assimp7Blender6vectorINS0_7MLoopUVEE5resetEv: 149| 42| void reset() { 150| 42| resize(0); 151| 42| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_7MLoopUVEEERNS0_11ObjectCacheINS0_6vectorEEERNS5_IT_EE: 719| 6| ObjectCache &cache(vector & /*in*/) const { 720| 6| return _cacheArrays; 721| 6| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3getINS0_7MLoopUVEEEvRKNS0_9StructureERNS2_IT_EERKNS0_7PointerE: 684| 3| void get(const Structure &, vector &, const Pointer &) {} _ZNK6Assimp7Blender9Structure9_allocateINS0_7MLoopUVEEEPT_RNS0_6vectorIS4_EERm: 356| 3| T *_allocate(vector &out, size_t &s) const { 357| 3| out.resize(s); 358| 3| return s ? &out.front() : nullptr; ------------------ | Branch (358:16): [True: 3, False: 0] ------------------ 359| 3| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3setINS0_7MLoopUVEEEvRKNS0_9StructureERKNS2_IT_EERKNS0_7PointerE: 686| 3| void set(const Structure &, const vector &, const Pointer &) {} _ZN6Assimp7Blender9Structure19_defaultInitializerILi1EEclINS0_6vectorINS0_8MLoopColEEEEEvRT_PKc: 395| 30| void operator()(T &out, const char *reason = "") { 396| 30| ASSIMP_LOG_WARN(reason); 397| | 398| | // ... and let the show go on 399| 30| _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); 400| 30| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi0EEclINS0_6vectorINS0_8MLoopColEEEEEvRT_PKc: 382| 30| void operator()(T &out, const char * = nullptr) { 383| 30| out = T(); 384| 30| } _ZN6Assimp7Blender6vectorINS0_8MLoopColEE5resetEv: 149| 42| void reset() { 150| 42| resize(0); 151| 42| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi1EEclINS0_6vectorINS0_5MPolyEEEEEvRT_PKc: 395| 30| void operator()(T &out, const char *reason = "") { 396| 30| ASSIMP_LOG_WARN(reason); 397| | 398| | // ... and let the show go on 399| 30| _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); 400| 30| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi0EEclINS0_6vectorINS0_5MPolyEEEEEvRT_PKc: 382| 30| void operator()(T &out, const char * = nullptr) { 383| 30| out = T(); 384| 30| } _ZN6Assimp7Blender6vectorINS0_5MPolyEE5resetEv: 149| 42| void reset() { 150| 42| resize(0); 151| 42| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_5MPolyEEERNS0_11ObjectCacheINS0_6vectorEEERNS5_IT_EE: 719| 22| ObjectCache &cache(vector & /*in*/) const { 720| 22| return _cacheArrays; 721| 22| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3getINS0_5MPolyEEEvRKNS0_9StructureERNS2_IT_EERKNS0_7PointerE: 684| 11| void get(const Structure &, vector &, const Pointer &) {} _ZNK6Assimp7Blender6vectorINS0_5MPolyEEcvbEv: 153| 22| operator bool() const { 154| 22| return !empty(); 155| 22| } _ZNK6Assimp7Blender9Structure9_allocateINS0_5MPolyEEEPT_RNS0_6vectorIS4_EERm: 356| 11| T *_allocate(vector &out, size_t &s) const { 357| 11| out.resize(s); 358| 11| return s ? &out.front() : nullptr; ------------------ | Branch (358:16): [True: 11, False: 0] ------------------ 359| 11| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3setINS0_5MPolyEEEvRKNS0_9StructureERKNS2_IT_EERKNS0_7PointerE: 686| 11| void set(const Structure &, const vector &, const Pointer &) {} _ZN6Assimp7Blender9Structure19_defaultInitializerILi1EEclINS0_6vectorINS0_8MTexPolyEEEEEvRT_PKc: 395| 31| void operator()(T &out, const char *reason = "") { 396| 31| ASSIMP_LOG_WARN(reason); 397| | 398| | // ... and let the show go on 399| 31| _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); 400| 31| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi0EEclINS0_6vectorINS0_8MTexPolyEEEEEvRT_PKc: 382| 31| void operator()(T &out, const char * = nullptr) { 383| 31| out = T(); 384| 31| } _ZN6Assimp7Blender6vectorINS0_8MTexPolyEE5resetEv: 149| 42| void reset() { 150| 42| resize(0); 151| 42| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_8MTexPolyEEERNS0_11ObjectCacheINS0_6vectorEEERNS5_IT_EE: 719| 4| ObjectCache &cache(vector & /*in*/) const { 720| 4| return _cacheArrays; 721| 4| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3getINS0_8MTexPolyEEEvRKNS0_9StructureERNS2_IT_EERKNS0_7PointerE: 684| 2| void get(const Structure &, vector &, const Pointer &) {} _ZNK6Assimp7Blender6vectorINS0_8MTexPolyEEcvbEv: 153| 4| operator bool() const { 154| 4| return !empty(); 155| 4| } _ZNK6Assimp7Blender9Structure9_allocateINS0_8MTexPolyEEEPT_RNS0_6vectorIS4_EERm: 356| 2| T *_allocate(vector &out, size_t &s) const { 357| 2| out.resize(s); 358| 2| return s ? &out.front() : nullptr; ------------------ | Branch (358:16): [True: 2, False: 0] ------------------ 359| 2| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3setINS0_8MTexPolyEEEvRKNS0_9StructureERKNS2_IT_EERKNS0_7PointerE: 686| 2| void set(const Structure &, const vector &, const Pointer &) {} _ZN6Assimp7Blender6vectorINS0_11MDeformVertEE5resetEv: 149| 42| void reset() { 150| 42| resize(0); 151| 42| } _ZN6Assimp7Blender6vectorINS0_4MColEE5resetEv: 149| 42| void reset() { 150| 42| resize(0); 151| 42| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_4MColEEERNS0_11ObjectCacheINS0_6vectorEEERNS5_IT_EE: 719| 2| ObjectCache &cache(vector & /*in*/) const { 720| 2| return _cacheArrays; 721| 2| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3getINS0_4MColEEEvRKNS0_9StructureERNS2_IT_EERKNS0_7PointerE: 684| 1| void get(const Structure &, vector &, const Pointer &) {} _ZNK6Assimp7Blender9Structure9_allocateINS0_4MColEEEPT_RNS0_6vectorIS4_EERm: 356| 1| T *_allocate(vector &out, size_t &s) const { 357| 1| out.resize(s); 358| 1| return s ? &out.front() : nullptr; ------------------ | Branch (358:16): [True: 1, False: 0] ------------------ 359| 1| } _ZN6Assimp7Blender11ObjectCacheINS0_6vectorEE3setINS0_4MColEEEvRKNS0_9StructureERKNS2_IT_EERKNS0_7PointerE: 686| 1| void set(const Structure &, const vector &, const Pointer &) {} _ZN6Assimp7Blender6vectorINSt3__110shared_ptrINS0_8MaterialEEEE5resetEv: 149| 42| void reset() { 150| 42| resize(0); 151| 42| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_8MaterialEEERNS0_11ObjectCacheINSt3__110shared_ptrEEERNS6_IT_EE: 714| 67| ObjectCache &cache(std::shared_ptr & /*in*/) const { 715| 67| return _cache; 716| 67| } _ZNK6Assimp7Blender9Structure9_allocateINS0_8MaterialEEEPT_RNSt3__110shared_ptrIS4_EERm: 349| 28| T *_allocate(std::shared_ptr &out, size_t &s) const { 350| 28| out = std::shared_ptr(new T()); 351| 28| s = 1; 352| 28| return out.get(); 353| 28| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi1EEclINS0_10CustomDataEEEvRT_PKc: 395| 61| void operator()(T &out, const char *reason = "") { 396| 61| ASSIMP_LOG_WARN(reason); 397| | 398| | // ... and let the show go on 399| 61| _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); 400| 61| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi0EEclINS0_10CustomDataEEEvRT_PKc: 382| 61| void operator()(T &out, const char * = nullptr) { 383| 61| out = T(); 384| 61| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_5WorldEEERNS0_11ObjectCacheINSt3__110shared_ptrEEERNS6_IT_EE: 714| 52| ObjectCache &cache(std::shared_ptr & /*in*/) const { 715| 52| return _cache; 716| 52| } _ZNK6Assimp7Blender9Structure9_allocateINS0_5WorldEEEPT_RNSt3__110shared_ptrIS4_EERm: 349| 26| T *_allocate(std::shared_ptr &out, size_t &s) const { 350| 26| out = std::shared_ptr(new T()); 351| 26| s = 1; 352| 26| return out.get(); 353| 26| } _ZNK6Assimp7Blender12FileDatabase5cacheINS0_10PackedFileEEERNS0_11ObjectCacheINSt3__110shared_ptrEEERNS6_IT_EE: 714| 2| ObjectCache &cache(std::shared_ptr & /*in*/) const { 715| 2| return _cache; 716| 2| } _ZNK6Assimp7Blender9Structure9_allocateINS0_10PackedFileEEEPT_RNSt3__110shared_ptrIS4_EERm: 349| 1| T *_allocate(std::shared_ptr &out, size_t &s) const { 350| 1| out = std::shared_ptr(new T()); 351| 1| s = 1; 352| 1| return out.get(); 353| 1| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi1EEclIA42_iEEvRT_PKc: 395| 90| void operator()(T &out, const char *reason = "") { 396| 90| ASSIMP_LOG_WARN(reason); 397| | 398| | // ... and let the show go on 399| 90| _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); 400| 90| } _ZN6Assimp7Blender9Structure19_defaultInitializerILi0EEclIiLj42EEEvRAT0__T_PKc: 366| 90| void operator()(T (&out)[N], const char * = nullptr) { 367| 3.87k| for (unsigned int i = 0; i < N; ++i) { ------------------ | Branch (367:38): [True: 3.78k, False: 90] ------------------ 368| 3.78k| out[i] = T(); 369| 3.78k| } 370| 90| } _ZN6Assimp7Blender5ErrorC2IJRA17_KcRKiRA14_S3_EEEDpOT_: 94| 1| DeadlyImportError(args...) { 95| 1| } _ZNK6Assimp7Blender9StructureixERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 57| 365k|{ 58| 365k| std::map::const_iterator it = indices.find(ss); 59| 365k| if (it == indices.end()) { ------------------ | Branch (59:9): [True: 1.94k, False: 363k] ------------------ 60| 1.94k| throw Error("BlendDNA: Did not find a field named `",ss,"` in structure `",name,"`"); 61| 1.94k| } 62| | 63| 363k| return fields[(*it).second]; 64| 365k|} _ZNK6Assimp7Blender9Structure3GetERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 68| 6|{ 69| 6| std::map::const_iterator it = indices.find(ss); 70| 6| return it == indices.end() ? nullptr : &fields[(*it).second]; ------------------ | Branch (70:12): [True: 0, False: 6] ------------------ 71| 6|} _ZNK6Assimp7Blender9Structure14ResolvePointerERNSt3__110shared_ptrINS0_10FileOffsetEEERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 473| 1|{ 474| | // Currently used exclusively by PackedFile::data to represent 475| | // a simple offset into the mapped BLEND file. 476| 1| out.reset(); 477| 1| if (!ptrval.val) { ------------------ | Branch (477:9): [True: 0, False: 1] ------------------ 478| 0| return false; 479| 0| } 480| | 481| | // find the file block the pointer is pointing to 482| 1| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 483| | 484| 1| out = std::shared_ptr< FileOffset > (new FileOffset()); 485| 1| out->val = block->start+ static_cast((ptrval.val - block->address.val) ); 486| 1| return false; 487| 1|} _ZNK6Assimp7Blender9Structure14ResolvePointerINSt3__110shared_ptrENS0_8ElemBaseEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 535| 368|{ 536| | // Special case when the data type needs to be determined at runtime. 537| | // Less secure than in the `strongly-typed` case. 538| | 539| 368| out.reset(); 540| 368| if (!ptrval.val) { ------------------ | Branch (540:9): [True: 204, False: 164] ------------------ 541| 204| return false; 542| 204| } 543| | 544| | // find the file block the pointer is pointing to 545| 164| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 546| | 547| | // determine the target type from the block header 548| 164| const Structure& s = db.dna[block->dna_index]; 549| | 550| | // try to retrieve the object from the cache 551| 164| db.cache(out).get(s,out,ptrval); 552| 164| if (out) { ------------------ | Branch (552:9): [True: 48, False: 116] ------------------ 553| 48| return true; 554| 48| } 555| | 556| | // seek to this location, but save the previous stream pointer. 557| 116| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 558| 116| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 559| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 560| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 561| | 562| | // continue conversion after allocating the required storage 563| 116| DNA::FactoryPair builders = db.dna.GetBlobToStructureConverter(s,db); 564| 116| if (!builders.first) { ------------------ | Branch (564:9): [True: 0, False: 116] ------------------ 565| | // this might happen if DNA::RegisterConverters hasn't been called so far 566| | // or if the target type is not contained in `our` DNA. 567| 0| out.reset(); 568| 0| ASSIMP_LOG_WARN( "Failed to find a converter for the `",s.name,"` structure" ); 569| 0| return false; 570| 0| } 571| | 572| | // allocate the object hull 573| 116| out = (s.*builders.first)(); 574| | 575| | // cache the object immediately to prevent infinite recursion in a 576| | // circular list with a single element (i.e. a self-referencing element). 577| 116| db.cache(out).set(s,out,ptrval); 578| | 579| | // and do the actual conversion 580| 116| (s.*builders.second)(out,db); 581| 116| db.reader->SetCurrentPos(pold); 582| | 583| | // store a pointer to the name string of the actual type 584| | // in the object itself. This allows the conversion code 585| | // to perform additional type checking. 586| 116| out->dna_type = s.name.c_str(); 587| | 588| | 589| 116|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 590| 116| ++db.stats().pointers_resolved; 591| 116|#endif 592| 116| return false; 593| 116|} _ZNK6Assimp7Blender9Structure25LocateFileBlockForAddressERKNS0_7PointerERKNS0_12FileDatabaseE: 597| 1.09k|{ 598| | // the file blocks appear in list sorted by 599| | // with ascending base addresses so we can run a 600| | // binary search to locate the pointer quickly. 601| | 602| | // NOTE: Blender seems to distinguish between side-by-side 603| | // data (stored in the same data block) and far pointers, 604| | // which are only used for structures starting with an ID. 605| | // We don't need to make this distinction, our algorithm 606| | // works regardless where the data is stored. 607| 1.09k| vector::const_iterator it = std::lower_bound(db.entries.begin(),db.entries.end(),ptrval); 608| 1.09k| if (it == db.entries.end()) { ------------------ | Branch (608:9): [True: 1, False: 1.09k] ------------------ 609| | // this is crucial, pointers may not be invalid. 610| | // this is either a corrupted file or an attempted attack. 611| 1| throw DeadlyImportError("Failure resolving pointer 0x", 612| 1| std::hex,ptrval.val,", no file block falls into this address range"); 613| 1| } 614| 1.09k| if (ptrval.val >= (*it).address.val + (*it).size) { ------------------ | Branch (614:9): [True: 0, False: 1.09k] ------------------ 615| 0| throw DeadlyImportError("Failure resolving pointer 0x", 616| 0| std::hex,ptrval.val,", nearest file block starting at 0x", 617| 0| (*it).address.val," ends at 0x", 618| 0| (*it).address.val + (*it).size); 619| 0| } 620| 1.09k| return &*it; 621| 1.09k|} _ZNK6Assimp7Blender9Structure7ConvertIiEEvRT_RKNS0_12FileDatabaseE: 677| 181k|{ 678| 181k| ConvertDispatcher(dest,*this,db); 679| 181k|} _ZNK6Assimp7Blender9Structure7ConvertIsEEvRT_RKNS0_12FileDatabaseE: 683| 37.2k|{ 684| | // automatic rescaling from short to float and vice versa (seems to be used by normals) 685| 37.2k| if (name == "float") { ------------------ | Branch (685:9): [True: 7, False: 37.2k] ------------------ 686| 7| float f = db.reader->GetF4(); 687| 7| if ( f > 1.0f ) ------------------ | Branch (687:14): [True: 4, False: 3] ------------------ 688| 4| f = 1.0f; 689| 7| dest = static_cast( f * 32767.f); 690| | //db.reader->IncPtr(-4); 691| 7| return; 692| 7| } 693| 37.2k| else if (name == "double") { ------------------ | Branch (693:14): [True: 0, False: 37.2k] ------------------ 694| 0| dest = static_cast(db.reader->GetF8() * 32767.); 695| | //db.reader->IncPtr(-8); 696| 0| return; 697| 0| } 698| 37.2k| ConvertDispatcher(dest,*this,db); 699| 37.2k|} _ZNK6Assimp7Blender9Structure7ConvertIcEEvRT_RKNS0_12FileDatabaseE: 703| 144k|{ 704| | // automatic rescaling from char to float and vice versa (seems useful for RGB colors) 705| 144k| if (name == "float") { ------------------ | Branch (705:9): [True: 0, False: 144k] ------------------ 706| 0| dest = static_cast(db.reader->GetF4() * 255.f); 707| 0| return; 708| 0| } 709| 144k| else if (name == "double") { ------------------ | Branch (709:14): [True: 0, False: 144k] ------------------ 710| 0| dest = static_cast(db.reader->GetF8() * 255.f); 711| 0| return; 712| 0| } 713| 144k| ConvertDispatcher(dest,*this,db); 714| 144k|} _ZNK6Assimp7Blender9Structure7ConvertIfEEvRT_RKNS0_12FileDatabaseE: 734| 115k|{ 735| | // automatic rescaling from char to float and vice versa (seems useful for RGB colors) 736| 115k| if (name == "char") { ------------------ | Branch (736:9): [True: 0, False: 115k] ------------------ 737| 0| dest = db.reader->GetI1() / 255.f; 738| 0| return; 739| 0| } 740| | // automatic rescaling from short to float and vice versa (used by normals) 741| 115k| else if (name == "short") { ------------------ | Branch (741:14): [True: 54.0k, False: 61.0k] ------------------ 742| 54.0k| dest = db.reader->GetI2() / 32767.f; 743| 54.0k| return; 744| 54.0k| } 745| 61.0k| ConvertDispatcher(dest,*this,db); 746| 61.0k|} _ZNK6Assimp7Blender9Structure7ConvertINS0_7PointerEEEvRT_RKNS0_12FileDatabaseE: 764| 3.11k|{ 765| 3.11k| if (db.i64bit) { ------------------ | Branch (765:9): [True: 1.55k, False: 1.56k] ------------------ 766| 1.55k| dest.val = db.reader->GetU8(); 767| | //db.reader->IncPtr(-8); 768| 1.55k| return; 769| 1.55k| } 770| 1.56k| dest.val = db.reader->GetU4(); 771| | //db.reader->IncPtr(-4); 772| 1.56k|} _ZNK6Assimp7Blender3DNAixERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 776| 361k|{ 777| 361k| std::map::const_iterator it = indices.find(ss); 778| 361k| if (it == indices.end()) { ------------------ | Branch (778:9): [True: 0, False: 361k] ------------------ 779| 0| throw Error("BlendDNA: Did not find a structure named `",ss,"`"); 780| 0| } 781| | 782| 361k| return structures[(*it).second]; 783| 361k|} _ZNK6Assimp7Blender3DNA3GetERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 787| 12|{ 788| 12| std::map::const_iterator it = indices.find(ss); 789| 12| return it == indices.end() ? nullptr : &structures[(*it).second]; ------------------ | Branch (789:12): [True: 0, False: 12] ------------------ 790| 12|} _ZNK6Assimp7Blender3DNAixEm: 794| 766|{ 795| 766| if (i >= structures.size()) { ------------------ | Branch (795:9): [True: 0, False: 766] ------------------ 796| 0| throw Error("BlendDNA: There is no structure with index `",i,"`"); 797| 0| } 798| | 799| 766| return structures[i]; 800| 766|} _ZNK6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3getINS0_8ElemBaseEEEvRKNS0_9StructureERNS3_IT_EERKNS0_7PointerE: 807| 164|) const { 808| | 809| 164| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (809:8): [True: 87, False: 77] ------------------ 810| 87| s.cache_idx = db.next_cache_idx++; 811| 87| caches.resize(db.next_cache_idx); 812| 87| return; 813| 87| } 814| | 815| 77| typename StructureCache::const_iterator it = caches[s.cache_idx].find(ptr); 816| 77| if (it != caches[s.cache_idx].end()) { ------------------ | Branch (816:9): [True: 48, False: 29] ------------------ 817| 48| out = std::static_pointer_cast( (*it).second ); 818| | 819| 48|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 820| 48| ++db.stats().cache_hits; 821| 48|#endif 822| 48| } 823| | // otherwise, out remains untouched 824| 77|} _ZN6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3setINS0_8ElemBaseEEEvRKNS0_9StructureERKNS3_IT_EERKNS0_7PointerE: 832| 116|) { 833| 116| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (833:8): [True: 0, False: 116] ------------------ 834| 0| s.cache_idx = db.next_cache_idx++; 835| 0| caches.resize(db.next_cache_idx); 836| 0| } 837| 116| caches[s.cache_idx][ptr] = std::static_pointer_cast( out ); 838| | 839| 116|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 840| 116| ++db.stats().cached_objects; 841| 116|#endif 842| 116|} _ZN6Assimp7Blender17ConvertDispatcherIiEEvRT_RKNS0_9StructureERKNS0_12FileDatabaseE: 654| 181k|{ 655| 181k| if (in.name == "int") { ------------------ | Branch (655:9): [True: 148k, False: 33.4k] ------------------ 656| 148k| out = static_cast_silent()(db.reader->GetU4()); 657| 148k| } 658| 33.4k| else if (in.name == "short") { ------------------ | Branch (658:14): [True: 7.77k, False: 25.6k] ------------------ 659| 7.77k| out = static_cast_silent()(db.reader->GetU2()); 660| 7.77k| } 661| 25.6k| else if (in.name == "char") { ------------------ | Branch (661:14): [True: 25.6k, False: 0] ------------------ 662| 25.6k| out = static_cast_silent()(db.reader->GetU1()); 663| 25.6k| } 664| 0| else if (in.name == "float") { ------------------ | Branch (664:14): [True: 0, False: 0] ------------------ 665| 0| out = static_cast(db.reader->GetF4()); 666| 0| } 667| 0| else if (in.name == "double") { ------------------ | Branch (667:14): [True: 0, False: 0] ------------------ 668| 0| out = static_cast(db.reader->GetF8()); 669| 0| } 670| 0| else { 671| 0| throw DeadlyImportError("Unknown source for conversion to primitive data type: ", in.name); 672| 0| } 673| 181k|} _ZN6Assimp7Blender18static_cast_silentIiEclIjEEiT_: 635| 148k| T operator()(V in) { 636| 148k| return static_cast(in & static_cast::type>(-1)); 637| 148k| } _ZN6Assimp7Blender18static_cast_silentIiEclItEEiT_: 635| 7.77k| T operator()(V in) { 636| 7.77k| return static_cast(in & static_cast::type>(-1)); 637| 7.77k| } _ZN6Assimp7Blender18static_cast_silentIiEclIhEEiT_: 635| 25.6k| T operator()(V in) { 636| 25.6k| return static_cast(in & static_cast::type>(-1)); 637| 25.6k| } _ZN6Assimp7Blender17ConvertDispatcherIsEEvRT_RKNS0_9StructureERKNS0_12FileDatabaseE: 654| 37.2k|{ 655| 37.2k| if (in.name == "int") { ------------------ | Branch (655:9): [True: 14, False: 37.2k] ------------------ 656| 14| out = static_cast_silent()(db.reader->GetU4()); 657| 14| } 658| 37.2k| else if (in.name == "short") { ------------------ | Branch (658:14): [True: 37.2k, False: 46] ------------------ 659| 37.2k| out = static_cast_silent()(db.reader->GetU2()); 660| 37.2k| } 661| 46| else if (in.name == "char") { ------------------ | Branch (661:14): [True: 46, False: 0] ------------------ 662| 46| out = static_cast_silent()(db.reader->GetU1()); 663| 46| } 664| 0| else if (in.name == "float") { ------------------ | Branch (664:14): [True: 0, False: 0] ------------------ 665| 0| out = static_cast(db.reader->GetF4()); 666| 0| } 667| 0| else if (in.name == "double") { ------------------ | Branch (667:14): [True: 0, False: 0] ------------------ 668| 0| out = static_cast(db.reader->GetF8()); 669| 0| } 670| 0| else { 671| 0| throw DeadlyImportError("Unknown source for conversion to primitive data type: ", in.name); 672| 0| } 673| 37.2k|} _ZN6Assimp7Blender18static_cast_silentIsEclIjEEsT_: 635| 14| T operator()(V in) { 636| 14| return static_cast(in & static_cast::type>(-1)); 637| 14| } _ZN6Assimp7Blender18static_cast_silentIsEclItEEsT_: 635| 37.2k| T operator()(V in) { 636| 37.2k| return static_cast(in & static_cast::type>(-1)); 637| 37.2k| } _ZN6Assimp7Blender18static_cast_silentIsEclIhEEsT_: 635| 46| T operator()(V in) { 636| 46| return static_cast(in & static_cast::type>(-1)); 637| 46| } _ZN6Assimp7Blender17ConvertDispatcherIcEEvRT_RKNS0_9StructureERKNS0_12FileDatabaseE: 654| 144k|{ 655| 144k| if (in.name == "int") { ------------------ | Branch (655:9): [True: 0, False: 144k] ------------------ 656| 0| out = static_cast_silent()(db.reader->GetU4()); 657| 0| } 658| 144k| else if (in.name == "short") { ------------------ | Branch (658:14): [True: 0, False: 144k] ------------------ 659| 0| out = static_cast_silent()(db.reader->GetU2()); 660| 0| } 661| 144k| else if (in.name == "char") { ------------------ | Branch (661:14): [True: 144k, False: 0] ------------------ 662| 144k| out = static_cast_silent()(db.reader->GetU1()); 663| 144k| } 664| 0| else if (in.name == "float") { ------------------ | Branch (664:14): [True: 0, False: 0] ------------------ 665| 0| out = static_cast(db.reader->GetF4()); 666| 0| } 667| 0| else if (in.name == "double") { ------------------ | Branch (667:14): [True: 0, False: 0] ------------------ 668| 0| out = static_cast(db.reader->GetF8()); 669| 0| } 670| 0| else { 671| 0| throw DeadlyImportError("Unknown source for conversion to primitive data type: ", in.name); 672| 0| } 673| 144k|} _ZN6Assimp7Blender18static_cast_silentIcEclIhEEcT_: 635| 144k| T operator()(V in) { 636| 144k| return static_cast(in & static_cast::type>(-1)); 637| 144k| } _ZN6Assimp7Blender17ConvertDispatcherIfEEvRT_RKNS0_9StructureERKNS0_12FileDatabaseE: 654| 61.0k|{ 655| 61.0k| if (in.name == "int") { ------------------ | Branch (655:9): [True: 0, False: 61.0k] ------------------ 656| 0| out = static_cast_silent()(db.reader->GetU4()); 657| 0| } 658| 61.0k| else if (in.name == "short") { ------------------ | Branch (658:14): [True: 0, False: 61.0k] ------------------ 659| 0| out = static_cast_silent()(db.reader->GetU2()); 660| 0| } 661| 61.0k| else if (in.name == "char") { ------------------ | Branch (661:14): [True: 0, False: 61.0k] ------------------ 662| 0| out = static_cast_silent()(db.reader->GetU1()); 663| 0| } 664| 61.0k| else if (in.name == "float") { ------------------ | Branch (664:14): [True: 61.0k, False: 0] ------------------ 665| 61.0k| out = static_cast(db.reader->GetF4()); 666| 61.0k| } 667| 0| else if (in.name == "double") { ------------------ | Branch (667:14): [True: 0, False: 0] ------------------ 668| 0| out = static_cast(db.reader->GetF8()); 669| 0| } 670| 0| else { 671| 0| throw DeadlyImportError("Unknown source for conversion to primitive data type: ", in.name); 672| 0| } 673| 61.0k|} _ZNK6Assimp7Blender9Structure9ReadFieldILi2ENS0_2IDEEEvRT0_PKcRKNS0_12FileDatabaseE: 282| 290|{ 283| 290| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 284| 290| try { 285| 290| const Field& f = (*this)[name]; 286| | // find the structure definition pertaining to this field 287| 290| const Structure& s = db.dna[f.type]; 288| | 289| 290| db.reader->IncPtr(f.offset); 290| 290| s.Convert(out,db); 291| 290| } 292| 290| catch (const Error& e) { 293| 0| _defaultInitializer()(out,e.what()); 294| 0| } 295| | 296| | // and recover the previous stream position 297| 290| db.reader->SetCurrentPos(old); 298| | 299| 290|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 300| 290| ++db.stats().fields_read; 301| 290|#endif 302| 290|} _ZNK6Assimp7Blender9Structure9ReadFieldILi2EiEEvRT0_PKcRKNS0_12FileDatabaseE: 282| 146k|{ 283| 146k| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 284| 146k| try { 285| 146k| const Field& f = (*this)[name]; 286| | // find the structure definition pertaining to this field 287| 146k| const Structure& s = db.dna[f.type]; 288| | 289| 146k| db.reader->IncPtr(f.offset); 290| 146k| s.Convert(out,db); 291| 146k| } 292| 146k| catch (const Error& e) { 293| 0| _defaultInitializer()(out,e.what()); 294| 0| } 295| | 296| | // and recover the previous stream position 297| 146k| db.reader->SetCurrentPos(old); 298| | 299| 146k|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 300| 146k| ++db.stats().fields_read; 301| 146k|#endif 302| 146k|} _ZNK6Assimp7Blender9Structure15ReadFieldArray2ILi1EfLm4ELm4EEEvRAT1__AT2__T0_PKcRKNS0_12FileDatabaseE: 137| 200|{ 138| 200| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 139| 200| try { 140| 200| const Field& f = (*this)[name]; 141| 200| const Structure& s = db.dna[f.type]; 142| | 143| | // is the input actually an array? 144| 200| if (!(f.flags & FieldFlag_Array)) { ------------------ | Branch (144:13): [True: 0, False: 200] ------------------ 145| 0| throw Error("Field `",name,"` of structure `", 146| 0| this->name,"` ought to be an array of size ",M,"*",N 147| 0| ); 148| 0| } 149| | 150| 200| db.reader->IncPtr(f.offset); 151| | 152| | // size conversions are always allowed, regardless of error_policy 153| 200| unsigned int i = 0; 154| 1.00k| for(; i < std::min(f.array_sizes[0],M); ++i) { ------------------ | Branch (154:15): [True: 800, False: 200] ------------------ 155| 800| unsigned int j = 0; 156| 4.00k| for(; j < std::min(f.array_sizes[1],N); ++j) { ------------------ | Branch (156:19): [True: 3.20k, False: 800] ------------------ 157| 3.20k| s.Convert(out[i][j],db); 158| 3.20k| } 159| 800| for(; j < N; ++j) { ------------------ | Branch (159:19): [True: 0, False: 800] ------------------ 160| 0| _defaultInitializer()(out[i][j]); 161| 0| } 162| 800| } 163| 200| for(; i < M; ++i) { ------------------ | Branch (163:15): [True: 0, False: 200] ------------------ 164| 0| _defaultInitializer()(out[i]); 165| 0| } 166| 200| } 167| 200| catch (const Error& e) { 168| 0| _defaultInitializer()(out,e.what()); 169| 0| } 170| | 171| | // and recover the previous stream position 172| 200| db.reader->SetCurrentPos(old); 173| | 174| 200|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 175| 200| ++db.stats().fields_read; 176| 200|#endif 177| 200|} _ZNK6Assimp7Blender9Structure14ReadFieldArrayILi1EcLm32EEEvRAT1__T0_PKcRKNS0_12FileDatabaseE: 100| 134|{ 101| 134| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 102| 134| try { 103| 134| const Field& f = (*this)[name]; 104| 134| const Structure& s = db.dna[f.type]; 105| | 106| | // is the input actually an array? 107| 134| if (!(f.flags & FieldFlag_Array)) { ------------------ | Branch (107:13): [True: 0, False: 134] ------------------ 108| 0| throw Error("Field `",name,"` of structure `",this->name,"` ought to be an array of size ",M); 109| 0| } 110| | 111| 134| db.reader->IncPtr(f.offset); 112| | 113| | // size conversions are always allowed, regardless of error_policy 114| 134| unsigned int i = 0; 115| 4.42k| for(; i < std::min(f.array_sizes[0],M); ++i) { ------------------ | Branch (115:15): [True: 4.28k, False: 134] ------------------ 116| 4.28k| s.Convert(out[i],db); 117| 4.28k| } 118| 134| for(; i < M; ++i) { ------------------ | Branch (118:15): [True: 0, False: 134] ------------------ 119| 0| _defaultInitializer()(out[i]); 120| 0| } 121| 134| } 122| 134| catch (const Error& e) { 123| 0| _defaultInitializer()(out,e.what()); 124| 0| } 125| | 126| | // and recover the previous stream position 127| 134| db.reader->SetCurrentPos(old); 128| | 129| 134|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 130| 134| ++db.stats().fields_read; 131| 134|#endif 132| 134|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENSt3__110shared_ptrENS0_6ObjectEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 655|{ 184| 655| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 655| Pointer ptrval; 186| 655| const Field* f; 187| 655| try { 188| 655| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 655| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 655] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 655| db.reader->IncPtr(f->offset); 197| 655| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 655| } 201| 655| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 655| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 655| if(!non_recursive) { ------------------ | Branch (211:8): [True: 654, False: 1] ------------------ 212| | // and recover the previous stream position 213| 654| db.reader->SetCurrentPos(old); 214| 654| } 215| | 216| 655|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 655| ++db.stats().fields_read; 218| 655|#endif 219| | 220| 655| return res; 221| 655|} _ZNK6Assimp7Blender9Structure14ResolvePointerINSt3__110shared_ptrENS0_6ObjectEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 655|{ 413| 655| out.reset(); // ensure null pointers work 414| 655| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 520, False: 135] ------------------ 415| 520| return false; 416| 520| } 417| 135| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 135| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 135| const Structure& ss = db.dna[block->dna_index]; 424| 135| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 135] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 135| db.cache(out).get(s,out,ptrval); 432| 135| if (out) { ------------------ | Branch (432:9): [True: 35, False: 100] ------------------ 433| 35| return true; 434| 35| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 100| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 100| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 100| size_t num = block->size / ss.size; 444| 100| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 100| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 100| if (!non_recursive) { ------------------ | Branch (451:9): [True: 100, False: 0] ------------------ 452| 200| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 100, False: 100] ------------------ 453| 100| s.Convert(*o,db); 454| 100| } 455| | 456| 100| db.reader->SetCurrentPos(pold); 457| 100| } 458| | 459| 100|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 100| if(out) { ------------------ | Branch (460:8): [True: 99, False: 1] ------------------ 461| 99| ++db.stats().pointers_resolved; 462| 99| } 463| 100|#endif 464| 100| return false; 465| 135|} _ZNK6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3getINS0_6ObjectEEEvRKNS0_9StructureERNS3_IT_EERKNS0_7PointerE: 807| 135|) const { 808| | 809| 135| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (809:8): [True: 26, False: 109] ------------------ 810| 26| s.cache_idx = db.next_cache_idx++; 811| 26| caches.resize(db.next_cache_idx); 812| 26| return; 813| 26| } 814| | 815| 109| typename StructureCache::const_iterator it = caches[s.cache_idx].find(ptr); 816| 109| if (it != caches[s.cache_idx].end()) { ------------------ | Branch (816:9): [True: 35, False: 74] ------------------ 817| 35| out = std::static_pointer_cast( (*it).second ); 818| | 819| 35|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 820| 35| ++db.stats().cache_hits; 821| 35|#endif 822| 35| } 823| | // otherwise, out remains untouched 824| 109|} _ZN6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3setINS0_6ObjectEEEvRKNS0_9StructureERKNS3_IT_EERKNS0_7PointerE: 832| 100|) { 833| 100| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (833:8): [True: 0, False: 100] ------------------ 834| 0| s.cache_idx = db.next_cache_idx++; 835| 0| caches.resize(db.next_cache_idx); 836| 0| } 837| 100| caches[s.cache_idx][ptr] = std::static_pointer_cast( out ); 838| | 839| 100|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 840| 100| ++db.stats().cached_objects; 841| 100|#endif 842| 100|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENSt3__110shared_ptrENS0_5GroupEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 128|{ 184| 128| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 128| Pointer ptrval; 186| 128| const Field* f; 187| 128| try { 188| 128| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 128| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 128] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 128| db.reader->IncPtr(f->offset); 197| 128| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 128| } 201| 128| catch (const Error& e) { 202| 1| _defaultInitializer()(out,e.what()); 203| | 204| 1| out.reset(); 205| 1| return false; 206| 1| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 127| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 127| if(!non_recursive) { ------------------ | Branch (211:8): [True: 127, False: 0] ------------------ 212| | // and recover the previous stream position 213| 127| db.reader->SetCurrentPos(old); 214| 127| } 215| | 216| 127|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 127| ++db.stats().fields_read; 218| 127|#endif 219| | 220| 127| return res; 221| 128|} _ZNK6Assimp7Blender9Structure14ResolvePointerINSt3__110shared_ptrENS0_5GroupEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 127|{ 413| 127| out.reset(); // ensure null pointers work 414| 127| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 127, False: 0] ------------------ 415| 127| return false; 416| 127| } 417| 0| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 0| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 0| const Structure& ss = db.dna[block->dna_index]; 424| 0| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 0] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 0| db.cache(out).get(s,out,ptrval); 432| 0| if (out) { ------------------ | Branch (432:9): [True: 0, False: 0] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 0| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 0| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 0| size_t num = block->size / ss.size; 444| 0| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 0| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 0| if (!non_recursive) { ------------------ | Branch (451:9): [True: 0, False: 0] ------------------ 452| 0| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 0, False: 0] ------------------ 453| 0| s.Convert(*o,db); 454| 0| } 455| | 456| 0| db.reader->SetCurrentPos(pold); 457| 0| } 458| | 459| 0|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 0| if(out) { ------------------ | Branch (460:8): [True: 0, False: 0] ------------------ 461| 0| ++db.stats().pointers_resolved; 462| 0| } 463| 0|#endif 464| 0| return false; 465| 0|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi2ENSt3__110shared_ptrENS0_8ElemBaseEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 100|{ 184| 100| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 100| Pointer ptrval; 186| 100| const Field* f; 187| 100| try { 188| 100| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 100| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 100] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 100| db.reader->IncPtr(f->offset); 197| 100| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 100| } 201| 100| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 100| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 100| if(!non_recursive) { ------------------ | Branch (211:8): [True: 99, False: 1] ------------------ 212| | // and recover the previous stream position 213| 99| db.reader->SetCurrentPos(old); 214| 99| } 215| | 216| 100|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 100| ++db.stats().fields_read; 218| 100|#endif 219| | 220| 100| return res; 221| 100|} _ZNK6Assimp7Blender9Structure9ReadFieldILi1ENS0_8ListBaseEEEvRT0_PKcRKNS0_12FileDatabaseE: 282| 124|{ 283| 124| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 284| 124| try { 285| 124| const Field& f = (*this)[name]; 286| | // find the structure definition pertaining to this field 287| 124| const Structure& s = db.dna[f.type]; 288| | 289| 124| db.reader->IncPtr(f.offset); 290| 124| s.Convert(out,db); 291| 124| } 292| 124| catch (const Error& e) { 293| 0| _defaultInitializer()(out,e.what()); 294| 0| } 295| | 296| | // and recover the previous stream position 297| 124| db.reader->SetCurrentPos(old); 298| | 299| 124|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 300| 124| ++db.stats().fields_read; 301| 124|#endif 302| 124|} _ZNK6Assimp7Blender9Structure9ReadFieldILi1EiEEvRT0_PKcRKNS0_12FileDatabaseE: 282| 34.3k|{ 283| 34.3k| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 284| 34.3k| try { 285| 34.3k| const Field& f = (*this)[name]; 286| | // find the structure definition pertaining to this field 287| 34.3k| const Structure& s = db.dna[f.type]; 288| | 289| 34.3k| db.reader->IncPtr(f.offset); 290| 34.3k| s.Convert(out,db); 291| 34.3k| } 292| 34.3k| catch (const Error& e) { 293| 1.21k| _defaultInitializer()(out,e.what()); 294| 1.21k| } 295| | 296| | // and recover the previous stream position 297| 34.3k| db.reader->SetCurrentPos(old); 298| | 299| 34.3k|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 300| 34.3k| ++db.stats().fields_read; 301| 34.3k|#endif 302| 34.3k|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi2ENSt3__110shared_ptrENS0_16CollectionObjectEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 3|{ 184| 3| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 3| Pointer ptrval; 186| 3| const Field* f; 187| 3| try { 188| 3| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 3| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 3] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 3| db.reader->IncPtr(f->offset); 197| 3| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 3| } 201| 3| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 3| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 3| if(!non_recursive) { ------------------ | Branch (211:8): [True: 3, False: 0] ------------------ 212| | // and recover the previous stream position 213| 3| db.reader->SetCurrentPos(old); 214| 3| } 215| | 216| 3|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 3| ++db.stats().fields_read; 218| 3|#endif 219| | 220| 3| return res; 221| 3|} _ZNK6Assimp7Blender9Structure14ResolvePointerINSt3__110shared_ptrENS0_16CollectionObjectEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 3|{ 413| 3| out.reset(); // ensure null pointers work 414| 3| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 1, False: 2] ------------------ 415| 1| return false; 416| 1| } 417| 2| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 2| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 2| const Structure& ss = db.dna[block->dna_index]; 424| 2| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 2] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 2| db.cache(out).get(s,out,ptrval); 432| 2| if (out) { ------------------ | Branch (432:9): [True: 0, False: 2] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 2| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 2| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 2| size_t num = block->size / ss.size; 444| 2| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 2| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 2| if (!non_recursive) { ------------------ | Branch (451:9): [True: 2, False: 0] ------------------ 452| 4| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 2, False: 2] ------------------ 453| 2| s.Convert(*o,db); 454| 2| } 455| | 456| 2| db.reader->SetCurrentPos(pold); 457| 2| } 458| | 459| 2|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 2| if(out) { ------------------ | Branch (460:8): [True: 2, False: 0] ------------------ 461| 2| ++db.stats().pointers_resolved; 462| 2| } 463| 2|#endif 464| 2| return false; 465| 2|} _ZNK6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3getINS0_16CollectionObjectEEEvRKNS0_9StructureERNS3_IT_EERKNS0_7PointerE: 807| 2|) const { 808| | 809| 2| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (809:8): [True: 0, False: 2] ------------------ 810| 0| s.cache_idx = db.next_cache_idx++; 811| 0| caches.resize(db.next_cache_idx); 812| 0| return; 813| 0| } 814| | 815| 2| typename StructureCache::const_iterator it = caches[s.cache_idx].find(ptr); 816| 2| if (it != caches[s.cache_idx].end()) { ------------------ | Branch (816:9): [True: 0, False: 2] ------------------ 817| 0| out = std::static_pointer_cast( (*it).second ); 818| | 819| 0|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 820| 0| ++db.stats().cache_hits; 821| 0|#endif 822| 0| } 823| | // otherwise, out remains untouched 824| 2|} _ZN6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3setINS0_16CollectionObjectEEEvRKNS0_9StructureERKNS3_IT_EERKNS0_7PointerE: 832| 2|) { 833| 2| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (833:8): [True: 0, False: 2] ------------------ 834| 0| s.cache_idx = db.next_cache_idx++; 835| 0| caches.resize(db.next_cache_idx); 836| 0| } 837| 2| caches[s.cache_idx][ptr] = std::static_pointer_cast( out ); 838| | 839| 2|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 840| 2| ++db.stats().cached_objects; 841| 2|#endif 842| 2|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi2ENSt3__110shared_ptrENS0_15CollectionChildEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 2|{ 184| 2| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 2| Pointer ptrval; 186| 2| const Field* f; 187| 2| try { 188| 2| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 2| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 2] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 2| db.reader->IncPtr(f->offset); 197| 2| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 2| } 201| 2| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 2| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 2| if(!non_recursive) { ------------------ | Branch (211:8): [True: 2, False: 0] ------------------ 212| | // and recover the previous stream position 213| 2| db.reader->SetCurrentPos(old); 214| 2| } 215| | 216| 2|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 2| ++db.stats().fields_read; 218| 2|#endif 219| | 220| 2| return res; 221| 2|} _ZNK6Assimp7Blender9Structure14ResolvePointerINSt3__110shared_ptrENS0_15CollectionChildEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 2|{ 413| 2| out.reset(); // ensure null pointers work 414| 2| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 2, False: 0] ------------------ 415| 2| return false; 416| 2| } 417| 0| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 0| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 0| const Structure& ss = db.dna[block->dna_index]; 424| 0| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 0] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 0| db.cache(out).get(s,out,ptrval); 432| 0| if (out) { ------------------ | Branch (432:9): [True: 0, False: 0] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 0| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 0| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 0| size_t num = block->size / ss.size; 444| 0| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 0| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 0| if (!non_recursive) { ------------------ | Branch (451:9): [True: 0, False: 0] ------------------ 452| 0| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 0, False: 0] ------------------ 453| 0| s.Convert(*o,db); 454| 0| } 455| | 456| 0| db.reader->SetCurrentPos(pold); 457| 0| } 458| | 459| 0|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 0| if(out) { ------------------ | Branch (460:8): [True: 0, False: 0] ------------------ 461| 0| ++db.stats().pointers_resolved; 462| 0| } 463| 0|#endif 464| 0| return false; 465| 0|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENSt3__110shared_ptrENS0_10CollectionEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 26|{ 184| 26| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 26| Pointer ptrval; 186| 26| const Field* f; 187| 26| try { 188| 26| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 26| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 26] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 26| db.reader->IncPtr(f->offset); 197| 26| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 26| } 201| 26| catch (const Error& e) { 202| 24| _defaultInitializer()(out,e.what()); 203| | 204| 24| out.reset(); 205| 24| return false; 206| 24| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 2| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 2| if(!non_recursive) { ------------------ | Branch (211:8): [True: 2, False: 0] ------------------ 212| | // and recover the previous stream position 213| 2| db.reader->SetCurrentPos(old); 214| 2| } 215| | 216| 2|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 2| ++db.stats().fields_read; 218| 2|#endif 219| | 220| 2| return res; 221| 26|} _ZNK6Assimp7Blender9Structure14ResolvePointerINSt3__110shared_ptrENS0_10CollectionEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 2|{ 413| 2| out.reset(); // ensure null pointers work 414| 2| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 0, False: 2] ------------------ 415| 0| return false; 416| 0| } 417| 2| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 2| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 2| const Structure& ss = db.dna[block->dna_index]; 424| 2| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 2] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 2| db.cache(out).get(s,out,ptrval); 432| 2| if (out) { ------------------ | Branch (432:9): [True: 0, False: 2] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 2| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 2| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 2| size_t num = block->size / ss.size; 444| 2| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 2| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 2| if (!non_recursive) { ------------------ | Branch (451:9): [True: 2, False: 0] ------------------ 452| 4| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 2, False: 2] ------------------ 453| 2| s.Convert(*o,db); 454| 2| } 455| | 456| 2| db.reader->SetCurrentPos(pold); 457| 2| } 458| | 459| 2|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 2| if(out) { ------------------ | Branch (460:8): [True: 2, False: 0] ------------------ 461| 2| ++db.stats().pointers_resolved; 462| 2| } 463| 2|#endif 464| 2| return false; 465| 2|} _ZNK6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3getINS0_10CollectionEEEvRKNS0_9StructureERNS3_IT_EERKNS0_7PointerE: 807| 2|) const { 808| | 809| 2| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (809:8): [True: 1, False: 1] ------------------ 810| 1| s.cache_idx = db.next_cache_idx++; 811| 1| caches.resize(db.next_cache_idx); 812| 1| return; 813| 1| } 814| | 815| 1| typename StructureCache::const_iterator it = caches[s.cache_idx].find(ptr); 816| 1| if (it != caches[s.cache_idx].end()) { ------------------ | Branch (816:9): [True: 0, False: 1] ------------------ 817| 0| out = std::static_pointer_cast( (*it).second ); 818| | 819| 0|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 820| 0| ++db.stats().cache_hits; 821| 0|#endif 822| 0| } 823| | // otherwise, out remains untouched 824| 1|} _ZN6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3setINS0_10CollectionEEEvRKNS0_9StructureERKNS3_IT_EERKNS0_7PointerE: 832| 2|) { 833| 2| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (833:8): [True: 0, False: 2] ------------------ 834| 0| s.cache_idx = db.next_cache_idx++; 835| 0| caches.resize(db.next_cache_idx); 836| 0| } 837| 2| caches[s.cache_idx][ptr] = std::static_pointer_cast( out ); 838| | 839| 2|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 840| 2| ++db.stats().cached_objects; 841| 2|#endif 842| 2|} _ZNK6Assimp7Blender9Structure9ReadFieldILi2ENS0_8ListBaseEEEvRT0_PKcRKNS0_12FileDatabaseE: 282| 4|{ 283| 4| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 284| 4| try { 285| 4| const Field& f = (*this)[name]; 286| | // find the structure definition pertaining to this field 287| 4| const Structure& s = db.dna[f.type]; 288| | 289| 4| db.reader->IncPtr(f.offset); 290| 4| s.Convert(out,db); 291| 4| } 292| 4| catch (const Error& e) { 293| 0| _defaultInitializer()(out,e.what()); 294| 0| } 295| | 296| | // and recover the previous stream position 297| 4| db.reader->SetCurrentPos(old); 298| | 299| 4|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 300| 4| ++db.stats().fields_read; 301| 4|#endif 302| 4|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENSt3__110shared_ptrENS0_3TexEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 28|{ 184| 28| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 28| Pointer ptrval; 186| 28| const Field* f; 187| 28| try { 188| 28| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 28| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 28] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 28| db.reader->IncPtr(f->offset); 197| 28| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 28| } 201| 28| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 28| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 28| if(!non_recursive) { ------------------ | Branch (211:8): [True: 28, False: 0] ------------------ 212| | // and recover the previous stream position 213| 28| db.reader->SetCurrentPos(old); 214| 28| } 215| | 216| 28|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 28| ++db.stats().fields_read; 218| 28|#endif 219| | 220| 28| return res; 221| 28|} _ZNK6Assimp7Blender9Structure14ResolvePointerINSt3__110shared_ptrENS0_3TexEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 28|{ 413| 28| out.reset(); // ensure null pointers work 414| 28| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 0, False: 28] ------------------ 415| 0| return false; 416| 0| } 417| 28| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 28| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 28| const Structure& ss = db.dna[block->dna_index]; 424| 28| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 28] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 28| db.cache(out).get(s,out,ptrval); 432| 28| if (out) { ------------------ | Branch (432:9): [True: 4, False: 24] ------------------ 433| 4| return true; 434| 4| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 24| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 24| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 24| size_t num = block->size / ss.size; 444| 24| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 24| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 24| if (!non_recursive) { ------------------ | Branch (451:9): [True: 24, False: 0] ------------------ 452| 48| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 24, False: 24] ------------------ 453| 24| s.Convert(*o,db); 454| 24| } 455| | 456| 24| db.reader->SetCurrentPos(pold); 457| 24| } 458| | 459| 24|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 24| if(out) { ------------------ | Branch (460:8): [True: 24, False: 0] ------------------ 461| 24| ++db.stats().pointers_resolved; 462| 24| } 463| 24|#endif 464| 24| return false; 465| 28|} _ZNK6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3getINS0_3TexEEEvRKNS0_9StructureERNS3_IT_EERKNS0_7PointerE: 807| 28|) const { 808| | 809| 28| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (809:8): [True: 21, False: 7] ------------------ 810| 21| s.cache_idx = db.next_cache_idx++; 811| 21| caches.resize(db.next_cache_idx); 812| 21| return; 813| 21| } 814| | 815| 7| typename StructureCache::const_iterator it = caches[s.cache_idx].find(ptr); 816| 7| if (it != caches[s.cache_idx].end()) { ------------------ | Branch (816:9): [True: 4, False: 3] ------------------ 817| 4| out = std::static_pointer_cast( (*it).second ); 818| | 819| 4|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 820| 4| ++db.stats().cache_hits; 821| 4|#endif 822| 4| } 823| | // otherwise, out remains untouched 824| 7|} _ZN6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3setINS0_3TexEEEvRKNS0_9StructureERKNS3_IT_EERKNS0_7PointerE: 832| 24|) { 833| 24| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (833:8): [True: 0, False: 24] ------------------ 834| 0| s.cache_idx = db.next_cache_idx++; 835| 0| caches.resize(db.next_cache_idx); 836| 0| } 837| 24| caches[s.cache_idx][ptr] = std::static_pointer_cast( out ); 838| | 839| 24|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 840| 24| ++db.stats().cached_objects; 841| 24|#endif 842| 24|} _ZNK6Assimp7Blender9Structure9ReadFieldILi1EcEEvRT0_PKcRKNS0_12FileDatabaseE: 282| 102k|{ 283| 102k| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 284| 102k| try { 285| 102k| const Field& f = (*this)[name]; 286| | // find the structure definition pertaining to this field 287| 102k| const Structure& s = db.dna[f.type]; 288| | 289| 102k| db.reader->IncPtr(f.offset); 290| 102k| s.Convert(out,db); 291| 102k| } 292| 102k| catch (const Error& e) { 293| 2| _defaultInitializer()(out,e.what()); 294| 2| } 295| | 296| | // and recover the previous stream position 297| 102k| db.reader->SetCurrentPos(old); 298| | 299| 102k|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 300| 102k| ++db.stats().fields_read; 301| 102k|#endif 302| 102k|} _ZNK6Assimp7Blender9Structure14ReadFieldArrayILi1EfLm3EEEvRAT1__T0_PKcRKNS0_12FileDatabaseE: 100| 18.0k|{ 101| 18.0k| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 102| 18.0k| try { 103| 18.0k| const Field& f = (*this)[name]; 104| 18.0k| const Structure& s = db.dna[f.type]; 105| | 106| | // is the input actually an array? 107| 18.0k| if (!(f.flags & FieldFlag_Array)) { ------------------ | Branch (107:13): [True: 0, False: 18.0k] ------------------ 108| 0| throw Error("Field `",name,"` of structure `",this->name,"` ought to be an array of size ",M); 109| 0| } 110| | 111| 18.0k| db.reader->IncPtr(f.offset); 112| | 113| | // size conversions are always allowed, regardless of error_policy 114| 18.0k| unsigned int i = 0; 115| 72.3k| for(; i < std::min(f.array_sizes[0],M); ++i) { ------------------ | Branch (115:15): [True: 54.2k, False: 18.0k] ------------------ 116| 54.2k| s.Convert(out[i],db); 117| 54.2k| } 118| 18.0k| for(; i < M; ++i) { ------------------ | Branch (118:15): [True: 0, False: 18.0k] ------------------ 119| 0| _defaultInitializer()(out[i]); 120| 0| } 121| 18.0k| } 122| 18.0k| catch (const Error& e) { 123| 0| _defaultInitializer()(out,e.what()); 124| 0| } 125| | 126| | // and recover the previous stream position 127| 18.0k| db.reader->SetCurrentPos(old); 128| | 129| 18.0k|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 130| 18.0k| ++db.stats().fields_read; 131| 18.0k|#endif 132| 18.0k|} _ZNK6Assimp7Blender9Structure9ReadFieldILi1EfEEvRT0_PKcRKNS0_12FileDatabaseE: 282| 2.96k|{ 283| 2.96k| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 284| 2.96k| try { 285| 2.96k| const Field& f = (*this)[name]; 286| | // find the structure definition pertaining to this field 287| 2.96k| const Structure& s = db.dna[f.type]; 288| | 289| 2.96k| db.reader->IncPtr(f.offset); 290| 2.96k| s.Convert(out,db); 291| 2.96k| } 292| 2.96k| catch (const Error& e) { 293| 289| _defaultInitializer()(out,e.what()); 294| 289| } 295| | 296| | // and recover the previous stream position 297| 2.96k| db.reader->SetCurrentPos(old); 298| | 299| 2.96k|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 300| 2.96k| ++db.stats().fields_read; 301| 2.96k|#endif 302| 2.96k|} _ZNK6Assimp7Blender9Structure9ReadFieldILi1EsEEvRT0_PKcRKNS0_12FileDatabaseE: 282| 37.4k|{ 283| 37.4k| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 284| 37.4k| try { 285| 37.4k| const Field& f = (*this)[name]; 286| | // find the structure definition pertaining to this field 287| 37.4k| const Structure& s = db.dna[f.type]; 288| | 289| 37.4k| db.reader->IncPtr(f.offset); 290| 37.4k| s.Convert(out,db); 291| 37.4k| } 292| 37.4k| catch (const Error& e) { 293| 117| _defaultInitializer()(out,e.what()); 294| 117| } 295| | 296| | // and recover the previous stream position 297| 37.4k| db.reader->SetCurrentPos(old); 298| | 299| 37.4k|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 300| 37.4k| ++db.stats().fields_read; 301| 37.4k|#endif 302| 37.4k|} _ZNK6Assimp7Blender9Structure15ReadFieldArray2ILi2EfLm4ELm2EEEvRAT1__AT2__T0_PKcRKNS0_12FileDatabaseE: 137| 28|{ 138| 28| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 139| 28| try { 140| 28| const Field& f = (*this)[name]; 141| 28| const Structure& s = db.dna[f.type]; 142| | 143| | // is the input actually an array? 144| 28| if (!(f.flags & FieldFlag_Array)) { ------------------ | Branch (144:13): [True: 0, False: 28] ------------------ 145| 0| throw Error("Field `",name,"` of structure `", 146| 0| this->name,"` ought to be an array of size ",M,"*",N 147| 0| ); 148| 0| } 149| | 150| 28| db.reader->IncPtr(f.offset); 151| | 152| | // size conversions are always allowed, regardless of error_policy 153| 28| unsigned int i = 0; 154| 140| for(; i < std::min(f.array_sizes[0],M); ++i) { ------------------ | Branch (154:15): [True: 112, False: 28] ------------------ 155| 112| unsigned int j = 0; 156| 336| for(; j < std::min(f.array_sizes[1],N); ++j) { ------------------ | Branch (156:19): [True: 224, False: 112] ------------------ 157| 224| s.Convert(out[i][j],db); 158| 224| } 159| 112| for(; j < N; ++j) { ------------------ | Branch (159:19): [True: 0, False: 112] ------------------ 160| 0| _defaultInitializer()(out[i][j]); 161| 0| } 162| 112| } 163| 28| for(; i < M; ++i) { ------------------ | Branch (163:15): [True: 0, False: 28] ------------------ 164| 0| _defaultInitializer()(out[i]); 165| 0| } 166| 28| } 167| 28| catch (const Error& e) { 168| 0| _defaultInitializer()(out,e.what()); 169| 0| } 170| | 171| | // and recover the previous stream position 172| 28| db.reader->SetCurrentPos(old); 173| | 174| 28|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 175| 28| ++db.stats().fields_read; 176| 28|#endif 177| 28|} _ZNK6Assimp7Blender9Structure9ReadFieldILi2ENS0_12ModifierDataEEEvRT0_PKcRKNS0_12FileDatabaseE: 282| 6|{ 283| 6| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 284| 6| try { 285| 6| const Field& f = (*this)[name]; 286| | // find the structure definition pertaining to this field 287| 6| const Structure& s = db.dna[f.type]; 288| | 289| 6| db.reader->IncPtr(f.offset); 290| 6| s.Convert(out,db); 291| 6| } 292| 6| catch (const Error& e) { 293| 0| _defaultInitializer()(out,e.what()); 294| 0| } 295| | 296| | // and recover the previous stream position 297| 6| db.reader->SetCurrentPos(old); 298| | 299| 6|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 300| 6| ++db.stats().fields_read; 301| 6|#endif 302| 6|} _ZNK6Assimp7Blender9Structure9ReadFieldILi2EsEEvRT0_PKcRKNS0_12FileDatabaseE: 282| 4|{ 283| 4| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 284| 4| try { 285| 4| const Field& f = (*this)[name]; 286| | // find the structure definition pertaining to this field 287| 4| const Structure& s = db.dna[f.type]; 288| | 289| 4| db.reader->IncPtr(f.offset); 290| 4| s.Convert(out,db); 291| 4| } 292| 4| catch (const Error& e) { 293| 0| _defaultInitializer()(out,e.what()); 294| 0| } 295| | 296| | // and recover the previous stream position 297| 4| db.reader->SetCurrentPos(old); 298| | 299| 4|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 300| 4| ++db.stats().fields_read; 301| 4|#endif 302| 4|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENSt3__110shared_ptrENS0_10FileOffsetEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 1|{ 184| 1| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 1| Pointer ptrval; 186| 1| const Field* f; 187| 1| try { 188| 1| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 1| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 1] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 1| db.reader->IncPtr(f->offset); 197| 1| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 1| } 201| 1| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 1| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 1| if(!non_recursive) { ------------------ | Branch (211:8): [True: 1, False: 0] ------------------ 212| | // and recover the previous stream position 213| 1| db.reader->SetCurrentPos(old); 214| 1| } 215| | 216| 1|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 1| ++db.stats().fields_read; 218| 1|#endif 219| | 220| 1| return res; 221| 1|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENSt3__110shared_ptrENS0_4BaseEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 121|{ 184| 121| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 121| Pointer ptrval; 186| 121| const Field* f; 187| 121| try { 188| 121| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 121| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 121] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 121| db.reader->IncPtr(f->offset); 197| 121| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 121| } 201| 121| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 121| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 121| if(!non_recursive) { ------------------ | Branch (211:8): [True: 25, False: 96] ------------------ 212| | // and recover the previous stream position 213| 25| db.reader->SetCurrentPos(old); 214| 25| } 215| | 216| 121|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 121| ++db.stats().fields_read; 218| 121|#endif 219| | 220| 121| return res; 221| 121|} _ZNK6Assimp7Blender9Structure14ResolvePointerINSt3__110shared_ptrENS0_4BaseEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 121|{ 413| 121| out.reset(); // ensure null pointers work 414| 121| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 27, False: 94] ------------------ 415| 27| return false; 416| 27| } 417| 94| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 94| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 94| const Structure& ss = db.dna[block->dna_index]; 424| 94| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 94] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 94| db.cache(out).get(s,out,ptrval); 432| 94| if (out) { ------------------ | Branch (432:9): [True: 6, False: 88] ------------------ 433| 6| return true; 434| 6| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 88| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 88| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 88| size_t num = block->size / ss.size; 444| 88| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 88| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 88| if (!non_recursive) { ------------------ | Branch (451:9): [True: 23, False: 65] ------------------ 452| 46| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 23, False: 23] ------------------ 453| 23| s.Convert(*o,db); 454| 23| } 455| | 456| 23| db.reader->SetCurrentPos(pold); 457| 23| } 458| | 459| 88|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 88| if(out) { ------------------ | Branch (460:8): [True: 87, False: 1] ------------------ 461| 87| ++db.stats().pointers_resolved; 462| 87| } 463| 88|#endif 464| 88| return false; 465| 94|} _ZNK6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3getINS0_4BaseEEEvRKNS0_9StructureERNS3_IT_EERKNS0_7PointerE: 807| 94|) const { 808| | 809| 94| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (809:8): [True: 23, False: 71] ------------------ 810| 23| s.cache_idx = db.next_cache_idx++; 811| 23| caches.resize(db.next_cache_idx); 812| 23| return; 813| 23| } 814| | 815| 71| typename StructureCache::const_iterator it = caches[s.cache_idx].find(ptr); 816| 71| if (it != caches[s.cache_idx].end()) { ------------------ | Branch (816:9): [True: 6, False: 65] ------------------ 817| 6| out = std::static_pointer_cast( (*it).second ); 818| | 819| 6|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 820| 6| ++db.stats().cache_hits; 821| 6|#endif 822| 6| } 823| | // otherwise, out remains untouched 824| 71|} _ZN6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3setINS0_4BaseEEEvRKNS0_9StructureERKNS3_IT_EERKNS0_7PointerE: 832| 88|) { 833| 88| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (833:8): [True: 0, False: 88] ------------------ 834| 0| s.cache_idx = db.next_cache_idx++; 835| 0| caches.resize(db.next_cache_idx); 836| 0| } 837| 88| caches[s.cache_idx][ptr] = std::static_pointer_cast( out ); 838| | 839| 88|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 840| 88| ++db.stats().cached_objects; 841| 88|#endif 842| 88|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENSt3__110shared_ptrENS0_4MTexELm18EEEbRAT2__T0_IT1_EPKcRKNS0_12FileDatabaseE: 227| 28|{ 228| | // XXX see if we can reduce this to call to the 'normal' ReadFieldPtr 229| 28| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 230| 28| Pointer ptrval[N]; 231| 28| const Field* f; 232| 28| try { 233| 28| f = &(*this)[name]; 234| | 235| |#ifdef _DEBUG 236| | // sanity check, should never happen if the genblenddna script is right 237| | if ((FieldFlag_Pointer|FieldFlag_Pointer) != (f->flags & (FieldFlag_Pointer|FieldFlag_Pointer))) { 238| | throw Error("Field `",name,"` of structure `", 239| | this->name,"` ought to be a pointer AND an array"); 240| | } 241| |#endif // _DEBUG 242| | 243| 28| db.reader->IncPtr(f->offset); 244| | 245| 28| size_t i = 0; 246| 514| for(; i < std::min(f->array_sizes[0],N); ++i) { ------------------ | Branch (246:15): [True: 486, False: 28] ------------------ 247| 486| Convert(ptrval[i],db); 248| 486| } 249| 28| for(; i < N; ++i) { ------------------ | Branch (249:15): [True: 0, False: 28] ------------------ 250| 0| _defaultInitializer()(ptrval[i]); 251| 0| } 252| | 253| | // actually it is meaningless on which Structure the Convert is called 254| | // because the `Pointer` argument triggers a special implementation. 255| 28| } 256| 28| catch (const Error& e) { 257| 1| _defaultInitializer()(out,e.what()); 258| 19| for(size_t i = 0; i < N; ++i) { ------------------ | Branch (258:27): [True: 18, False: 1] ------------------ 259| 18| out[i].reset(); 260| 18| } 261| 1| return false; 262| 1| } 263| | 264| 27| bool res = true; 265| 513| for(size_t i = 0; i < N; ++i) { ------------------ | Branch (265:23): [True: 486, False: 27] ------------------ 266| | // resolve the pointer and load the corresponding structure 267| 486| res = ResolvePointer(out[i],ptrval[i],db,*f) && res; ------------------ | Branch (267:15): [True: 0, False: 486] | Branch (267:57): [True: 0, False: 0] ------------------ 268| 486| } 269| | 270| | // and recover the previous stream position 271| 27| db.reader->SetCurrentPos(old); 272| | 273| 27|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 274| 27| ++db.stats().fields_read; 275| 27|#endif 276| 27| return res; 277| 28|} _ZNK6Assimp7Blender9Structure14ResolvePointerINSt3__110shared_ptrENS0_4MTexEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 486|{ 413| 486| out.reset(); // ensure null pointers work 414| 486| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 458, False: 28] ------------------ 415| 458| return false; 416| 458| } 417| 28| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 28| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 28| const Structure& ss = db.dna[block->dna_index]; 424| 28| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 28] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 28| db.cache(out).get(s,out,ptrval); 432| 28| if (out) { ------------------ | Branch (432:9): [True: 0, False: 28] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 28| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 28| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 28| size_t num = block->size / ss.size; 444| 28| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 28| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 28| if (!non_recursive) { ------------------ | Branch (451:9): [True: 28, False: 0] ------------------ 452| 56| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 28, False: 28] ------------------ 453| 28| s.Convert(*o,db); 454| 28| } 455| | 456| 28| db.reader->SetCurrentPos(pold); 457| 28| } 458| | 459| 28|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 28| if(out) { ------------------ | Branch (460:8): [True: 28, False: 0] ------------------ 461| 28| ++db.stats().pointers_resolved; 462| 28| } 463| 28|#endif 464| 28| return false; 465| 28|} _ZNK6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3getINS0_4MTexEEEvRKNS0_9StructureERNS3_IT_EERKNS0_7PointerE: 807| 28|) const { 808| | 809| 28| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (809:8): [True: 21, False: 7] ------------------ 810| 21| s.cache_idx = db.next_cache_idx++; 811| 21| caches.resize(db.next_cache_idx); 812| 21| return; 813| 21| } 814| | 815| 7| typename StructureCache::const_iterator it = caches[s.cache_idx].find(ptr); 816| 7| if (it != caches[s.cache_idx].end()) { ------------------ | Branch (816:9): [True: 0, False: 7] ------------------ 817| 0| out = std::static_pointer_cast( (*it).second ); 818| | 819| 0|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 820| 0| ++db.stats().cache_hits; 821| 0|#endif 822| 0| } 823| | // otherwise, out remains untouched 824| 7|} _ZN6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3setINS0_4MTexEEEvRKNS0_9StructureERKNS3_IT_EERKNS0_7PointerE: 832| 28|) { 833| 28| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (833:8): [True: 0, False: 28] ------------------ 834| 0| s.cache_idx = db.next_cache_idx++; 835| 0| caches.resize(db.next_cache_idx); 836| 0| } 837| 28| caches[s.cache_idx][ptr] = std::static_pointer_cast( out ); 838| | 839| 28|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 840| 28| ++db.stats().cached_objects; 841| 28|#endif 842| 28|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENSt3__110shared_ptrENS0_5ImageEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 115|{ 184| 115| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 115| Pointer ptrval; 186| 115| const Field* f; 187| 115| try { 188| 115| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 115| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 115] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 115| db.reader->IncPtr(f->offset); 197| 115| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 115| } 201| 115| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 115| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 115| if(!non_recursive) { ------------------ | Branch (211:8): [True: 115, False: 0] ------------------ 212| | // and recover the previous stream position 213| 115| db.reader->SetCurrentPos(old); 214| 115| } 215| | 216| 115|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 115| ++db.stats().fields_read; 218| 115|#endif 219| | 220| 115| return res; 221| 115|} _ZNK6Assimp7Blender9Structure14ResolvePointerINSt3__110shared_ptrENS0_5ImageEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 115|{ 413| 115| out.reset(); // ensure null pointers work 414| 115| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 15, False: 100] ------------------ 415| 15| return false; 416| 15| } 417| 100| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 100| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 100| const Structure& ss = db.dna[block->dna_index]; 424| 100| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 100] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 100| db.cache(out).get(s,out,ptrval); 432| 100| if (out) { ------------------ | Branch (432:9): [True: 92, False: 8] ------------------ 433| 92| return true; 434| 92| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 8| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 8| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 8| size_t num = block->size / ss.size; 444| 8| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 8| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 8| if (!non_recursive) { ------------------ | Branch (451:9): [True: 8, False: 0] ------------------ 452| 16| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 8, False: 8] ------------------ 453| 8| s.Convert(*o,db); 454| 8| } 455| | 456| 8| db.reader->SetCurrentPos(pold); 457| 8| } 458| | 459| 8|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 8| if(out) { ------------------ | Branch (460:8): [True: 8, False: 0] ------------------ 461| 8| ++db.stats().pointers_resolved; 462| 8| } 463| 8|#endif 464| 8| return false; 465| 100|} _ZNK6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3getINS0_5ImageEEEvRKNS0_9StructureERNS3_IT_EERKNS0_7PointerE: 807| 100|) const { 808| | 809| 100| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (809:8): [True: 6, False: 94] ------------------ 810| 6| s.cache_idx = db.next_cache_idx++; 811| 6| caches.resize(db.next_cache_idx); 812| 6| return; 813| 6| } 814| | 815| 94| typename StructureCache::const_iterator it = caches[s.cache_idx].find(ptr); 816| 94| if (it != caches[s.cache_idx].end()) { ------------------ | Branch (816:9): [True: 92, False: 2] ------------------ 817| 92| out = std::static_pointer_cast( (*it).second ); 818| | 819| 92|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 820| 92| ++db.stats().cache_hits; 821| 92|#endif 822| 92| } 823| | // otherwise, out remains untouched 824| 94|} _ZN6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3setINS0_5ImageEEEvRKNS0_9StructureERKNS3_IT_EERKNS0_7PointerE: 832| 8|) { 833| 8| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (833:8): [True: 0, False: 8] ------------------ 834| 0| s.cache_idx = db.next_cache_idx++; 835| 0| caches.resize(db.next_cache_idx); 836| 0| } 837| 8| caches[s.cache_idx][ptr] = std::static_pointer_cast( out ); 838| | 839| 8|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 840| 8| ++db.stats().cached_objects; 841| 8|#endif 842| 8|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi2ENS0_6vectorENS0_5MFaceEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 42|{ 184| 42| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 42| Pointer ptrval; 186| 42| const Field* f; 187| 42| try { 188| 42| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 42| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 42] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 42| db.reader->IncPtr(f->offset); 197| 42| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 42| } 201| 42| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 42| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 42| if(!non_recursive) { ------------------ | Branch (211:8): [True: 42, False: 0] ------------------ 212| | // and recover the previous stream position 213| 42| db.reader->SetCurrentPos(old); 214| 42| } 215| | 216| 42|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 42| ++db.stats().fields_read; 218| 42|#endif 219| | 220| 42| return res; 221| 42|} _ZNK6Assimp7Blender9Structure14ResolvePointerINS0_6vectorENS0_5MFaceEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 42|{ 413| 42| out.reset(); // ensure null pointers work 414| 42| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 11, False: 31] ------------------ 415| 11| return false; 416| 11| } 417| 31| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 31| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 31| const Structure& ss = db.dna[block->dna_index]; 424| 31| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 31] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 31| db.cache(out).get(s,out,ptrval); 432| 31| if (out) { ------------------ | Branch (432:9): [True: 0, False: 31] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 31| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 31| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 31| size_t num = block->size / ss.size; 444| 31| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 31| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 31| if (!non_recursive) { ------------------ | Branch (451:9): [True: 31, False: 0] ------------------ 452| 7.54k| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 7.51k, False: 31] ------------------ 453| 7.51k| s.Convert(*o,db); 454| 7.51k| } 455| | 456| 31| db.reader->SetCurrentPos(pold); 457| 31| } 458| | 459| 31|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 31| if(out) { ------------------ | Branch (460:8): [True: 31, False: 0] ------------------ 461| 31| ++db.stats().pointers_resolved; 462| 31| } 463| 31|#endif 464| 31| return false; 465| 31|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENS0_6vectorENS0_6MTFaceEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 42|{ 184| 42| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 42| Pointer ptrval; 186| 42| const Field* f; 187| 42| try { 188| 42| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 42| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 42] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 42| db.reader->IncPtr(f->offset); 197| 42| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 42| } 201| 42| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 42| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 42| if(!non_recursive) { ------------------ | Branch (211:8): [True: 42, False: 0] ------------------ 212| | // and recover the previous stream position 213| 42| db.reader->SetCurrentPos(old); 214| 42| } 215| | 216| 42|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 42| ++db.stats().fields_read; 218| 42|#endif 219| | 220| 42| return res; 221| 42|} _ZNK6Assimp7Blender9Structure14ResolvePointerINS0_6vectorENS0_6MTFaceEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 42|{ 413| 42| out.reset(); // ensure null pointers work 414| 42| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 38, False: 4] ------------------ 415| 38| return false; 416| 38| } 417| 4| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 4| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 4| const Structure& ss = db.dna[block->dna_index]; 424| 4| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 4] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 4| db.cache(out).get(s,out,ptrval); 432| 4| if (out) { ------------------ | Branch (432:9): [True: 0, False: 4] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 4| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 4| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 4| size_t num = block->size / ss.size; 444| 4| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 4| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 4| if (!non_recursive) { ------------------ | Branch (451:9): [True: 4, False: 0] ------------------ 452| 18| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 14, False: 4] ------------------ 453| 14| s.Convert(*o,db); 454| 14| } 455| | 456| 4| db.reader->SetCurrentPos(pold); 457| 4| } 458| | 459| 4|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 4| if(out) { ------------------ | Branch (460:8): [True: 4, False: 0] ------------------ 461| 4| ++db.stats().pointers_resolved; 462| 4| } 463| 4|#endif 464| 4| return false; 465| 4|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENS0_6vectorENS0_5TFaceEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 42|{ 184| 42| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 42| Pointer ptrval; 186| 42| const Field* f; 187| 42| try { 188| 42| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 42| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 42] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 42| db.reader->IncPtr(f->offset); 197| 42| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 42| } 201| 42| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 42| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 42| if(!non_recursive) { ------------------ | Branch (211:8): [True: 42, False: 0] ------------------ 212| | // and recover the previous stream position 213| 42| db.reader->SetCurrentPos(old); 214| 42| } 215| | 216| 42|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 42| ++db.stats().fields_read; 218| 42|#endif 219| | 220| 42| return res; 221| 42|} _ZNK6Assimp7Blender9Structure14ResolvePointerINS0_6vectorENS0_5TFaceEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 42|{ 413| 42| out.reset(); // ensure null pointers work 414| 42| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 42, False: 0] ------------------ 415| 42| return false; 416| 42| } 417| 0| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 0| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 0| const Structure& ss = db.dna[block->dna_index]; 424| 0| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 0] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 0| db.cache(out).get(s,out,ptrval); 432| 0| if (out) { ------------------ | Branch (432:9): [True: 0, False: 0] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 0| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 0| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 0| size_t num = block->size / ss.size; 444| 0| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 0| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 0| if (!non_recursive) { ------------------ | Branch (451:9): [True: 0, False: 0] ------------------ 452| 0| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 0, False: 0] ------------------ 453| 0| s.Convert(*o,db); 454| 0| } 455| | 456| 0| db.reader->SetCurrentPos(pold); 457| 0| } 458| | 459| 0|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 0| if(out) { ------------------ | Branch (460:8): [True: 0, False: 0] ------------------ 461| 0| ++db.stats().pointers_resolved; 462| 0| } 463| 0|#endif 464| 0| return false; 465| 0|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi2ENS0_6vectorENS0_5MVertEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 42|{ 184| 42| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 42| Pointer ptrval; 186| 42| const Field* f; 187| 42| try { 188| 42| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 42| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 42] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 42| db.reader->IncPtr(f->offset); 197| 42| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 42| } 201| 42| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 42| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 42| if(!non_recursive) { ------------------ | Branch (211:8): [True: 42, False: 0] ------------------ 212| | // and recover the previous stream position 213| 42| db.reader->SetCurrentPos(old); 214| 42| } 215| | 216| 42|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 42| ++db.stats().fields_read; 218| 42|#endif 219| | 220| 42| return res; 221| 42|} _ZNK6Assimp7Blender9Structure14ResolvePointerINS0_6vectorENS0_5MVertEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 42|{ 413| 42| out.reset(); // ensure null pointers work 414| 42| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 0, False: 42] ------------------ 415| 0| return false; 416| 0| } 417| 42| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 42| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 42| const Structure& ss = db.dna[block->dna_index]; 424| 42| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 42] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 42| db.cache(out).get(s,out,ptrval); 432| 42| if (out) { ------------------ | Branch (432:9): [True: 0, False: 42] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 42| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 42| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 42| size_t num = block->size / ss.size; 444| 42| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 42| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 42| if (!non_recursive) { ------------------ | Branch (451:9): [True: 42, False: 0] ------------------ 452| 9.05k| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 9.01k, False: 42] ------------------ 453| 9.01k| s.Convert(*o,db); 454| 9.01k| } 455| | 456| 42| db.reader->SetCurrentPos(pold); 457| 42| } 458| | 459| 42|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 42| if(out) { ------------------ | Branch (460:8): [True: 42, False: 0] ------------------ 461| 42| ++db.stats().pointers_resolved; 462| 42| } 463| 42|#endif 464| 42| return false; 465| 42|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENS0_6vectorENS0_5MEdgeEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 42|{ 184| 42| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 42| Pointer ptrval; 186| 42| const Field* f; 187| 42| try { 188| 42| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 42| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 42] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 42| db.reader->IncPtr(f->offset); 197| 42| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 42| } 201| 42| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 42| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 42| if(!non_recursive) { ------------------ | Branch (211:8): [True: 42, False: 0] ------------------ 212| | // and recover the previous stream position 213| 42| db.reader->SetCurrentPos(old); 214| 42| } 215| | 216| 42|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 42| ++db.stats().fields_read; 218| 42|#endif 219| | 220| 42| return res; 221| 42|} _ZNK6Assimp7Blender9Structure14ResolvePointerINS0_6vectorENS0_5MEdgeEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 42|{ 413| 42| out.reset(); // ensure null pointers work 414| 42| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 0, False: 42] ------------------ 415| 0| return false; 416| 0| } 417| 42| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 42| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 42| const Structure& ss = db.dna[block->dna_index]; 424| 42| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 42] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 42| db.cache(out).get(s,out,ptrval); 432| 42| if (out) { ------------------ | Branch (432:9): [True: 0, False: 42] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 42| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 42| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 42| size_t num = block->size / ss.size; 444| 42| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 42| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 42| if (!non_recursive) { ------------------ | Branch (451:9): [True: 42, False: 0] ------------------ 452| 17.0k| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 16.9k, False: 42] ------------------ 453| 16.9k| s.Convert(*o,db); 454| 16.9k| } 455| | 456| 42| db.reader->SetCurrentPos(pold); 457| 42| } 458| | 459| 42|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 42| if(out) { ------------------ | Branch (460:8): [True: 42, False: 0] ------------------ 461| 42| ++db.stats().pointers_resolved; 462| 42| } 463| 42|#endif 464| 42| return false; 465| 42|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENS0_6vectorENS0_5MLoopEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 42|{ 184| 42| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 42| Pointer ptrval; 186| 42| const Field* f; 187| 42| try { 188| 42| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 42| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 42] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 42| db.reader->IncPtr(f->offset); 197| 42| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 42| } 201| 42| catch (const Error& e) { 202| 30| _defaultInitializer()(out,e.what()); 203| | 204| 30| out.reset(); 205| 30| return false; 206| 30| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 12| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 12| if(!non_recursive) { ------------------ | Branch (211:8): [True: 12, False: 0] ------------------ 212| | // and recover the previous stream position 213| 12| db.reader->SetCurrentPos(old); 214| 12| } 215| | 216| 12|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 12| ++db.stats().fields_read; 218| 12|#endif 219| | 220| 12| return res; 221| 42|} _ZNK6Assimp7Blender9Structure14ResolvePointerINS0_6vectorENS0_5MLoopEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 12|{ 413| 12| out.reset(); // ensure null pointers work 414| 12| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 1, False: 11] ------------------ 415| 1| return false; 416| 1| } 417| 11| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 11| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 11| const Structure& ss = db.dna[block->dna_index]; 424| 11| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 11] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 11| db.cache(out).get(s,out,ptrval); 432| 11| if (out) { ------------------ | Branch (432:9): [True: 0, False: 11] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 11| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 11| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 11| size_t num = block->size / ss.size; 444| 11| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 11| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 11| if (!non_recursive) { ------------------ | Branch (451:9): [True: 11, False: 0] ------------------ 452| 2.66k| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 2.65k, False: 11] ------------------ 453| 2.65k| s.Convert(*o,db); 454| 2.65k| } 455| | 456| 11| db.reader->SetCurrentPos(pold); 457| 11| } 458| | 459| 11|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 11| if(out) { ------------------ | Branch (460:8): [True: 11, False: 0] ------------------ 461| 11| ++db.stats().pointers_resolved; 462| 11| } 463| 11|#endif 464| 11| return false; 465| 11|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENS0_6vectorENS0_7MLoopUVEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 42|{ 184| 42| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 42| Pointer ptrval; 186| 42| const Field* f; 187| 42| try { 188| 42| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 42| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 42] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 42| db.reader->IncPtr(f->offset); 197| 42| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 42| } 201| 42| catch (const Error& e) { 202| 30| _defaultInitializer()(out,e.what()); 203| | 204| 30| out.reset(); 205| 30| return false; 206| 30| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 12| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 12| if(!non_recursive) { ------------------ | Branch (211:8): [True: 12, False: 0] ------------------ 212| | // and recover the previous stream position 213| 12| db.reader->SetCurrentPos(old); 214| 12| } 215| | 216| 12|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 12| ++db.stats().fields_read; 218| 12|#endif 219| | 220| 12| return res; 221| 42|} _ZNK6Assimp7Blender9Structure14ResolvePointerINS0_6vectorENS0_7MLoopUVEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 12|{ 413| 12| out.reset(); // ensure null pointers work 414| 12| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 9, False: 3] ------------------ 415| 9| return false; 416| 9| } 417| 3| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 3| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 3| const Structure& ss = db.dna[block->dna_index]; 424| 3| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 3] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 3| db.cache(out).get(s,out,ptrval); 432| 3| if (out) { ------------------ | Branch (432:9): [True: 0, False: 3] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 3| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 3| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 3| size_t num = block->size / ss.size; 444| 3| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 3| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 3| if (!non_recursive) { ------------------ | Branch (451:9): [True: 3, False: 0] ------------------ 452| 163| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 160, False: 3] ------------------ 453| 160| s.Convert(*o,db); 454| 160| } 455| | 456| 3| db.reader->SetCurrentPos(pold); 457| 3| } 458| | 459| 3|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 3| if(out) { ------------------ | Branch (460:8): [True: 3, False: 0] ------------------ 461| 3| ++db.stats().pointers_resolved; 462| 3| } 463| 3|#endif 464| 3| return false; 465| 3|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENS0_6vectorENS0_8MLoopColEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 42|{ 184| 42| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 42| Pointer ptrval; 186| 42| const Field* f; 187| 42| try { 188| 42| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 42| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 42] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 42| db.reader->IncPtr(f->offset); 197| 42| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 42| } 201| 42| catch (const Error& e) { 202| 30| _defaultInitializer()(out,e.what()); 203| | 204| 30| out.reset(); 205| 30| return false; 206| 30| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 12| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 12| if(!non_recursive) { ------------------ | Branch (211:8): [True: 12, False: 0] ------------------ 212| | // and recover the previous stream position 213| 12| db.reader->SetCurrentPos(old); 214| 12| } 215| | 216| 12|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 12| ++db.stats().fields_read; 218| 12|#endif 219| | 220| 12| return res; 221| 42|} _ZNK6Assimp7Blender9Structure14ResolvePointerINS0_6vectorENS0_8MLoopColEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 12|{ 413| 12| out.reset(); // ensure null pointers work 414| 12| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 12, False: 0] ------------------ 415| 12| return false; 416| 12| } 417| 0| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 0| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 0| const Structure& ss = db.dna[block->dna_index]; 424| 0| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 0] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 0| db.cache(out).get(s,out,ptrval); 432| 0| if (out) { ------------------ | Branch (432:9): [True: 0, False: 0] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 0| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 0| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 0| size_t num = block->size / ss.size; 444| 0| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 0| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 0| if (!non_recursive) { ------------------ | Branch (451:9): [True: 0, False: 0] ------------------ 452| 0| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 0, False: 0] ------------------ 453| 0| s.Convert(*o,db); 454| 0| } 455| | 456| 0| db.reader->SetCurrentPos(pold); 457| 0| } 458| | 459| 0|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 0| if(out) { ------------------ | Branch (460:8): [True: 0, False: 0] ------------------ 461| 0| ++db.stats().pointers_resolved; 462| 0| } 463| 0|#endif 464| 0| return false; 465| 0|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENS0_6vectorENS0_5MPolyEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 42|{ 184| 42| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 42| Pointer ptrval; 186| 42| const Field* f; 187| 42| try { 188| 42| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 42| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 42] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 42| db.reader->IncPtr(f->offset); 197| 42| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 42| } 201| 42| catch (const Error& e) { 202| 30| _defaultInitializer()(out,e.what()); 203| | 204| 30| out.reset(); 205| 30| return false; 206| 30| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 12| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 12| if(!non_recursive) { ------------------ | Branch (211:8): [True: 12, False: 0] ------------------ 212| | // and recover the previous stream position 213| 12| db.reader->SetCurrentPos(old); 214| 12| } 215| | 216| 12|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 12| ++db.stats().fields_read; 218| 12|#endif 219| | 220| 12| return res; 221| 42|} _ZNK6Assimp7Blender9Structure14ResolvePointerINS0_6vectorENS0_5MPolyEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 12|{ 413| 12| out.reset(); // ensure null pointers work 414| 12| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 1, False: 11] ------------------ 415| 1| return false; 416| 1| } 417| 11| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 11| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 11| const Structure& ss = db.dna[block->dna_index]; 424| 11| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 11] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 11| db.cache(out).get(s,out,ptrval); 432| 11| if (out) { ------------------ | Branch (432:9): [True: 0, False: 11] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 11| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 11| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 11| size_t num = block->size / ss.size; 444| 11| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 11| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 11| if (!non_recursive) { ------------------ | Branch (451:9): [True: 11, False: 0] ------------------ 452| 694| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 683, False: 11] ------------------ 453| 683| s.Convert(*o,db); 454| 683| } 455| | 456| 11| db.reader->SetCurrentPos(pold); 457| 11| } 458| | 459| 11|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 11| if(out) { ------------------ | Branch (460:8): [True: 11, False: 0] ------------------ 461| 11| ++db.stats().pointers_resolved; 462| 11| } 463| 11|#endif 464| 11| return false; 465| 11|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENS0_6vectorENS0_8MTexPolyEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 42|{ 184| 42| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 42| Pointer ptrval; 186| 42| const Field* f; 187| 42| try { 188| 42| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 42| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 42] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 42| db.reader->IncPtr(f->offset); 197| 42| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 42| } 201| 42| catch (const Error& e) { 202| 31| _defaultInitializer()(out,e.what()); 203| | 204| 31| out.reset(); 205| 31| return false; 206| 31| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 11| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 11| if(!non_recursive) { ------------------ | Branch (211:8): [True: 11, False: 0] ------------------ 212| | // and recover the previous stream position 213| 11| db.reader->SetCurrentPos(old); 214| 11| } 215| | 216| 11|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 11| ++db.stats().fields_read; 218| 11|#endif 219| | 220| 11| return res; 221| 42|} _ZNK6Assimp7Blender9Structure14ResolvePointerINS0_6vectorENS0_8MTexPolyEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 11|{ 413| 11| out.reset(); // ensure null pointers work 414| 11| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 9, False: 2] ------------------ 415| 9| return false; 416| 9| } 417| 2| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 2| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 2| const Structure& ss = db.dna[block->dna_index]; 424| 2| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 2] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 2| db.cache(out).get(s,out,ptrval); 432| 2| if (out) { ------------------ | Branch (432:9): [True: 0, False: 2] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 2| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 2| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 2| size_t num = block->size / ss.size; 444| 2| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 2| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 2| if (!non_recursive) { ------------------ | Branch (451:9): [True: 2, False: 0] ------------------ 452| 47| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 45, False: 2] ------------------ 453| 45| s.Convert(*o,db); 454| 45| } 455| | 456| 2| db.reader->SetCurrentPos(pold); 457| 2| } 458| | 459| 2|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 2| if(out) { ------------------ | Branch (460:8): [True: 2, False: 0] ------------------ 461| 2| ++db.stats().pointers_resolved; 462| 2| } 463| 2|#endif 464| 2| return false; 465| 2|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENS0_6vectorENS0_11MDeformVertEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 42|{ 184| 42| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 42| Pointer ptrval; 186| 42| const Field* f; 187| 42| try { 188| 42| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 42| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 42] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 42| db.reader->IncPtr(f->offset); 197| 42| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 42| } 201| 42| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 42| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 42| if(!non_recursive) { ------------------ | Branch (211:8): [True: 42, False: 0] ------------------ 212| | // and recover the previous stream position 213| 42| db.reader->SetCurrentPos(old); 214| 42| } 215| | 216| 42|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 42| ++db.stats().fields_read; 218| 42|#endif 219| | 220| 42| return res; 221| 42|} _ZNK6Assimp7Blender9Structure14ResolvePointerINS0_6vectorENS0_11MDeformVertEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 42|{ 413| 42| out.reset(); // ensure null pointers work 414| 42| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 42, False: 0] ------------------ 415| 42| return false; 416| 42| } 417| 0| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 0| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 0| const Structure& ss = db.dna[block->dna_index]; 424| 0| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 0] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 0| db.cache(out).get(s,out,ptrval); 432| 0| if (out) { ------------------ | Branch (432:9): [True: 0, False: 0] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 0| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 0| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 0| size_t num = block->size / ss.size; 444| 0| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 0| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 0| if (!non_recursive) { ------------------ | Branch (451:9): [True: 0, False: 0] ------------------ 452| 0| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 0, False: 0] ------------------ 453| 0| s.Convert(*o,db); 454| 0| } 455| | 456| 0| db.reader->SetCurrentPos(pold); 457| 0| } 458| | 459| 0|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 0| if(out) { ------------------ | Branch (460:8): [True: 0, False: 0] ------------------ 461| 0| ++db.stats().pointers_resolved; 462| 0| } 463| 0|#endif 464| 0| return false; 465| 0|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENS0_6vectorENS0_4MColEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 42|{ 184| 42| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 42| Pointer ptrval; 186| 42| const Field* f; 187| 42| try { 188| 42| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 42| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 42] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 42| db.reader->IncPtr(f->offset); 197| 42| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 42| } 201| 42| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 42| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 42| if(!non_recursive) { ------------------ | Branch (211:8): [True: 42, False: 0] ------------------ 212| | // and recover the previous stream position 213| 42| db.reader->SetCurrentPos(old); 214| 42| } 215| | 216| 42|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 42| ++db.stats().fields_read; 218| 42|#endif 219| | 220| 42| return res; 221| 42|} _ZNK6Assimp7Blender9Structure14ResolvePointerINS0_6vectorENS0_4MColEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 42|{ 413| 42| out.reset(); // ensure null pointers work 414| 42| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 41, False: 1] ------------------ 415| 41| return false; 416| 41| } 417| 1| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 1| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 1| const Structure& ss = db.dna[block->dna_index]; 424| 1| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 1] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 1| db.cache(out).get(s,out,ptrval); 432| 1| if (out) { ------------------ | Branch (432:9): [True: 0, False: 1] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 1| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 1| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 1| size_t num = block->size / ss.size; 444| 1| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 1| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 1| if (!non_recursive) { ------------------ | Branch (451:9): [True: 1, False: 0] ------------------ 452| 25| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 24, False: 1] ------------------ 453| 24| s.Convert(*o,db); 454| 24| } 455| | 456| 1| db.reader->SetCurrentPos(pold); 457| 1| } 458| | 459| 1|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 1| if(out) { ------------------ | Branch (460:8): [True: 1, False: 0] ------------------ 461| 1| ++db.stats().pointers_resolved; 462| 1| } 463| 1|#endif 464| 1| return false; 465| 1|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi2ENS0_6vectorENSt3__110shared_ptrINS0_8MaterialEEEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 42|{ 184| 42| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 42| Pointer ptrval; 186| 42| const Field* f; 187| 42| try { 188| 42| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 42| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 42] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 42| db.reader->IncPtr(f->offset); 197| 42| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 42| } 201| 42| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 42| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 42| if(!non_recursive) { ------------------ | Branch (211:8): [True: 42, False: 0] ------------------ 212| | // and recover the previous stream position 213| 42| db.reader->SetCurrentPos(old); 214| 42| } 215| | 216| 42|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 42| ++db.stats().fields_read; 218| 42|#endif 219| | 220| 42| return res; 221| 42|} _ZNK6Assimp7Blender9Structure14ResolvePointerINSt3__110shared_ptrENS0_8MaterialEEEbRNS0_6vectorIT_IT0_EEERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 495| 42|{ 496| | // This is a function overload, not a template specialization. According to 497| | // the partial ordering rules, it should be selected by the compiler 498| | // for array-of-pointer inputs, i.e. Object::mats. 499| | 500| 42| out.reset(); 501| 42| if (!ptrval.val) { ------------------ | Branch (501:9): [True: 4, False: 38] ------------------ 502| 4| return false; 503| 4| } 504| | 505| | // find the file block the pointer is pointing to 506| 38| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 507| 38| const size_t num = block->size / (db.i64bit?8:4); ------------------ | Branch (507:39): [True: 15, False: 23] ------------------ 508| | 509| | // keep the old stream position 510| 38| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 511| 38| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 512| | 513| 38| bool res = false; 514| | // allocate raw storage for the array 515| 38| out.resize(num); 516| 77| for (size_t i = 0; i< num; ++i) { ------------------ | Branch (516:24): [True: 39, False: 38] ------------------ 517| 39| Pointer val; 518| 39| Convert(val,db); 519| | 520| | // and resolve the pointees 521| 39| res = ResolvePointer(out[i],val,db,f) && res; ------------------ | Branch (521:15): [True: 11, False: 28] | Branch (521:50): [True: 0, False: 11] ------------------ 522| 39| } 523| | 524| 38| db.reader->SetCurrentPos(pold); 525| 38| return res; 526| 42|} _ZNK6Assimp7Blender9Structure14ResolvePointerINSt3__110shared_ptrENS0_8MaterialEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 39|{ 413| 39| out.reset(); // ensure null pointers work 414| 39| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 0, False: 39] ------------------ 415| 0| return false; 416| 0| } 417| 39| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 39| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 39| const Structure& ss = db.dna[block->dna_index]; 424| 39| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 39] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 39| db.cache(out).get(s,out,ptrval); 432| 39| if (out) { ------------------ | Branch (432:9): [True: 11, False: 28] ------------------ 433| 11| return true; 434| 11| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 28| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 28| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 28| size_t num = block->size / ss.size; 444| 28| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 28| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 28| if (!non_recursive) { ------------------ | Branch (451:9): [True: 28, False: 0] ------------------ 452| 56| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 28, False: 28] ------------------ 453| 28| s.Convert(*o,db); 454| 28| } 455| | 456| 28| db.reader->SetCurrentPos(pold); 457| 28| } 458| | 459| 28|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 28| if(out) { ------------------ | Branch (460:8): [True: 28, False: 0] ------------------ 461| 28| ++db.stats().pointers_resolved; 462| 28| } 463| 28|#endif 464| 28| return false; 465| 39|} _ZNK6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3getINS0_8MaterialEEEvRKNS0_9StructureERNS3_IT_EERKNS0_7PointerE: 807| 39|) const { 808| | 809| 39| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (809:8): [True: 23, False: 16] ------------------ 810| 23| s.cache_idx = db.next_cache_idx++; 811| 23| caches.resize(db.next_cache_idx); 812| 23| return; 813| 23| } 814| | 815| 16| typename StructureCache::const_iterator it = caches[s.cache_idx].find(ptr); 816| 16| if (it != caches[s.cache_idx].end()) { ------------------ | Branch (816:9): [True: 11, False: 5] ------------------ 817| 11| out = std::static_pointer_cast( (*it).second ); 818| | 819| 11|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 820| 11| ++db.stats().cache_hits; 821| 11|#endif 822| 11| } 823| | // otherwise, out remains untouched 824| 16|} _ZN6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3setINS0_8MaterialEEEvRKNS0_9StructureERKNS3_IT_EERKNS0_7PointerE: 832| 28|) { 833| 28| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (833:8): [True: 0, False: 28] ------------------ 834| 0| s.cache_idx = db.next_cache_idx++; 835| 0| caches.resize(db.next_cache_idx); 836| 0| } 837| 28| caches[s.cache_idx][ptr] = std::static_pointer_cast( out ); 838| | 839| 28|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 840| 28| ++db.stats().cached_objects; 841| 28|#endif 842| 28|} _ZNK6Assimp7Blender9Structure9ReadFieldILi1ENS0_10CustomDataEEEvRT0_PKcRKNS0_12FileDatabaseE: 282| 208|{ 283| 208| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 284| 208| try { 285| 208| const Field& f = (*this)[name]; 286| | // find the structure definition pertaining to this field 287| 208| const Structure& s = db.dna[f.type]; 288| | 289| 208| db.reader->IncPtr(f.offset); 290| 208| s.Convert(out,db); 291| 208| } 292| 208| catch (const Error& e) { 293| 61| _defaultInitializer()(out,e.what()); 294| 61| } 295| | 296| | // and recover the previous stream position 297| 208| db.reader->SetCurrentPos(old); 298| | 299| 207|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 300| 207| ++db.stats().fields_read; 301| 207|#endif 302| 207|} _ZNK6Assimp7Blender9Structure14ReadFieldArrayILi2EfLm3EEEvRAT1__T0_PKcRKNS0_12FileDatabaseE: 100| 18.0k|{ 101| 18.0k| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 102| 18.0k| try { 103| 18.0k| const Field& f = (*this)[name]; 104| 18.0k| const Structure& s = db.dna[f.type]; 105| | 106| | // is the input actually an array? 107| 18.0k| if (!(f.flags & FieldFlag_Array)) { ------------------ | Branch (107:13): [True: 0, False: 18.0k] ------------------ 108| 0| throw Error("Field `",name,"` of structure `",this->name,"` ought to be an array of size ",M); 109| 0| } 110| | 111| 18.0k| db.reader->IncPtr(f.offset); 112| | 113| | // size conversions are always allowed, regardless of error_policy 114| 18.0k| unsigned int i = 0; 115| 72.1k| for(; i < std::min(f.array_sizes[0],M); ++i) { ------------------ | Branch (115:15): [True: 54.0k, False: 18.0k] ------------------ 116| 54.0k| s.Convert(out[i],db); 117| 54.0k| } 118| 18.0k| for(; i < M; ++i) { ------------------ | Branch (118:15): [True: 0, False: 18.0k] ------------------ 119| 0| _defaultInitializer()(out[i]); 120| 0| } 121| 18.0k| } 122| 18.0k| catch (const Error& e) { 123| 0| _defaultInitializer()(out,e.what()); 124| 0| } 125| | 126| | // and recover the previous stream position 127| 18.0k| db.reader->SetCurrentPos(old); 128| | 129| 18.0k|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 130| 18.0k| ++db.stats().fields_read; 131| 18.0k|#endif 132| 18.0k|} _ZNK6Assimp7Blender9Structure14ReadFieldArrayILi1EfLm2EEEvRAT1__T0_PKcRKNS0_12FileDatabaseE: 100| 324|{ 101| 324| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 102| 324| try { 103| 324| const Field& f = (*this)[name]; 104| 324| const Structure& s = db.dna[f.type]; 105| | 106| | // is the input actually an array? 107| 324| if (!(f.flags & FieldFlag_Array)) { ------------------ | Branch (107:13): [True: 0, False: 324] ------------------ 108| 0| throw Error("Field `",name,"` of structure `",this->name,"` ought to be an array of size ",M); 109| 0| } 110| | 111| 324| db.reader->IncPtr(f.offset); 112| | 113| | // size conversions are always allowed, regardless of error_policy 114| 324| unsigned int i = 0; 115| 972| for(; i < std::min(f.array_sizes[0],M); ++i) { ------------------ | Branch (115:15): [True: 648, False: 324] ------------------ 116| 648| s.Convert(out[i],db); 117| 648| } 118| 324| for(; i < M; ++i) { ------------------ | Branch (118:15): [True: 0, False: 324] ------------------ 119| 0| _defaultInitializer()(out[i]); 120| 0| } 121| 324| } 122| 324| catch (const Error& e) { 123| 0| _defaultInitializer()(out,e.what()); 124| 0| } 125| | 126| | // and recover the previous stream position 127| 324| db.reader->SetCurrentPos(old); 128| | 129| 324|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 130| 324| ++db.stats().fields_read; 131| 324|#endif 132| 324|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENSt3__110shared_ptrENS0_8ElemBaseEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 268|{ 184| 268| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 268| Pointer ptrval; 186| 268| const Field* f; 187| 268| try { 188| 268| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 268| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 268] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 268| db.reader->IncPtr(f->offset); 197| 268| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 268| } 201| 268| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 268| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 268| if(!non_recursive) { ------------------ | Branch (211:8): [True: 268, False: 0] ------------------ 212| | // and recover the previous stream position 213| 268| db.reader->SetCurrentPos(old); 214| 268| } 215| | 216| 268|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 268| ++db.stats().fields_read; 218| 268|#endif 219| | 220| 268| return res; 221| 268|} _ZNK6Assimp7Blender9Structure14ReadFieldArrayILi1EcLm1024EEEvRAT1__T0_PKcRKNS0_12FileDatabaseE: 100| 290|{ 101| 290| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 102| 290| try { 103| 290| const Field& f = (*this)[name]; 104| 290| const Structure& s = db.dna[f.type]; 105| | 106| | // is the input actually an array? 107| 290| if (!(f.flags & FieldFlag_Array)) { ------------------ | Branch (107:13): [True: 0, False: 290] ------------------ 108| 0| throw Error("Field `",name,"` of structure `",this->name,"` ought to be an array of size ",M); 109| 0| } 110| | 111| 290| db.reader->IncPtr(f.offset); 112| | 113| | // size conversions are always allowed, regardless of error_policy 114| 290| unsigned int i = 0; 115| 11.7k| for(; i < std::min(f.array_sizes[0],M); ++i) { ------------------ | Branch (115:15): [True: 11.4k, False: 290] ------------------ 116| 11.4k| s.Convert(out[i],db); 117| 11.4k| } 118| 285k| for(; i < M; ++i) { ------------------ | Branch (118:15): [True: 285k, False: 290] ------------------ 119| 285k| _defaultInitializer()(out[i]); 120| 285k| } 121| 290| } 122| 290| catch (const Error& e) { 123| 0| _defaultInitializer()(out,e.what()); 124| 0| } 125| | 126| | // and recover the previous stream position 127| 290| db.reader->SetCurrentPos(old); 128| | 129| 290|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 130| 290| ++db.stats().fields_read; 131| 290|#endif 132| 290|} _ZNK6Assimp7Blender9Structure9ReadFieldILi2EcEEvRT0_PKcRKNS0_12FileDatabaseE: 282| 96|{ 283| 96| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 284| 96| try { 285| 96| const Field& f = (*this)[name]; 286| | // find the structure definition pertaining to this field 287| 96| const Structure& s = db.dna[f.type]; 288| | 289| 96| db.reader->IncPtr(f.offset); 290| 96| s.Convert(out,db); 291| 96| } 292| 96| catch (const Error& e) { 293| 0| _defaultInitializer()(out,e.what()); 294| 0| } 295| | 296| | // and recover the previous stream position 297| 96| db.reader->SetCurrentPos(old); 298| | 299| 96|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 300| 96| ++db.stats().fields_read; 301| 96|#endif 302| 96|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENSt3__110shared_ptrENS0_5WorldEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 26|{ 184| 26| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 26| Pointer ptrval; 186| 26| const Field* f; 187| 26| try { 188| 26| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 26| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 26] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 26| db.reader->IncPtr(f->offset); 197| 26| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 26| } 201| 26| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 26| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 26| if(!non_recursive) { ------------------ | Branch (211:8): [True: 26, False: 0] ------------------ 212| | // and recover the previous stream position 213| 26| db.reader->SetCurrentPos(old); 214| 26| } 215| | 216| 26|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 26| ++db.stats().fields_read; 218| 26|#endif 219| | 220| 26| return res; 221| 26|} _ZNK6Assimp7Blender9Structure14ResolvePointerINSt3__110shared_ptrENS0_5WorldEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 26|{ 413| 26| out.reset(); // ensure null pointers work 414| 26| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 0, False: 26] ------------------ 415| 0| return false; 416| 0| } 417| 26| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 26| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 26| const Structure& ss = db.dna[block->dna_index]; 424| 26| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 26] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 26| db.cache(out).get(s,out,ptrval); 432| 26| if (out) { ------------------ | Branch (432:9): [True: 0, False: 26] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 26| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 26| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 26| size_t num = block->size / ss.size; 444| 26| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 26| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 26| if (!non_recursive) { ------------------ | Branch (451:9): [True: 26, False: 0] ------------------ 452| 52| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 26, False: 26] ------------------ 453| 26| s.Convert(*o,db); 454| 26| } 455| | 456| 26| db.reader->SetCurrentPos(pold); 457| 26| } 458| | 459| 26|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 26| if(out) { ------------------ | Branch (460:8): [True: 26, False: 0] ------------------ 461| 26| ++db.stats().pointers_resolved; 462| 26| } 463| 26|#endif 464| 26| return false; 465| 26|} _ZNK6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3getINS0_5WorldEEEvRKNS0_9StructureERNS3_IT_EERKNS0_7PointerE: 807| 26|) const { 808| | 809| 26| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (809:8): [True: 26, False: 0] ------------------ 810| 26| s.cache_idx = db.next_cache_idx++; 811| 26| caches.resize(db.next_cache_idx); 812| 26| return; 813| 26| } 814| | 815| 0| typename StructureCache::const_iterator it = caches[s.cache_idx].find(ptr); 816| 0| if (it != caches[s.cache_idx].end()) { ------------------ | Branch (816:9): [True: 0, False: 0] ------------------ 817| 0| out = std::static_pointer_cast( (*it).second ); 818| | 819| 0|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 820| 0| ++db.stats().cache_hits; 821| 0|#endif 822| 0| } 823| | // otherwise, out remains untouched 824| 0|} _ZN6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3setINS0_5WorldEEEvRKNS0_9StructureERKNS3_IT_EERKNS0_7PointerE: 832| 26|) { 833| 26| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (833:8): [True: 0, False: 26] ------------------ 834| 0| s.cache_idx = db.next_cache_idx++; 835| 0| caches.resize(db.next_cache_idx); 836| 0| } 837| 26| caches[s.cache_idx][ptr] = std::static_pointer_cast( out ); 838| | 839| 26|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 840| 26| ++db.stats().cached_objects; 841| 26|#endif 842| 26|} _ZNK6Assimp7Blender9Structure14ReadFieldArrayILi1EcLm240EEEvRAT1__T0_PKcRKNS0_12FileDatabaseE: 100| 8|{ 101| 8| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 102| 8| try { 103| 8| const Field& f = (*this)[name]; 104| 8| const Structure& s = db.dna[f.type]; 105| | 106| | // is the input actually an array? 107| 8| if (!(f.flags & FieldFlag_Array)) { ------------------ | Branch (107:13): [True: 0, False: 8] ------------------ 108| 0| throw Error("Field `",name,"` of structure `",this->name,"` ought to be an array of size ",M); 109| 0| } 110| | 111| 8| db.reader->IncPtr(f.offset); 112| | 113| | // size conversions are always allowed, regardless of error_policy 114| 8| unsigned int i = 0; 115| 1.92k| for(; i < std::min(f.array_sizes[0],M); ++i) { ------------------ | Branch (115:15): [True: 1.92k, False: 8] ------------------ 116| 1.92k| s.Convert(out[i],db); 117| 1.92k| } 118| 8| for(; i < M; ++i) { ------------------ | Branch (118:15): [True: 0, False: 8] ------------------ 119| 0| _defaultInitializer()(out[i]); 120| 0| } 121| 8| } 122| 8| catch (const Error& e) { 123| 0| _defaultInitializer()(out,e.what()); 124| 0| } 125| | 126| | // and recover the previous stream position 127| 8| db.reader->SetCurrentPos(old); 128| | 129| 8|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 130| 8| ++db.stats().fields_read; 131| 8|#endif 132| 8|} _ZNK6Assimp7Blender9Structure12ReadFieldPtrILi1ENSt3__110shared_ptrENS0_10PackedFileEEEbRT0_IT1_EPKcRKNS0_12FileDatabaseEb: 183| 8|{ 184| 8| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 185| 8| Pointer ptrval; 186| 8| const Field* f; 187| 8| try { 188| 8| f = &(*this)[name]; 189| | 190| | // sanity check, should never happen if the genblenddna script is right 191| 8| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (191:13): [True: 0, False: 8] ------------------ 192| 0| throw Error("Field `",name,"` of structure `", 193| 0| this->name,"` ought to be a pointer"); 194| 0| } 195| | 196| 8| db.reader->IncPtr(f->offset); 197| 8| Convert(ptrval,db); 198| | // actually it is meaningless on which Structure the Convert is called 199| | // because the `Pointer` argument triggers a special implementation. 200| 8| } 201| 8| catch (const Error& e) { 202| 0| _defaultInitializer()(out,e.what()); 203| | 204| 0| out.reset(); 205| 0| return false; 206| 0| } 207| | 208| | // resolve the pointer and load the corresponding structure 209| 8| const bool res = ResolvePointer(out,ptrval,db,*f, non_recursive); 210| | 211| 8| if(!non_recursive) { ------------------ | Branch (211:8): [True: 8, False: 0] ------------------ 212| | // and recover the previous stream position 213| 8| db.reader->SetCurrentPos(old); 214| 8| } 215| | 216| 8|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 217| 8| ++db.stats().fields_read; 218| 8|#endif 219| | 220| 8| return res; 221| 8|} _ZNK6Assimp7Blender9Structure14ResolvePointerINSt3__110shared_ptrENS0_10PackedFileEEEbRT_IT0_ERKNS0_7PointerERKNS0_12FileDatabaseERKNS0_5FieldEb: 412| 8|{ 413| 8| out.reset(); // ensure null pointers work 414| 8| if (!ptrval.val) { ------------------ | Branch (414:9): [True: 7, False: 1] ------------------ 415| 7| return false; 416| 7| } 417| 1| const Structure& s = db.dna[f.type]; 418| | // find the file block the pointer is pointing to 419| 1| const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db); 420| | 421| | // also determine the target type from the block header 422| | // and check if it matches the type which we expect. 423| 1| const Structure& ss = db.dna[block->dna_index]; 424| 1| if (ss != s) { ------------------ | Branch (424:9): [True: 0, False: 1] ------------------ 425| 0| throw Error("Expected target to be of type `",s.name, 426| 0| "` but seemingly it is a `",ss.name,"` instead" 427| 0| ); 428| 0| } 429| | 430| | // try to retrieve the object from the cache 431| 1| db.cache(out).get(s,out,ptrval); 432| 1| if (out) { ------------------ | Branch (432:9): [True: 0, False: 1] ------------------ 433| 0| return true; 434| 0| } 435| | 436| | // seek to this location, but save the previous stream pointer. 437| 1| const StreamReaderAny::pos pold = db.reader->GetCurrentPos(); 438| 1| db.reader->SetCurrentPos(block->start+ static_cast((ptrval.val - block->address.val) )); 439| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 440| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 441| | 442| | // continue conversion after allocating the required storage 443| 1| size_t num = block->size / ss.size; 444| 1| T* o = _allocate(out,num); 445| | 446| | // cache the object before we convert it to avoid cyclic recursion. 447| 1| db.cache(out).set(s,out,ptrval); 448| | 449| | // if the non_recursive flag is set, we don't do anything but leave 450| | // the cursor at the correct position to resolve the object. 451| 1| if (!non_recursive) { ------------------ | Branch (451:9): [True: 1, False: 0] ------------------ 452| 2| for (size_t i = 0; i < num; ++i,++o) { ------------------ | Branch (452:28): [True: 1, False: 1] ------------------ 453| 1| s.Convert(*o,db); 454| 1| } 455| | 456| 1| db.reader->SetCurrentPos(pold); 457| 1| } 458| | 459| 1|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 460| 1| if(out) { ------------------ | Branch (460:8): [True: 1, False: 0] ------------------ 461| 1| ++db.stats().pointers_resolved; 462| 1| } 463| 1|#endif 464| 1| return false; 465| 1|} _ZNK6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3getINS0_10PackedFileEEEvRKNS0_9StructureERNS3_IT_EERKNS0_7PointerE: 807| 1|) const { 808| | 809| 1| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (809:8): [True: 1, False: 0] ------------------ 810| 1| s.cache_idx = db.next_cache_idx++; 811| 1| caches.resize(db.next_cache_idx); 812| 1| return; 813| 1| } 814| | 815| 0| typename StructureCache::const_iterator it = caches[s.cache_idx].find(ptr); 816| 0| if (it != caches[s.cache_idx].end()) { ------------------ | Branch (816:9): [True: 0, False: 0] ------------------ 817| 0| out = std::static_pointer_cast( (*it).second ); 818| | 819| 0|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 820| 0| ++db.stats().cache_hits; 821| 0|#endif 822| 0| } 823| | // otherwise, out remains untouched 824| 0|} _ZN6Assimp7Blender11ObjectCacheINSt3__110shared_ptrEE3setINS0_10PackedFileEEEvRKNS0_9StructureERKNS3_IT_EERKNS0_7PointerE: 832| 1|) { 833| 1| if(s.cache_idx == static_cast(-1)) { ------------------ | Branch (833:8): [True: 0, False: 1] ------------------ 834| 0| s.cache_idx = db.next_cache_idx++; 835| 0| caches.resize(db.next_cache_idx); 836| 0| } 837| 1| caches[s.cache_idx][ptr] = std::static_pointer_cast( out ); 838| | 839| 1|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 840| 1| ++db.stats().cached_objects; 841| 1|#endif 842| 1|} _ZNK6Assimp7Blender9Structure14ReadFieldArrayILi1EiLm42EEEvRAT1__T0_PKcRKNS0_12FileDatabaseE: 100| 148|{ 101| 148| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 102| 148| try { 103| 148| const Field& f = (*this)[name]; 104| 148| const Structure& s = db.dna[f.type]; 105| | 106| | // is the input actually an array? 107| 148| if (!(f.flags & FieldFlag_Array)) { ------------------ | Branch (107:13): [True: 0, False: 148] ------------------ 108| 0| throw Error("Field `",name,"` of structure `",this->name,"` ought to be an array of size ",M); 109| 0| } 110| | 111| 148| db.reader->IncPtr(f.offset); 112| | 113| | // size conversions are always allowed, regardless of error_policy 114| 148| unsigned int i = 0; 115| 2.48k| for(; i < std::min(f.array_sizes[0],M); ++i) { ------------------ | Branch (115:15): [True: 2.34k, False: 148] ------------------ 116| 2.34k| s.Convert(out[i],db); 117| 2.34k| } 118| 243| for(; i < M; ++i) { ------------------ | Branch (118:15): [True: 95, False: 148] ------------------ 119| 95| _defaultInitializer()(out[i]); 120| 95| } 121| 148| } 122| 148| catch (const Error& e) { 123| 90| _defaultInitializer()(out,e.what()); 124| 90| } 125| | 126| | // and recover the previous stream position 127| 148| db.reader->SetCurrentPos(old); 128| | 129| 148|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 130| 148| ++db.stats().fields_read; 131| 148|#endif 132| 148|} _ZNK6Assimp7Blender9Structure18ReadFieldPtrVectorILi1ENSt3__110shared_ptrENS0_15CustomDataLayerEEEbRNS0_6vectorIT0_IT1_EEEPKcRKNS0_12FileDatabaseE: 354| 148|bool Structure::ReadFieldPtrVector(vector>&out, const char* name, const FileDatabase& db) const { 355| 148| out.clear(); 356| | 357| 148| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 358| | 359| 148| Pointer ptrval; 360| 148| const Field* f; 361| 148| try { 362| 148| f = &(*this)[name]; 363| | 364| | // sanity check, should never happen if the genblenddna script is right 365| 148| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (365:7): [True: 0, False: 148] ------------------ 366| 0| throw Error("Field `", name, "` of structure `", 367| 0| this->name, "` ought to be a pointer"); 368| 0| } 369| | 370| 148| db.reader->IncPtr(f->offset); 371| 148| Convert(ptrval, db); 372| | // actually it is meaningless on which Structure the Convert is called 373| | // because the `Pointer` argument triggers a special implementation. 374| 148| } 375| 148| catch (const Error& e) { 376| 0| _defaultInitializer()(out, e.what()); 377| 0| out.clear(); 378| 0| return false; 379| 0| } 380| | 381| | 382| 148| if (ptrval.val) { ------------------ | Branch (382:6): [True: 137, False: 11] ------------------ 383| | // find the file block the pointer is pointing to 384| 137| const FileBlockHead* block = LocateFileBlockForAddress(ptrval, db); 385| 137| db.reader->SetCurrentPos(block->start + static_cast((ptrval.val - block->address.val))); 386| | // FIXME: basically, this could cause problems with 64 bit pointers on 32 bit systems. 387| | // I really ought to improve StreamReader to work with 64 bit indices exclusively. 388| | 389| 137| const Structure& s = db.dna[f->type]; 390| 732| for (size_t i = 0; i < block->num; ++i) { ------------------ | Branch (390:22): [True: 595, False: 137] ------------------ 391| 595| TOUT p(new T); 392| 595| s.Convert(*p, db); 393| 595| out.push_back(p); 394| 595| } 395| 137| } 396| | 397| 148| db.reader->SetCurrentPos(old); 398| | 399| 148|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 400| 148| ++db.stats().fields_read; 401| 148|#endif 402| | 403| 148| return true; 404| 148|} _ZNK6Assimp7Blender9Structure14ReadFieldArrayILi1EcLm64EEEvRAT1__T0_PKcRKNS0_12FileDatabaseE: 100| 595|{ 101| 595| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 102| 595| try { 103| 595| const Field& f = (*this)[name]; 104| 595| const Structure& s = db.dna[f.type]; 105| | 106| | // is the input actually an array? 107| 595| if (!(f.flags & FieldFlag_Array)) { ------------------ | Branch (107:13): [True: 0, False: 595] ------------------ 108| 0| throw Error("Field `",name,"` of structure `",this->name,"` ought to be an array of size ",M); 109| 0| } 110| | 111| 595| db.reader->IncPtr(f.offset); 112| | 113| | // size conversions are always allowed, regardless of error_policy 114| 595| unsigned int i = 0; 115| 24.2k| for(; i < std::min(f.array_sizes[0],M); ++i) { ------------------ | Branch (115:15): [True: 23.6k, False: 595] ------------------ 116| 23.6k| s.Convert(out[i],db); 117| 23.6k| } 118| 14.9k| for(; i < M; ++i) { ------------------ | Branch (118:15): [True: 14.4k, False: 595] ------------------ 119| 14.4k| _defaultInitializer()(out[i]); 120| 14.4k| } 121| 595| } 122| 595| catch (const Error& e) { 123| 0| _defaultInitializer()(out,e.what()); 124| 0| } 125| | 126| | // and recover the previous stream position 127| 595| db.reader->SetCurrentPos(old); 128| | 129| 595|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 130| 595| ++db.stats().fields_read; 131| 595|#endif 132| 595|} _ZNK6Assimp7Blender9Structure17ReadCustomDataPtrILi2EEEbRNSt3__110shared_ptrINS0_8ElemBaseEEEiPKcRKNS0_12FileDatabaseE: 308| 595|bool Structure::ReadCustomDataPtr(std::shared_ptr&out, int cdtype, const char* name, const FileDatabase& db) const { 309| | 310| 595| const StreamReaderAny::pos old = db.reader->GetCurrentPos(); 311| | 312| 595| Pointer ptrval; 313| 595| const Field* f; 314| 595| try { 315| 595| f = &(*this)[name]; 316| | 317| | // sanity check, should never happen if the genblenddna script is right 318| 595| if (!(f->flags & FieldFlag_Pointer)) { ------------------ | Branch (318:7): [True: 0, False: 595] ------------------ 319| 0| throw Error("Field `", name, "` of structure `", 320| 0| this->name, "` ought to be a pointer"); 321| 0| } 322| | 323| 595| db.reader->IncPtr(f->offset); 324| 595| Convert(ptrval, db); 325| | // actually it is meaningless on which Structure the Convert is called 326| | // because the `Pointer` argument triggers a special implementation. 327| 595| } 328| 595| catch (const Error& e) { 329| 0| _defaultInitializer()(out, e.what()); 330| 0| out.reset(); 331| 0| } 332| | 333| 595| bool readOk = true; 334| 595| if (ptrval.val) { ------------------ | Branch (334:6): [True: 152, False: 443] ------------------ 335| | // get block for ptr 336| 152| const FileBlockHead* block = LocateFileBlockForAddress(ptrval, db); 337| 152| db.reader->SetCurrentPos(block->start + static_cast((ptrval.val - block->address.val))); 338| | // read block->num instances of given type to out 339| 152| readOk = readCustomData(out, cdtype, block->num, db); 340| 152| } 341| | 342| | // and recover the previous stream position 343| 595| db.reader->SetCurrentPos(old); 344| | 345| 595|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 346| 595| ++db.stats().fields_read; 347| 595|#endif 348| | 349| 595| return readOk; 350| 595|} _ZNK6Assimp7Blender9Structure8AllocateINS0_19SubsurfModifierDataEEENSt3__110shared_ptrINS0_8ElemBaseEEEv: 85| 4|{ 86| 4| return std::shared_ptr(new T()); 87| 4|} _ZNK6Assimp7Blender9Structure7ConvertINS0_19SubsurfModifierDataEEEvNSt3__110shared_ptrINS0_8ElemBaseEEERKNS0_12FileDatabaseE: 93| 4|{ 94| 4| Convert (*static_cast ( in.get() ),db); 95| 4|} _ZNK6Assimp7Blender9Structure8AllocateINS0_4LampEEENSt3__110shared_ptrINS0_8ElemBaseEEEv: 85| 31|{ 86| 31| return std::shared_ptr(new T()); 87| 31|} _ZNK6Assimp7Blender9Structure7ConvertINS0_4LampEEEvNSt3__110shared_ptrINS0_8ElemBaseEEERKNS0_12FileDatabaseE: 93| 31|{ 94| 31| Convert (*static_cast ( in.get() ),db); 95| 31|} _ZNK6Assimp7Blender9Structure8AllocateINS0_4BaseEEENSt3__110shared_ptrINS0_8ElemBaseEEEv: 85| 8|{ 86| 8| return std::shared_ptr(new T()); 87| 8|} _ZNK6Assimp7Blender9Structure7ConvertINS0_4BaseEEEvNSt3__110shared_ptrINS0_8ElemBaseEEERKNS0_12FileDatabaseE: 93| 8|{ 94| 8| Convert (*static_cast ( in.get() ),db); 95| 8|} _ZNK6Assimp7Blender9Structure8AllocateINS0_4MeshEEENSt3__110shared_ptrINS0_8ElemBaseEEEv: 85| 42|{ 86| 42| return std::shared_ptr(new T()); 87| 42|} _ZNK6Assimp7Blender9Structure7ConvertINS0_4MeshEEEvNSt3__110shared_ptrINS0_8ElemBaseEEERKNS0_12FileDatabaseE: 93| 42|{ 94| 42| Convert (*static_cast ( in.get() ),db); 95| 42|} _ZNK6Assimp7Blender9Structure8AllocateINS0_6CameraEEENSt3__110shared_ptrINS0_8ElemBaseEEEv: 85| 27|{ 86| 27| return std::shared_ptr(new T()); 87| 27|} _ZNK6Assimp7Blender9Structure7ConvertINS0_6CameraEEEvNSt3__110shared_ptrINS0_8ElemBaseEEERKNS0_12FileDatabaseE: 93| 27|{ 94| 27| Convert (*static_cast ( in.get() ),db); 95| 27|} _ZNK6Assimp7Blender9Structure8AllocateINS0_18MirrorModifierDataEEENSt3__110shared_ptrINS0_8ElemBaseEEEv: 85| 2|{ 86| 2| return std::shared_ptr(new T()); 87| 2|} _ZNK6Assimp7Blender9Structure7ConvertINS0_18MirrorModifierDataEEEvNSt3__110shared_ptrINS0_8ElemBaseEEERKNS0_12FileDatabaseE: 93| 2|{ 94| 2| Convert (*static_cast ( in.get() ),db); 95| 2|} _ZNK6Assimp7Blender9Structure8AllocateINS0_15CollectionChildEEENSt3__110shared_ptrINS0_8ElemBaseEEEv: 85| 1|{ 86| 1| return std::shared_ptr(new T()); 87| 1|} _ZNK6Assimp7Blender9Structure7ConvertINS0_15CollectionChildEEEvNSt3__110shared_ptrINS0_8ElemBaseEEERKNS0_12FileDatabaseE: 93| 1|{ 94| 1| Convert (*static_cast ( in.get() ),db); 95| 1|} _ZNK6Assimp7Blender9Structure8AllocateINS0_16CollectionObjectEEENSt3__110shared_ptrINS0_8ElemBaseEEEv: 85| 1|{ 86| 1| return std::shared_ptr(new T()); 87| 1|} _ZNK6Assimp7Blender9Structure7ConvertINS0_16CollectionObjectEEEvNSt3__110shared_ptrINS0_8ElemBaseEEERKNS0_12FileDatabaseE: 93| 1|{ 94| 1| Convert (*static_cast ( in.get() ),db); 95| 1|} _ZN6Assimp7Blender9TempArrayINSt3__16vectorENS0_15BlenderModifierEEC2Ev: 67| 624| TempArray() = default; _ZN6Assimp7Blender9TempArrayINSt3__16vectorENS0_15BlenderModifierEED2Ev: 69| 624| ~TempArray () { 70| 624| for(T* elem : arr) { ------------------ | Branch (70:25): [True: 9, False: 624] ------------------ 71| 9| delete elem; 72| 9| } 73| 624| } _ZN6Assimp7Blender14ConversionDataC2ERKNS0_12FileDatabaseE: 143| 25| , db(db) 144| 25| {} _ZN6Assimp7Blender9TempArrayINSt3__16vectorE6aiMeshEC2Ev: 67| 25| TempArray() = default; _ZN6Assimp7Blender9TempArrayINSt3__16vectorE8aiCameraEC2Ev: 67| 25| TempArray() = default; _ZN6Assimp7Blender9TempArrayINSt3__16vectorE7aiLightEC2Ev: 67| 25| TempArray() = default; _ZN6Assimp7Blender9TempArrayINSt3__16vectorE10aiMaterialEC2Ev: 67| 25| TempArray() = default; _ZN6Assimp7Blender9TempArrayINSt3__16vectorE9aiTextureEC2Ev: 67| 25| TempArray() = default; _ZN6Assimp7Blender9TempArrayINSt3__16vectorE9aiTextureED2Ev: 69| 25| ~TempArray () { 70| 25| for(T* elem : arr) { ------------------ | Branch (70:25): [True: 0, False: 25] ------------------ 71| 0| delete elem; 72| 0| } 73| 25| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE10aiMaterialED2Ev: 69| 25| ~TempArray () { 70| 25| for(T* elem : arr) { ------------------ | Branch (70:25): [True: 0, False: 25] ------------------ 71| 0| delete elem; 72| 0| } 73| 25| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE7aiLightED2Ev: 69| 25| ~TempArray () { 70| 25| for(T* elem : arr) { ------------------ | Branch (70:25): [True: 0, False: 25] ------------------ 71| 0| delete elem; 72| 0| } 73| 25| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE8aiCameraED2Ev: 69| 25| ~TempArray () { 70| 25| for(T* elem : arr) { ------------------ | Branch (70:25): [True: 0, False: 25] ------------------ 71| 0| delete elem; 72| 0| } 73| 25| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE6aiMeshED2Ev: 69| 25| ~TempArray () { 70| 25| for(T* elem : arr) { ------------------ | Branch (70:25): [True: 0, False: 25] ------------------ 71| 0| delete elem; 72| 0| } 73| 25| } _ZN6Assimp7Blender27GetTextureTypeDisplayStringENS0_3Tex4TypeE: 180| 1|{ 181| 1| switch (t) { 182| 0| case Tex::Type_CLOUDS : return "Clouds"; ------------------ | Branch (182:5): [True: 0, False: 1] ------------------ 183| 0| case Tex::Type_WOOD : return "Wood"; ------------------ | Branch (183:5): [True: 0, False: 1] ------------------ 184| 0| case Tex::Type_MARBLE : return "Marble"; ------------------ | Branch (184:5): [True: 0, False: 1] ------------------ 185| 0| case Tex::Type_MAGIC : return "Magic"; ------------------ | Branch (185:5): [True: 0, False: 1] ------------------ 186| 0| case Tex::Type_BLEND : return "Blend"; ------------------ | Branch (186:5): [True: 0, False: 1] ------------------ 187| 0| case Tex::Type_STUCCI : return "Stucci"; ------------------ | Branch (187:5): [True: 0, False: 1] ------------------ 188| 0| case Tex::Type_NOISE : return "Noise"; ------------------ | Branch (188:5): [True: 0, False: 1] ------------------ 189| 0| case Tex::Type_PLUGIN : return "Plugin"; ------------------ | Branch (189:5): [True: 0, False: 1] ------------------ 190| 0| case Tex::Type_MUSGRAVE : return "Musgrave"; ------------------ | Branch (190:5): [True: 0, False: 1] ------------------ 191| 1| case Tex::Type_VORONOI : return "Voronoi"; ------------------ | Branch (191:5): [True: 1, False: 0] ------------------ 192| 0| case Tex::Type_DISTNOISE : return "DistortedNoise"; ------------------ | Branch (192:5): [True: 0, False: 1] ------------------ 193| 0| case Tex::Type_ENVMAP : return "EnvMap"; ------------------ | Branch (193:5): [True: 0, False: 1] ------------------ 194| 0| case Tex::Type_IMAGE : return "Image"; ------------------ | Branch (194:5): [True: 0, False: 1] ------------------ 195| 0| default: ------------------ | Branch (195:5): [True: 0, False: 1] ------------------ 196| 0| break; 197| 1| } 198| 0| return ""; 199| 1|} _ZNK6Assimp7Blender13ObjectCompareclEPKNS0_6ObjectES4_: 126| 69| bool operator() (const Object* left, const Object* right) const { 127| 69| return ::strncmp(left->id.name, right->id.name, strlen( left->id.name ) ) < 0; 128| 69| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE6aiMeshEptEv: 79| 491| mywrap* operator -> () { 80| 491| return &arr; 81| 491| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE6aiMeshE7dismissEv: 75| 25| void dismiss() { 76| 25| arr.clear(); 77| 25| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE7aiLightEptEv: 79| 131| mywrap* operator -> () { 80| 131| return &arr; 81| 131| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE7aiLightE7dismissEv: 75| 25| void dismiss() { 76| 25| arr.clear(); 77| 25| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE8aiCameraEptEv: 79| 126| mywrap* operator -> () { 80| 126| return &arr; 81| 126| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE8aiCameraE7dismissEv: 75| 25| void dismiss() { 76| 25| arr.clear(); 77| 25| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE10aiMaterialEptEv: 79| 156| mywrap* operator -> () { 80| 156| return &arr; 81| 156| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE10aiMaterialE7dismissEv: 75| 25| void dismiss() { 76| 25| arr.clear(); 77| 25| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE9aiTextureEptEv: 79| 31| mywrap* operator -> () { 80| 31| return &arr; 81| 31| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE9aiTextureE7dismissEv: 75| 1| void dismiss() { 76| 1| arr.clear(); 77| 1| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE6aiMeshE3getEv: 91| 25| mywrap& get () { 92| 25| return arr; 93| 25| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorE6aiMeshEixEm: 103| 8.24k| T*& operator[] (size_t idx) { 104| 8.24k| return arr[idx]; 105| 8.24k| } _ZN6Assimp7Blender9TempArrayINSt3__16vectorENS0_15BlenderModifierEEptEv: 79| 30| mywrap* operator -> () { 80| 30| return &arr; 81| 30| } _ZN6Assimp15BlenderImporterC2Ev: 101| 624| modifier_cache(new BlenderModifierShowcase()) { 102| | // empty 103| 624|} _ZN6Assimp15BlenderImporterD2Ev: 107| 624|BlenderImporter::~BlenderImporter() { 108| 624| delete modifier_cache; 109| 624|} _ZNK6Assimp15BlenderImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 115| 99|bool BlenderImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 116| 99| return ParseMagicToken(pFile, pIOHandler).error.empty(); 117| 99|} _ZNK6Assimp15BlenderImporter7GetInfoEv: 121| 666|const aiImporterDesc *BlenderImporter::GetInfo() const { 122| 666| return &blenderDesc; 123| 666|} _ZN6Assimp15BlenderImporter15SetupPropertiesEPKNS_8ImporterE: 127| 32|void BlenderImporter::SetupProperties(const Importer * /*pImp*/) { 128| | // nothing to be done for the moment 129| 32|} _ZN6Assimp15BlenderImporter14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 134| 32| aiScene *pScene, IOSystem *pIOHandler) { 135| 32| FileDatabase file; 136| 32| StreamOrError streamOrError = ParseMagicToken(pFile, pIOHandler); 137| 32| if (!streamOrError.error.empty()) { ------------------ | Branch (137:9): [True: 0, False: 32] ------------------ 138| 0| ThrowException(streamOrError.error); 139| 0| } 140| 32| std::shared_ptr stream = std::move(streamOrError.stream); 141| | 142| 32| char version[4] = { 0 }; 143| 32| file.i64bit = (stream->Read(version, 1, 1), version[0] == '-'); 144| 32| file.little = (stream->Read(version, 1, 1), version[0] == 'v'); 145| | 146| 32| stream->Read(version, 3, 1); 147| 32| version[3] = '\0'; 148| | 149| 32| LogInfo("Blender version is ", version[0], ".", version + 1, 150| 32| " (64bit: ", file.i64bit ? "true" : "false", ------------------ | Branch (150:26): [True: 15, False: 17] ------------------ 151| 32| ", little endian: ", file.little ? "true" : "false", ")"); ------------------ | Branch (151:34): [True: 31, False: 1] ------------------ 152| | 153| 32| ParseBlendFile(file, std::move(stream)); 154| | 155| 32| Scene scene; 156| 32| ExtractScene(scene, file); 157| | 158| 32| ConvertBlendFile(pScene, scene, file); 159| 32|} _ZN6Assimp15BlenderImporter14ParseBlendFileERNS_7Blender12FileDatabaseENSt3__110shared_ptrINS_8IOStreamEEE: 162| 32|void BlenderImporter::ParseBlendFile(FileDatabase &out, std::shared_ptr stream) { 163| 32| out.reader = std::make_shared(stream, out.little); 164| | 165| 32| DNAParser dna_reader(out); 166| 32| const DNA *dna = nullptr; 167| | 168| 32| out.entries.reserve(128); 169| 32| { // even small BLEND files tend to consist of many file blocks 170| 32| SectionParser parser(*out.reader, out.i64bit); 171| | 172| | // first parse the file in search for the DNA and insert all other sections into the database 173| 21.5k| while ((parser.Next(), 1)) { ------------------ | Branch (173:16): [True: 21.5k, False: 6] ------------------ 174| 21.5k| const FileBlockHead &head = parser.GetCurrent(); 175| | 176| 21.5k| if (head.id == "ENDB") { ------------------ | Branch (176:17): [True: 26, False: 21.5k] ------------------ 177| 26| break; // only valid end of the file 178| 21.5k| } else if (head.id == "DNA1") { ------------------ | Branch (178:24): [True: 28, False: 21.4k] ------------------ 179| 28| dna_reader.Parse(); 180| 28| dna = &dna_reader.GetDNA(); 181| 28| continue; 182| 28| } 183| | 184| 21.4k| out.entries.push_back(head); 185| 21.4k| } 186| 32| } 187| 32| if (!dna) { ------------------ | Branch (187:9): [True: 0, False: 32] ------------------ 188| 0| ThrowException("SDNA not found"); 189| 0| } 190| | 191| 32| std::sort(out.entries.begin(), out.entries.end()); 192| 32|} _ZN6Assimp15BlenderImporter12ExtractSceneERNS_7Blender5SceneERKNS1_12FileDatabaseE: 195| 26|void BlenderImporter::ExtractScene(Scene &out, const FileDatabase &file) { 196| 26| const FileBlockHead *block = nullptr; 197| 26| std::map::const_iterator it = file.dna.indices.find("Scene"); 198| 26| if (it == file.dna.indices.end()) { ------------------ | Branch (198:9): [True: 0, False: 26] ------------------ 199| 0| ThrowException("There is no `Scene` structure record"); 200| 0| } 201| | 202| 26| const Structure &ss = file.dna.structures[(*it).second]; 203| | 204| | // we need a scene somewhere to start with. 205| 13.0k| for (const FileBlockHead &bl : file.entries) { ------------------ | Branch (205:34): [True: 13.0k, False: 0] ------------------ 206| | 207| | // Fix: using the DNA index is more reliable to locate scenes 208| | //if (bl.id == "SC") { 209| | 210| 13.0k| if (bl.dna_index == (*it).second) { ------------------ | Branch (210:13): [True: 26, False: 13.0k] ------------------ 211| 26| block = &bl; 212| 26| break; 213| 26| } 214| 13.0k| } 215| | 216| 26| if (!block) { ------------------ | Branch (216:9): [True: 0, False: 26] ------------------ 217| 0| ThrowException("There is not a single `Scene` record to load"); 218| 0| } 219| | 220| 26| file.reader->SetCurrentPos(block->start); 221| 26| ss.Convert(out, file); 222| | 223| 26|#ifndef ASSIMP_BUILD_BLENDER_NO_STATS 224| | ASSIMP_LOG_INFO( 225| 26| "(Stats) Fields read: ", file.stats().fields_read, 226| 26| ", pointers resolved: ", file.stats().pointers_resolved, 227| 26| ", cache hits: ", file.stats().cache_hits, 228| 26| ", cached objects: ", file.stats().cached_objects); 229| 26|#endif 230| 26|} _ZN6Assimp15BlenderImporter18ParseSubCollectionERKNS_7Blender5SceneEP6aiNodeRKNSt3__110shared_ptrINS1_10CollectionEEERNS1_14ConversionDataE: 233| 2|void BlenderImporter::ParseSubCollection(const Blender::Scene &in, aiNode *root, const std::shared_ptr& collection, ConversionData &conv_data) { 234| | 235| 2| std::deque root_objects; 236| | // Count number of objects 237| 5| for (std::shared_ptr cur = std::static_pointer_cast(collection->gobject.first); cur; cur = cur->next) { ------------------ | Branch (237:121): [True: 3, False: 2] ------------------ 238| 3| if (cur->ob) { ------------------ | Branch (238:13): [True: 3, False: 0] ------------------ 239| 3| root_objects.push_back(cur->ob); 240| 3| } 241| 3| } 242| 2| std::deque root_children; 243| | // Count number of child nodes 244| 3| for (std::shared_ptr cur = std::static_pointer_cast(collection->children.first); cur; cur = cur->next) { ------------------ | Branch (244:120): [True: 1, False: 2] ------------------ 245| 1| if (cur->collection) { ------------------ | Branch (245:13): [True: 1, False: 0] ------------------ 246| 1| root_children.push_back(cur->collection.get()); 247| 1| } 248| 1| } 249| 2| root->mNumChildren = static_cast(root_objects.size() + root_children.size()); 250| 2| root->mChildren = new aiNode *[root->mNumChildren](); 251| | 252| 5| for (unsigned int i = 0; i < static_cast(root_objects.size()); ++i) { ------------------ | Branch (252:30): [True: 3, False: 2] ------------------ 253| 3| root->mChildren[i] = ConvertNode(in, root_objects[i], conv_data, aiMatrix4x4()); 254| 3| root->mChildren[i]->mParent = root; 255| 3| } 256| | 257| | // For each subcollection create a new node to represent it 258| 2| unsigned int iterator = static_cast(root_objects.size()); 259| 3| for (std::shared_ptr cur = std::static_pointer_cast(collection->children.first); cur; cur = cur->next) { ------------------ | Branch (259:120): [True: 1, False: 2] ------------------ 260| 1| if (cur->collection) { ------------------ | Branch (260:13): [True: 1, False: 0] ------------------ 261| 1| root->mChildren[iterator] = new aiNode(cur->collection->id.name + 2); // skip over the name prefix 'OB' 262| 1| root->mChildren[iterator]->mParent = root; 263| 1| ParseSubCollection(in, root->mChildren[iterator], cur->collection, conv_data); 264| 1| } 265| 1| iterator += 1; 266| 1| } 267| 2|} _ZN6Assimp15BlenderImporter16ConvertBlendFileEP7aiSceneRKNS_7Blender5SceneERKNS3_12FileDatabaseE: 270| 25|void BlenderImporter::ConvertBlendFile(aiScene *out, const Scene &in, const FileDatabase &file) { 271| 25| ConversionData conv(file); 272| | 273| 25| aiNode *root = out->mRootNode = new aiNode(""); 274| | // Iterate over all objects directly under master_collection, 275| | // If in.master_collection == null, then we're parsing something older. 276| 25| if (in.master_collection) { ------------------ | Branch (276:9): [True: 1, False: 24] ------------------ 277| 1| ParseSubCollection(in, root, in.master_collection, conv); 278| 24| } else { 279| 24| std::deque no_parents; 280| 119| for (std::shared_ptr cur = std::static_pointer_cast(in.base.first); cur; cur = cur->next) { ------------------ | Branch (280:89): [True: 95, False: 24] ------------------ 281| 95| if (cur->object) { ------------------ | Branch (281:17): [True: 95, False: 0] ------------------ 282| 95| if (!cur->object->parent) { ------------------ | Branch (282:21): [True: 86, False: 9] ------------------ 283| 86| no_parents.push_back(cur->object.get()); 284| 86| } else { 285| 9| conv.objects.insert(cur->object.get()); 286| 9| } 287| 95| } 288| 95| } 289| 102| for (std::shared_ptr cur = in.basact; cur; cur = cur->next) { ------------------ | Branch (289:53): [True: 78, False: 24] ------------------ 290| 78| if (cur->object) { ------------------ | Branch (290:17): [True: 78, False: 0] ------------------ 291| 78| if (cur->object->parent) { ------------------ | Branch (291:21): [True: 9, False: 69] ------------------ 292| 9| conv.objects.insert(cur->object.get()); 293| 9| } 294| 78| } 295| 78| } 296| | 297| 24| if (no_parents.empty()) { ------------------ | Branch (297:13): [True: 0, False: 24] ------------------ 298| 0| ThrowException("Expected at least one object with no parent"); 299| 0| } 300| | 301| 24| root->mNumChildren = static_cast(no_parents.size()); 302| 24| root->mChildren = new aiNode *[root->mNumChildren](); 303| 110| for (unsigned int i = 0; i < root->mNumChildren; ++i) { ------------------ | Branch (303:34): [True: 86, False: 24] ------------------ 304| 86| root->mChildren[i] = ConvertNode(in, no_parents[i], conv, aiMatrix4x4()); 305| 86| root->mChildren[i]->mParent = root; 306| 86| } 307| 24| } 308| | 309| 25| BuildMaterials(conv); 310| | 311| 25| if (conv.meshes->size()) { ------------------ | Branch (311:9): [True: 25, False: 0] ------------------ 312| 25| out->mMeshes = new aiMesh *[out->mNumMeshes = static_cast(conv.meshes->size())]; 313| 25| std::copy(conv.meshes->begin(), conv.meshes->end(), out->mMeshes); 314| 25| conv.meshes.dismiss(); 315| 25| } 316| | 317| 25| if (conv.lights->size()) { ------------------ | Branch (317:9): [True: 25, False: 0] ------------------ 318| 25| out->mLights = new aiLight *[out->mNumLights = static_cast(conv.lights->size())]; 319| 25| std::copy(conv.lights->begin(), conv.lights->end(), out->mLights); 320| 25| conv.lights.dismiss(); 321| 25| } 322| | 323| 25| if (conv.cameras->size()) { ------------------ | Branch (323:9): [True: 25, False: 0] ------------------ 324| 25| out->mCameras = new aiCamera *[out->mNumCameras = static_cast(conv.cameras->size())]; 325| 25| std::copy(conv.cameras->begin(), conv.cameras->end(), out->mCameras); 326| 25| conv.cameras.dismiss(); 327| 25| } 328| | 329| 25| if (conv.materials->size()) { ------------------ | Branch (329:9): [True: 25, False: 0] ------------------ 330| 25| out->mMaterials = new aiMaterial *[out->mNumMaterials = static_cast(conv.materials->size())]; 331| 25| std::copy(conv.materials->begin(), conv.materials->end(), out->mMaterials); 332| 25| conv.materials.dismiss(); 333| 25| } 334| | 335| 25| if (conv.textures->size()) { ------------------ | Branch (335:9): [True: 1, False: 24] ------------------ 336| 1| out->mTextures = new aiTexture *[out->mNumTextures = static_cast(conv.textures->size())]; 337| 1| std::copy(conv.textures->begin(), conv.textures->end(), out->mTextures); 338| 1| conv.textures.dismiss(); 339| 1| } 340| | 341| | // acknowledge that the scene might come out incomplete 342| | // by Assimp's definition of `complete`: blender scenes 343| | // can consist of thousands of cameras or lights with 344| | // not a single mesh between them. 345| 25| if (!out->mNumMeshes) { ------------------ | Branch (345:9): [True: 0, False: 25] ------------------ 346| | out->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; 347| 0| } 348| 25|} _ZN6Assimp15BlenderImporter12ResolveImageEP10aiMaterialPKNS_7Blender8MaterialEPKNS3_4MTexEPKNS3_5ImageERNS3_14ConversionDataE: 351| 9|void BlenderImporter::ResolveImage(aiMaterial *out, const Material *mat, const MTex *tex, const Image *img, ConversionData &conv_data) { 352| 9| (void)mat; 353| 9| (void)tex; 354| 9| (void)conv_data; 355| 9| aiString name; 356| | 357| | // check if the file contents are bundled with the BLEND file 358| 9| if (img->packedfile) { ------------------ | Branch (358:9): [True: 1, False: 8] ------------------ 359| 1| name.data[0] = '*'; 360| 1| name.length = 1 + ASSIMP_itoa10(name.data + 1, static_cast(AI_MAXLEN - 1), static_cast(conv_data.textures->size())); 361| | 362| 1| conv_data.textures->push_back(new aiTexture()); 363| 1| aiTexture *curTex = conv_data.textures->back(); 364| | 365| | // usually 'img->name' will be the original file name of the embedded textures, 366| | // so we can extract the file extension from it. 367| 1| const size_t nlen = strlen(img->name); 368| 1| const char *s = img->name + nlen, *e = s; 369| 5| while (s >= img->name && *s != '.') { ------------------ | Branch (369:16): [True: 5, False: 0] | Branch (369:34): [True: 4, False: 1] ------------------ 370| 4| --s; 371| 4| } 372| | 373| 1| curTex->achFormatHint[0] = s + 1 > e ? '\0' : (char)::tolower((unsigned char)s[1]); ------------------ | Branch (373:36): [True: 0, False: 1] ------------------ 374| 1| curTex->achFormatHint[1] = s + 2 > e ? '\0' : (char)::tolower((unsigned char)s[2]); ------------------ | Branch (374:36): [True: 0, False: 1] ------------------ 375| 1| curTex->achFormatHint[2] = s + 3 > e ? '\0' : (char)::tolower((unsigned char)s[3]); ------------------ | Branch (375:36): [True: 0, False: 1] ------------------ 376| 1| curTex->achFormatHint[3] = '\0'; 377| | 378| | // tex->mHeight = 0; 379| 1| curTex->mWidth = img->packedfile->size; 380| 1| uint8_t *ch = new uint8_t[curTex->mWidth]; 381| | 382| 1| conv_data.db.reader->SetCurrentPos(static_cast(img->packedfile->data->val)); 383| 1| conv_data.db.reader->CopyAndAdvance(ch, curTex->mWidth); 384| | 385| 1| curTex->pcData = reinterpret_cast(ch); 386| | 387| 1| LogInfo("Reading embedded texture, original file was ", img->name); 388| 8| } else { 389| 8| name = aiString(img->name); 390| 8| } 391| | 392| 9| aiTextureType texture_type = aiTextureType_UNKNOWN; 393| 9| MTex::MapType map_type = tex->mapto; 394| | 395| 9| if (map_type & MTex::MapType_COL) ------------------ | Branch (395:9): [True: 8, False: 1] ------------------ 396| 8| texture_type = aiTextureType_DIFFUSE; 397| 1| else if (map_type & MTex::MapType_NORM) { ------------------ | Branch (397:14): [True: 0, False: 1] ------------------ 398| 0| if (tex->tex->imaflag & Tex::ImageFlags_NORMALMAP) { ------------------ | Branch (398:13): [True: 0, False: 0] ------------------ 399| 0| texture_type = aiTextureType_NORMALS; 400| 0| } else { 401| 0| texture_type = aiTextureType_HEIGHT; 402| 0| } 403| 0| out->AddProperty(&tex->norfac, 1, AI_MATKEY_BUMPSCALING); 404| 1| } else if (map_type & MTex::MapType_COLSPEC) ------------------ | Branch (404:16): [True: 0, False: 1] ------------------ 405| 0| texture_type = aiTextureType_SPECULAR; 406| 1| else if (map_type & MTex::MapType_COLMIR) ------------------ | Branch (406:14): [True: 0, False: 1] ------------------ 407| 0| texture_type = aiTextureType_REFLECTION; 408| | //else if (map_type & MTex::MapType_REF) 409| 1| else if (map_type & MTex::MapType_SPEC) ------------------ | Branch (409:14): [True: 0, False: 1] ------------------ 410| 0| texture_type = aiTextureType_SHININESS; 411| 1| else if (map_type & MTex::MapType_EMIT) ------------------ | Branch (411:14): [True: 0, False: 1] ------------------ 412| 0| texture_type = aiTextureType_EMISSIVE; 413| | //else if (map_type & MTex::MapType_ALPHA) 414| | //else if (map_type & MTex::MapType_HAR) 415| | //else if (map_type & MTex::MapType_RAYMIRR) 416| | //else if (map_type & MTex::MapType_TRANSLU) 417| 1| else if (map_type & MTex::MapType_AMB) ------------------ | Branch (417:14): [True: 1, False: 0] ------------------ 418| 1| texture_type = aiTextureType_AMBIENT; 419| 0| else if (map_type & MTex::MapType_DISPLACE) ------------------ | Branch (419:14): [True: 0, False: 0] ------------------ 420| 0| texture_type = aiTextureType_DISPLACEMENT; 421| | //else if (map_type & MTex::MapType_WARP) 422| | 423| | out->AddProperty(&name, AI_MATKEY_TEXTURE(texture_type, 424| 9| conv_data.next_texture[texture_type]++)); 425| 9|} _ZN6Assimp15BlenderImporter18AddSentinelTextureEP10aiMaterialPKNS_7Blender8MaterialEPKNS3_4MTexERNS3_14ConversionDataE: 428| 1|void BlenderImporter::AddSentinelTexture(aiMaterial *out, const Material *mat, const MTex *tex, ConversionData &conv_data) { 429| 1| (void)mat; 430| 1| (void)tex; 431| 1| (void)conv_data; 432| | 433| 1| aiString name; 434| 1| name.length = ai_snprintf(name.data, AI_MAXLEN, "Procedural,num=%i,type=%s", conv_data.sentinel_cnt++, 435| 1| GetTextureTypeDisplayString(tex->tex->type)); 436| | out->AddProperty(&name, AI_MATKEY_TEXTURE_DIFFUSE( 437| 1| conv_data.next_texture[aiTextureType_DIFFUSE]++)); 438| 1|} _ZN6Assimp15BlenderImporter14ResolveTextureEP10aiMaterialPKNS_7Blender8MaterialEPKNS3_4MTexERNS3_14ConversionDataE: 441| 27|void BlenderImporter::ResolveTexture(aiMaterial *out, const Material *mat, const MTex *tex, ConversionData &conv_data) { 442| 27| const Tex *rtex = tex->tex.get(); 443| 27| if (!rtex || !rtex->type) { ------------------ | Branch (443:9): [True: 0, False: 27] | Branch (443:18): [True: 17, False: 10] ------------------ 444| 17| return; 445| 17| } 446| | 447| | // We can't support most of the texture types because they're mostly procedural. 448| | // These are substituted by a dummy texture. 449| 10| const char *dispnam = ""; 450| 10| switch (rtex->type) { 451| | // these are listed in blender's UI 452| 0| case Tex::Type_CLOUDS: ------------------ | Branch (452:5): [True: 0, False: 10] ------------------ 453| 0| case Tex::Type_WOOD: ------------------ | Branch (453:5): [True: 0, False: 10] ------------------ 454| 0| case Tex::Type_MARBLE: ------------------ | Branch (454:5): [True: 0, False: 10] ------------------ 455| 0| case Tex::Type_MAGIC: ------------------ | Branch (455:5): [True: 0, False: 10] ------------------ 456| 0| case Tex::Type_BLEND: ------------------ | Branch (456:5): [True: 0, False: 10] ------------------ 457| 0| case Tex::Type_STUCCI: ------------------ | Branch (457:5): [True: 0, False: 10] ------------------ 458| 0| case Tex::Type_NOISE: ------------------ | Branch (458:5): [True: 0, False: 10] ------------------ 459| 0| case Tex::Type_PLUGIN: ------------------ | Branch (459:5): [True: 0, False: 10] ------------------ 460| 0| case Tex::Type_MUSGRAVE: ------------------ | Branch (460:5): [True: 0, False: 10] ------------------ 461| 1| case Tex::Type_VORONOI: ------------------ | Branch (461:5): [True: 1, False: 9] ------------------ 462| 1| case Tex::Type_DISTNOISE: ------------------ | Branch (462:5): [True: 0, False: 10] ------------------ 463| 1| case Tex::Type_ENVMAP: ------------------ | Branch (463:5): [True: 0, False: 10] ------------------ 464| | 465| | // these do no appear in the UI, why? 466| 1| case Tex::Type_POINTDENSITY: ------------------ | Branch (466:5): [True: 0, False: 10] ------------------ 467| 1| case Tex::Type_VOXELDATA: ------------------ | Branch (467:5): [True: 0, False: 10] ------------------ 468| | 469| 1| LogWarn("Encountered a texture with an unsupported type: ", dispnam); 470| 1| AddSentinelTexture(out, mat, tex, conv_data); 471| 1| break; 472| | 473| 9| case Tex::Type_IMAGE: ------------------ | Branch (473:5): [True: 9, False: 1] ------------------ 474| 9| if (!rtex->ima) { ------------------ | Branch (474:13): [True: 0, False: 9] ------------------ 475| 0| LogError("A texture claims to be an Image, but no image reference is given"); 476| 0| break; 477| 0| } 478| 9| ResolveImage(out, mat, tex, rtex->ima.get(), conv_data); 479| 9| break; 480| | 481| 0| default: ------------------ | Branch (481:5): [True: 0, False: 10] ------------------ 482| 0| ai_assert(false); 483| 10| }; 484| 10|} _ZN6Assimp15BlenderImporter20BuildDefaultMaterialERNS_7Blender14ConversionDataE: 487| 25|void BlenderImporter::BuildDefaultMaterial(Blender::ConversionData &conv_data) { 488| | // add a default material if necessary 489| 25| unsigned int index = static_cast(-1); 490| 41| for (aiMesh *mesh : conv_data.meshes.get()) { ------------------ | Branch (490:23): [True: 41, False: 25] ------------------ 491| 41| if (mesh->mMaterialIndex == static_cast(-1)) { ------------------ | Branch (491:13): [True: 4, False: 37] ------------------ 492| | 493| 4| if (index == static_cast(-1)) { ------------------ | Branch (493:17): [True: 4, False: 0] ------------------ 494| | // Setup a default material. 495| 4| std::shared_ptr p(new Material()); 496| 4| const size_t len = ::strlen(AI_DEFAULT_MATERIAL_NAME); 497| 4| ai_assert(len < sizeof(p->id.name) - 2); 498| 4| memcpy(p->id.name + 2, AI_DEFAULT_MATERIAL_NAME, len); 499| | 500| | // Note: MSVC11 does not zero-initialize Material here, although it should. 501| | // Thus all relevant fields should be explicitly initialized. We cannot add 502| | // a default constructor to Material since the DNA codegen does not support 503| | // parsing it. 504| 4| p->r = p->g = p->b = 0.6f; 505| 4| p->specr = p->specg = p->specb = 0.6f; 506| 4| p->ambr = p->ambg = p->ambb = 0.0f; 507| 4| p->mirr = p->mirg = p->mirb = 0.0f; 508| 4| p->emit = 0.f; 509| 4| p->alpha = 0.f; 510| 4| p->har = 0; 511| | 512| 4| index = static_cast(conv_data.materials_raw.size()); 513| 4| conv_data.materials_raw.push_back(p); 514| 4| LogInfo("Adding default material"); 515| 4| } 516| 4| mesh->mMaterialIndex = index; 517| 4| } 518| 41| } 519| 25|} _ZN6Assimp15BlenderImporter14AddBlendParamsEP10aiMaterialPKNS_7Blender8MaterialE: 521| 31|void BlenderImporter::AddBlendParams(aiMaterial *result, const Material *source) { 522| 31| aiColor3D diffuseColor(source->r, source->g, source->b); 523| 31| result->AddProperty(&diffuseColor, 1, "$mat.blend.diffuse.color", 0, 0); 524| | 525| 31| float diffuseIntensity = source->ref; 526| 31| result->AddProperty(&diffuseIntensity, 1, "$mat.blend.diffuse.intensity", 0, 0); 527| | 528| 31| int diffuseShader = source->diff_shader; 529| 31| result->AddProperty(&diffuseShader, 1, "$mat.blend.diffuse.shader", 0, 0); 530| | 531| 31| int diffuseRamp = 0; 532| 31| result->AddProperty(&diffuseRamp, 1, "$mat.blend.diffuse.ramp", 0, 0); 533| | 534| 31| aiColor3D specularColor(source->specr, source->specg, source->specb); 535| 31| result->AddProperty(&specularColor, 1, "$mat.blend.specular.color", 0, 0); 536| | 537| 31| float specularIntensity = source->spec; 538| 31| result->AddProperty(&specularIntensity, 1, "$mat.blend.specular.intensity", 0, 0); 539| | 540| 31| int specularShader = source->spec_shader; 541| 31| result->AddProperty(&specularShader, 1, "$mat.blend.specular.shader", 0, 0); 542| | 543| 31| int specularRamp = 0; 544| 31| result->AddProperty(&specularRamp, 1, "$mat.blend.specular.ramp", 0, 0); 545| | 546| 31| int specularHardness = source->har; 547| 31| result->AddProperty(&specularHardness, 1, "$mat.blend.specular.hardness", 0, 0); 548| | 549| 31| int transparencyUse = source->mode & MA_TRANSPARENCY ? 1 : 0; ------------------ | Branch (549:27): [True: 14, False: 17] ------------------ 550| 31| result->AddProperty(&transparencyUse, 1, "$mat.blend.transparency.use", 0, 0); 551| | 552| 31| int transparencyMethod = source->mode & MA_RAYTRANSP ? 2 : (source->mode & MA_ZTRANSP ? 1 : 0); ------------------ | Branch (552:30): [True: 1, False: 30] | Branch (552:65): [True: 13, False: 17] ------------------ 553| 31| result->AddProperty(&transparencyMethod, 1, "$mat.blend.transparency.method", 0, 0); 554| | 555| 31| float transparencyAlpha = source->alpha; 556| 31| result->AddProperty(&transparencyAlpha, 1, "$mat.blend.transparency.alpha", 0, 0); 557| | 558| 31| float transparencySpecular = source->spectra; 559| 31| result->AddProperty(&transparencySpecular, 1, "$mat.blend.transparency.specular", 0, 0); 560| | 561| 31| float transparencyFresnel = source->fresnel_tra; 562| 31| result->AddProperty(&transparencyFresnel, 1, "$mat.blend.transparency.fresnel", 0, 0); 563| | 564| 31| float transparencyBlend = source->fresnel_tra_i; 565| 31| result->AddProperty(&transparencyBlend, 1, "$mat.blend.transparency.blend", 0, 0); 566| | 567| 31| float transparencyIor = source->ang; 568| 31| result->AddProperty(&transparencyIor, 1, "$mat.blend.transparency.ior", 0, 0); 569| | 570| 31| float transparencyFilter = source->filter; 571| 31| result->AddProperty(&transparencyFilter, 1, "$mat.blend.transparency.filter", 0, 0); 572| | 573| 31| float transparencyFalloff = source->tx_falloff; 574| 31| result->AddProperty(&transparencyFalloff, 1, "$mat.blend.transparency.falloff", 0, 0); 575| | 576| 31| float transparencyLimit = source->tx_limit; 577| 31| result->AddProperty(&transparencyLimit, 1, "$mat.blend.transparency.limit", 0, 0); 578| | 579| 31| int transparencyDepth = source->ray_depth_tra; 580| 31| result->AddProperty(&transparencyDepth, 1, "$mat.blend.transparency.depth", 0, 0); 581| | 582| 31| float transparencyGlossAmount = source->gloss_tra; 583| 31| result->AddProperty(&transparencyGlossAmount, 1, "$mat.blend.transparency.glossAmount", 0, 0); 584| | 585| 31| float transparencyGlossThreshold = source->adapt_thresh_tra; 586| 31| result->AddProperty(&transparencyGlossThreshold, 1, "$mat.blend.transparency.glossThreshold", 0, 0); 587| | 588| 31| int transparencyGlossSamples = source->samp_gloss_tra; 589| 31| result->AddProperty(&transparencyGlossSamples, 1, "$mat.blend.transparency.glossSamples", 0, 0); 590| | 591| 31| int mirrorUse = source->mode & MA_RAYMIRROR ? 1 : 0; ------------------ | Branch (591:21): [True: 1, False: 30] ------------------ 592| 31| result->AddProperty(&mirrorUse, 1, "$mat.blend.mirror.use", 0, 0); 593| | 594| 31| float mirrorReflectivity = source->ray_mirror; 595| 31| result->AddProperty(&mirrorReflectivity, 1, "$mat.blend.mirror.reflectivity", 0, 0); 596| | 597| 31| aiColor3D mirrorColor(source->mirr, source->mirg, source->mirb); 598| 31| result->AddProperty(&mirrorColor, 1, "$mat.blend.mirror.color", 0, 0); 599| | 600| 31| float mirrorFresnel = source->fresnel_mir; 601| 31| result->AddProperty(&mirrorFresnel, 1, "$mat.blend.mirror.fresnel", 0, 0); 602| | 603| 31| float mirrorBlend = source->fresnel_mir_i; 604| 31| result->AddProperty(&mirrorBlend, 1, "$mat.blend.mirror.blend", 0, 0); 605| | 606| 31| int mirrorDepth = source->ray_depth; 607| 31| result->AddProperty(&mirrorDepth, 1, "$mat.blend.mirror.depth", 0, 0); 608| | 609| 31| float mirrorMaxDist = source->dist_mir; 610| 31| result->AddProperty(&mirrorMaxDist, 1, "$mat.blend.mirror.maxDist", 0, 0); 611| | 612| 31| int mirrorFadeTo = source->fadeto_mir; 613| 31| result->AddProperty(&mirrorFadeTo, 1, "$mat.blend.mirror.fadeTo", 0, 0); 614| | 615| 31| float mirrorGlossAmount = source->gloss_mir; 616| 31| result->AddProperty(&mirrorGlossAmount, 1, "$mat.blend.mirror.glossAmount", 0, 0); 617| | 618| 31| float mirrorGlossThreshold = source->adapt_thresh_mir; 619| 31| result->AddProperty(&mirrorGlossThreshold, 1, "$mat.blend.mirror.glossThreshold", 0, 0); 620| | 621| 31| int mirrorGlossSamples = source->samp_gloss_mir; 622| 31| result->AddProperty(&mirrorGlossSamples, 1, "$mat.blend.mirror.glossSamples", 0, 0); 623| | 624| 31| float mirrorGlossAnisotropic = source->aniso_gloss_mir; 625| 31| result->AddProperty(&mirrorGlossAnisotropic, 1, "$mat.blend.mirror.glossAnisotropic", 0, 0); 626| 31|} _ZN6Assimp15BlenderImporter14BuildMaterialsERNS_7Blender14ConversionDataE: 628| 25|void BlenderImporter::BuildMaterials(ConversionData &conv_data) { 629| 25| conv_data.materials->reserve(conv_data.materials_raw.size()); 630| | 631| 25| BuildDefaultMaterial(conv_data); 632| | 633| 31| for (const std::shared_ptr &mat : conv_data.materials_raw) { ------------------ | Branch (633:47): [True: 31, False: 25] ------------------ 634| | 635| | // reset per material global counters 636| 620| for (size_t i = 0; i < sizeof(conv_data.next_texture) / sizeof(conv_data.next_texture[0]); ++i) { ------------------ | Branch (636:28): [True: 589, False: 31] ------------------ 637| 589| conv_data.next_texture[i] = 0; 638| 589| } 639| | 640| 31| aiMaterial *mout = new aiMaterial(); 641| 31| conv_data.materials->push_back(mout); 642| | // For any new material field handled here, the default material above must be updated with an appropriate default value. 643| | 644| | // set material name 645| 31| aiString name = aiString(mat->id.name + 2); // skip over the name prefix 'MA' 646| 31| mout->AddProperty(&name, AI_MATKEY_NAME); 647| | 648| | // basic material colors 649| 31| aiColor3D col(mat->r, mat->g, mat->b); 650| 31| if (mat->r || mat->g || mat->b) { ------------------ | Branch (650:13): [True: 31, False: 0] | Branch (650:23): [True: 0, False: 0] | Branch (650:33): [True: 0, False: 0] ------------------ 651| | 652| | // Usually, zero diffuse color means no diffuse color at all in the equation. 653| | // So we omit this member to express this intent. 654| 31| mout->AddProperty(&col, 1, AI_MATKEY_COLOR_DIFFUSE); 655| | 656| 31| if (mat->emit) { ------------------ | Branch (656:17): [True: 1, False: 30] ------------------ 657| 1| aiColor3D emit_col(mat->emit * mat->r, mat->emit * mat->g, mat->emit * mat->b); 658| 1| mout->AddProperty(&emit_col, 1, AI_MATKEY_COLOR_EMISSIVE); 659| 1| } 660| 31| } 661| | 662| 31| col = aiColor3D(mat->specr, mat->specg, mat->specb); 663| 31| mout->AddProperty(&col, 1, AI_MATKEY_COLOR_SPECULAR); 664| | 665| | // is hardness/shininess set? 666| 31| if (mat->har) { ------------------ | Branch (666:13): [True: 26, False: 5] ------------------ 667| 26| const float har = mat->har; 668| 26| mout->AddProperty(&har, 1, AI_MATKEY_SHININESS); 669| 26| } 670| | 671| 31| col = aiColor3D(mat->ambr, mat->ambg, mat->ambb); 672| 31| mout->AddProperty(&col, 1, AI_MATKEY_COLOR_AMBIENT); 673| | 674| | // is mirror enabled? 675| 31| if (mat->mode & MA_RAYMIRROR) { ------------------ | Branch (675:13): [True: 1, False: 30] ------------------ 676| 1| const float ray_mirror = mat->ray_mirror; 677| 1| mout->AddProperty(&ray_mirror, 1, AI_MATKEY_REFLECTIVITY); 678| 1| } 679| | 680| 31| col = aiColor3D(mat->mirr, mat->mirg, mat->mirb); 681| 31| mout->AddProperty(&col, 1, AI_MATKEY_COLOR_REFLECTIVE); 682| | 683| 589| for (size_t i = 0; i < sizeof(mat->mtex) / sizeof(mat->mtex[0]); ++i) { ------------------ | Branch (683:28): [True: 558, False: 31] ------------------ 684| 558| if (!mat->mtex[i]) { ------------------ | Branch (684:17): [True: 531, False: 27] ------------------ 685| 531| continue; 686| 531| } 687| | 688| 27| ResolveTexture(mout, mat.get(), mat->mtex[i].get(), conv_data); 689| 27| } 690| | 691| 31| AddBlendParams(mout, mat.get()); 692| 31| } 693| 25|} _ZN6Assimp15BlenderImporter15CheckActualTypeEPKNS_7Blender8ElemBaseEPKc: 696| 95|void BlenderImporter::CheckActualType(const ElemBase *dt, const char *check) { 697| 95| ai_assert(dt); 698| 95| if (strcmp(dt->dna_type, check)) { ------------------ | Branch (698:9): [True: 0, False: 95] ------------------ 699| 0| ThrowException("Expected object at ", std::hex, dt, " to be of type `", check, 700| 0| "`, but it claims to be a `", dt->dna_type, "`instead"); 701| 0| } 702| 95|} _ZN6Assimp15BlenderImporter11ConvertMeshERKNS_7Blender5SceneEPKNS1_6ObjectEPKNS1_4MeshERNS1_14ConversionDataERNS1_9TempArrayINSt3__16vectorE6aiMeshEE: 711| 38| ConversionData &conv_data, TempArray &temp) { 712| | // TODO: Resolve various problems with BMesh triangulation before re-enabling. 713| | // See issues #400, #373, #318 #315 and #132. 714| |#if defined(TODO_FIX_BMESH_CONVERSION) 715| | BlenderBMeshConverter BMeshConverter(mesh); 716| | if (BMeshConverter.ContainsBMesh()) { 717| | mesh = BMeshConverter.TriangulateBMesh(); 718| | } 719| |#endif 720| | 721| 38| typedef std::pair MyPair; 722| 38| if ((!mesh->totface && !mesh->totloop) || !mesh->totvert) { ------------------ | Branch (722:10): [True: 11, False: 27] | Branch (722:28): [True: 0, False: 11] | Branch (722:47): [True: 0, False: 38] ------------------ 723| 0| return; 724| 0| } 725| | 726| | // some sanity checks 727| 38| if (static_cast(mesh->totface) > mesh->mface.size()) { ------------------ | Branch (727:9): [True: 0, False: 38] ------------------ 728| 0| ThrowException("Number of faces is larger than the corresponding array"); 729| 0| } 730| | 731| 38| if (static_cast(mesh->totvert) > mesh->mvert.size()) { ------------------ | Branch (731:9): [True: 0, False: 38] ------------------ 732| 0| ThrowException("Number of vertices is larger than the corresponding array"); 733| 0| } 734| | 735| 38| if (static_cast(mesh->totloop) > mesh->mloop.size()) { ------------------ | Branch (735:9): [True: 0, False: 38] ------------------ 736| 0| ThrowException("Number of vertices is larger than the corresponding array"); 737| 0| } 738| | 739| | // collect per-submesh numbers 740| 38| std::map per_mat; 741| 38| std::map per_mat_verts; 742| 7.52k| for (int i = 0; i < mesh->totface; ++i) { ------------------ | Branch (742:21): [True: 7.48k, False: 38] ------------------ 743| | 744| 7.48k| const MFace &mf = mesh->mface[i]; 745| 7.48k| per_mat[mf.mat_nr]++; 746| 7.48k| per_mat_verts[mf.mat_nr] += mf.v4 ? 4 : 3; ------------------ | Branch (746:37): [True: 7.32k, False: 161] ------------------ 747| 7.48k| } 748| | 749| 721| for (int i = 0; i < mesh->totpoly; ++i) { ------------------ | Branch (749:21): [True: 683, False: 38] ------------------ 750| 683| const MPoly &mp = mesh->mpoly[i]; 751| 683| per_mat[mp.mat_nr]++; 752| 683| per_mat_verts[mp.mat_nr] += mp.totloop; 753| 683| } 754| | 755| | // ... and allocate the corresponding meshes 756| 38| const size_t old = temp->size(); 757| 38| temp->reserve(temp->size() + per_mat.size()); 758| | 759| 38| std::map mat_num_to_mesh_idx; 760| 39| for (MyPair &it : per_mat) { ------------------ | Branch (760:21): [True: 39, False: 38] ------------------ 761| | 762| 39| mat_num_to_mesh_idx[it.first] = temp->size(); 763| 39| temp->push_back(new aiMesh()); 764| | 765| 39| aiMesh *out = temp->back(); 766| 39| out->mVertices = new aiVector3D[per_mat_verts[it.first]]; 767| 39| out->mNormals = new aiVector3D[per_mat_verts[it.first]]; 768| | 769| | //out->mNumFaces = 0 770| | //out->mNumVertices = 0 771| 39| out->mFaces = new aiFace[it.second](); 772| | 773| | // all sub-meshes created from this mesh are named equally. this allows 774| | // curious users to recover the original adjacency. 775| 39| out->mName = aiString(mesh->id.name + 2); 776| | // skip over the name prefix 'ME' 777| | 778| | // resolve the material reference and add this material to the set of 779| | // output materials. The (temporary) material index is the index 780| | // of the material entry within the list of resolved materials. 781| 39| if (mesh->mat) { ------------------ | Branch (781:13): [True: 35, False: 4] ------------------ 782| | 783| 35| if (static_cast(it.first) >= mesh->mat.size()) { ------------------ | Branch (783:17): [True: 0, False: 35] ------------------ 784| 0| ThrowException("Material index is out of range"); 785| 0| } 786| | 787| 35| std::shared_ptr mat = mesh->mat[it.first]; 788| 35| const std::deque>::iterator has = std::find( 789| 35| conv_data.materials_raw.begin(), 790| 35| conv_data.materials_raw.end(), mat); 791| | 792| 35| if (has != conv_data.materials_raw.end()) { ------------------ | Branch (792:17): [True: 8, False: 27] ------------------ 793| 8| out->mMaterialIndex = static_cast(std::distance(conv_data.materials_raw.begin(), has)); 794| 27| } else { 795| 27| out->mMaterialIndex = static_cast(conv_data.materials_raw.size()); 796| 27| conv_data.materials_raw.push_back(mat); 797| 27| } 798| 35| } else 799| 4| out->mMaterialIndex = static_cast(-1); 800| 39| } 801| | 802| 7.52k| for (int i = 0; i < mesh->totface; ++i) { ------------------ | Branch (802:21): [True: 7.48k, False: 38] ------------------ 803| | 804| 7.48k| const MFace &mf = mesh->mface[i]; 805| | 806| 7.48k| aiMesh *const out = temp[mat_num_to_mesh_idx[mf.mat_nr]]; 807| 7.48k| aiFace &f = out->mFaces[out->mNumFaces++]; 808| | 809| 7.48k| f.mIndices = new unsigned int[f.mNumIndices = mf.v4 ? 4 : 3]; ------------------ | Branch (809:55): [True: 7.32k, False: 161] ------------------ 810| 7.48k| aiVector3D *vo = out->mVertices + out->mNumVertices; 811| 7.48k| aiVector3D *vn = out->mNormals + out->mNumVertices; 812| | 813| | // XXX we can't fold this easily, because we are restricted 814| | // to the member names from the BLEND file (v1,v2,v3,v4) 815| | // which are assigned by the genblenddna.py script and 816| | // cannot be changed without breaking the entire 817| | // import process. 818| | 819| 7.48k| if (mf.v1 >= mesh->totvert) { ------------------ | Branch (819:13): [True: 0, False: 7.48k] ------------------ 820| 0| ThrowException("Vertex index v1 out of range"); 821| 0| } 822| 7.48k| const MVert *v = &mesh->mvert[mf.v1]; 823| 7.48k| vo->x = v->co[0]; 824| 7.48k| vo->y = v->co[1]; 825| 7.48k| vo->z = v->co[2]; 826| 7.48k| vn->x = v->no[0]; 827| 7.48k| vn->y = v->no[1]; 828| 7.48k| vn->z = v->no[2]; 829| 7.48k| f.mIndices[0] = out->mNumVertices++; 830| 7.48k| ++vo; 831| 7.48k| ++vn; 832| | 833| | // if (f.mNumIndices >= 2) { 834| 7.48k| if (mf.v2 >= mesh->totvert) { ------------------ | Branch (834:13): [True: 0, False: 7.48k] ------------------ 835| 0| ThrowException("Vertex index v2 out of range"); 836| 0| } 837| 7.48k| v = &mesh->mvert[mf.v2]; 838| 7.48k| vo->x = v->co[0]; 839| 7.48k| vo->y = v->co[1]; 840| 7.48k| vo->z = v->co[2]; 841| 7.48k| vn->x = v->no[0]; 842| 7.48k| vn->y = v->no[1]; 843| 7.48k| vn->z = v->no[2]; 844| 7.48k| f.mIndices[1] = out->mNumVertices++; 845| 7.48k| ++vo; 846| 7.48k| ++vn; 847| | 848| 7.48k| if (mf.v3 >= mesh->totvert) { ------------------ | Branch (848:13): [True: 0, False: 7.48k] ------------------ 849| 0| ThrowException("Vertex index v3 out of range"); 850| 0| } 851| | // if (f.mNumIndices >= 3) { 852| 7.48k| v = &mesh->mvert[mf.v3]; 853| 7.48k| vo->x = v->co[0]; 854| 7.48k| vo->y = v->co[1]; 855| 7.48k| vo->z = v->co[2]; 856| 7.48k| vn->x = v->no[0]; 857| 7.48k| vn->y = v->no[1]; 858| 7.48k| vn->z = v->no[2]; 859| 7.48k| f.mIndices[2] = out->mNumVertices++; 860| 7.48k| ++vo; 861| 7.48k| ++vn; 862| | 863| 7.48k| if (mf.v4 >= mesh->totvert) { ------------------ | Branch (863:13): [True: 0, False: 7.48k] ------------------ 864| 0| ThrowException("Vertex index v4 out of range"); 865| 0| } 866| | // if (f.mNumIndices >= 4) { 867| 7.48k| if (mf.v4) { ------------------ | Branch (867:13): [True: 7.32k, False: 161] ------------------ 868| 7.32k| v = &mesh->mvert[mf.v4]; 869| 7.32k| vo->x = v->co[0]; 870| 7.32k| vo->y = v->co[1]; 871| 7.32k| vo->z = v->co[2]; 872| 7.32k| vn->x = v->no[0]; 873| 7.32k| vn->y = v->no[1]; 874| 7.32k| vn->z = v->no[2]; 875| 7.32k| f.mIndices[3] = out->mNumVertices++; 876| 7.32k| ++vo; 877| 7.32k| ++vn; 878| | 879| 7.32k| out->mPrimitiveTypes |= aiPrimitiveType_POLYGON; 880| 7.32k| } else 881| 161| out->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE; 882| | 883| | // } 884| | // } 885| | // } 886| 7.48k| } 887| | 888| 721| for (int i = 0; i < mesh->totpoly; ++i) { ------------------ | Branch (888:21): [True: 683, False: 38] ------------------ 889| | 890| 683| const MPoly &mf = mesh->mpoly[i]; 891| | 892| 683| aiMesh *const out = temp[mat_num_to_mesh_idx[mf.mat_nr]]; 893| 683| aiFace &f = out->mFaces[out->mNumFaces++]; 894| | 895| 683| f.mIndices = new unsigned int[f.mNumIndices = mf.totloop]; 896| 683| aiVector3D *vo = out->mVertices + out->mNumVertices; 897| 683| aiVector3D *vn = out->mNormals + out->mNumVertices; 898| | 899| | // XXX we can't fold this easily, because we are restricted 900| | // to the member names from the BLEND file (v1,v2,v3,v4) 901| | // which are assigned by the genblenddna.py script and 902| | // cannot be changed without breaking the entire 903| | // import process. 904| 3.33k| for (int j = 0; j < mf.totloop; ++j) { ------------------ | Branch (904:25): [True: 2.65k, False: 683] ------------------ 905| 2.65k| const MLoop &loop = mesh->mloop[mf.loopstart + j]; 906| | 907| 2.65k| if (loop.v >= mesh->totvert) { ------------------ | Branch (907:17): [True: 0, False: 2.65k] ------------------ 908| 0| ThrowException("Vertex index out of range"); 909| 0| } 910| | 911| 2.65k| const MVert &v = mesh->mvert[loop.v]; 912| | 913| 2.65k| vo->x = v.co[0]; 914| 2.65k| vo->y = v.co[1]; 915| 2.65k| vo->z = v.co[2]; 916| 2.65k| vn->x = v.no[0]; 917| 2.65k| vn->y = v.no[1]; 918| 2.65k| vn->z = v.no[2]; 919| 2.65k| f.mIndices[j] = out->mNumVertices++; 920| | 921| 2.65k| ++vo; 922| 2.65k| ++vn; 923| 2.65k| } 924| 683| if (mf.totloop == 3) { ------------------ | Branch (924:13): [True: 76, False: 607] ------------------ 925| 76| out->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE; 926| 607| } else { 927| 607| out->mPrimitiveTypes |= aiPrimitiveType_POLYGON; 928| 607| } 929| 683| } 930| | 931| | // TODO should we create the TextureUVMapping map in Convert to prevent redundant processing? 932| | 933| | // create texture <-> uvname mapping for all materials 934| | // key is texture number, value is data * 935| 38| typedef std::map TextureUVMapping; 936| | // key is material number, value is the TextureUVMapping for the material 937| 38| typedef std::map MaterialTextureUVMappings; 938| 38| MaterialTextureUVMappings matTexUvMappings; 939| 38| const uint32_t maxMat = static_cast(mesh->mat.size()); 940| 73| for (uint32_t m = 0; m < maxMat; ++m) { ------------------ | Branch (940:26): [True: 35, False: 38] ------------------ 941| | // get material by index 942| 35| const std::shared_ptr pMat = mesh->mat[m]; 943| 35| TextureUVMapping texuv; 944| 35| const uint32_t maxTex = sizeof(pMat->mtex) / sizeof(pMat->mtex[0]); 945| 665| for (uint32_t t = 0; t < maxTex; ++t) { ------------------ | Branch (945:30): [True: 630, False: 35] ------------------ 946| 630| if (pMat->mtex[t] && pMat->mtex[t]->uvname[0]) { ------------------ | Branch (946:17): [True: 35, False: 595] | Branch (946:34): [True: 2, False: 33] ------------------ 947| | // get the CustomData layer for given uvname and correct type 948| 2| const ElemBase *pLoop = getCustomDataLayerData(mesh->ldata, CD_MLOOPUV, pMat->mtex[t]->uvname); 949| 2| if (pLoop) { ------------------ | Branch (949:21): [True: 2, False: 0] ------------------ 950| 2| texuv.insert(std::make_pair(t, dynamic_cast(pLoop))); 951| 2| } 952| 2| } 953| 630| } 954| 35| if (texuv.size()) { ------------------ | Branch (954:13): [True: 1, False: 34] ------------------ 955| 1| matTexUvMappings.insert(std::make_pair(m, texuv)); 956| 1| } 957| 35| } 958| | 959| | // collect texture coordinates, they're stored in a separate per-face buffer 960| 38| if (mesh->mtface || mesh->mloopuv) { ------------------ | Branch (960:9): [True: 4, False: 34] | Branch (960:25): [True: 3, False: 31] ------------------ 961| 7| if (mesh->totface > static_cast(mesh->mtface.size())) { ------------------ | Branch (961:13): [True: 0, False: 7] ------------------ 962| 0| ThrowException("Number of UV faces is larger than the corresponding UV face array (#1)"); 963| 0| } 964| 14| for (std::vector::iterator it = temp->begin() + old; it != temp->end(); ++it) { ------------------ | Branch (964:72): [True: 7, False: 7] ------------------ 965| 7| ai_assert(0 != (*it)->mNumVertices); 966| 7| ai_assert(0 != (*it)->mNumFaces); 967| 7| const auto itMatTexUvMapping = matTexUvMappings.find((*it)->mMaterialIndex); 968| 7| if (itMatTexUvMapping == matTexUvMappings.end()) { ------------------ | Branch (968:17): [True: 6, False: 1] ------------------ 969| | // default behaviour like before 970| 6| (*it)->mTextureCoords[0] = new aiVector3D[(*it)->mNumVertices]; 971| 6| } else { 972| | // create texture coords for every mapped tex 973| 3| for (uint32_t i = 0; i < itMatTexUvMapping->second.size(); ++i) { ------------------ | Branch (973:38): [True: 2, False: 1] ------------------ 974| 2| (*it)->mTextureCoords[i] = new aiVector3D[(*it)->mNumVertices]; 975| 2| } 976| 1| } 977| 7| (*it)->mNumFaces = (*it)->mNumVertices = 0; 978| 7| } 979| | 980| 21| for (int i = 0; i < mesh->totface; ++i) { ------------------ | Branch (980:25): [True: 14, False: 7] ------------------ 981| 14| const MTFace *v = &mesh->mtface[i]; 982| | 983| 14| aiMesh *const out = temp[mat_num_to_mesh_idx[mesh->mface[i].mat_nr]]; 984| 14| const aiFace &f = out->mFaces[out->mNumFaces++]; 985| | 986| 14| aiVector3D *vo = &out->mTextureCoords[0][out->mNumVertices]; 987| 70| for (unsigned int j = 0; j < f.mNumIndices; ++j, ++vo, ++out->mNumVertices) { ------------------ | Branch (987:38): [True: 56, False: 14] ------------------ 988| 56| vo->x = v->uv[j][0]; 989| 56| vo->y = v->uv[j][1]; 990| 56| } 991| 14| } 992| | 993| 58| for (int i = 0; i < mesh->totpoly; ++i) { ------------------ | Branch (993:25): [True: 51, False: 7] ------------------ 994| 51| const MPoly &v = mesh->mpoly[i]; 995| 51| aiMesh *const out = temp[mat_num_to_mesh_idx[v.mat_nr]]; 996| 51| const aiFace &f = out->mFaces[out->mNumFaces++]; 997| | 998| 51| const auto itMatTexUvMapping = matTexUvMappings.find(v.mat_nr); 999| 51| if (itMatTexUvMapping == matTexUvMappings.end()) { ------------------ | Branch (999:17): [True: 50, False: 1] ------------------ 1000| | // old behavior 1001| 50| aiVector3D *vo = &out->mTextureCoords[0][out->mNumVertices]; 1002| 206| for (unsigned int j = 0; j < f.mNumIndices; ++j, ++vo, ++out->mNumVertices) { ------------------ | Branch (1002:42): [True: 156, False: 50] ------------------ 1003| 156| const MLoopUV &uv = mesh->mloopuv[v.loopstart + j]; 1004| 156| vo->x = uv.uv[0]; 1005| 156| vo->y = uv.uv[1]; 1006| 156| } 1007| 50| } else { 1008| | // create textureCoords for every mapped tex 1009| 3| for (uint32_t m = 0; m < itMatTexUvMapping->second.size(); ++m) { ------------------ | Branch (1009:38): [True: 2, False: 1] ------------------ 1010| 2| const MLoopUV *tm = itMatTexUvMapping->second[m]; 1011| 2| aiVector3D *vo = &out->mTextureCoords[m][out->mNumVertices]; 1012| 2| uint32_t j = 0; 1013| 10| for (; j < f.mNumIndices; ++j, ++vo) { ------------------ | Branch (1013:28): [True: 8, False: 2] ------------------ 1014| 8| const MLoopUV &uv = tm[v.loopstart + j]; 1015| 8| vo->x = uv.uv[0]; 1016| 8| vo->y = uv.uv[1]; 1017| 8| } 1018| | // only update written mNumVertices in last loop 1019| | // TODO why must the numVertices be incremented here? 1020| 2| if (m == itMatTexUvMapping->second.size() - 1) { ------------------ | Branch (1020:25): [True: 1, False: 1] ------------------ 1021| 1| out->mNumVertices += j; 1022| 1| } 1023| 2| } 1024| 1| } 1025| 51| } 1026| 7| } 1027| | 1028| | // collect texture coordinates, old-style (marked as deprecated in current blender sources) 1029| 38| if (mesh->tface) { ------------------ | Branch (1029:9): [True: 0, False: 38] ------------------ 1030| 0| if (mesh->totface > static_cast(mesh->tface.size())) { ------------------ | Branch (1030:13): [True: 0, False: 0] ------------------ 1031| 0| ThrowException("Number of faces is larger than the corresponding UV face array (#2)"); 1032| 0| } 1033| 0| for (std::vector::iterator it = temp->begin() + old; it != temp->end(); ++it) { ------------------ | Branch (1033:72): [True: 0, False: 0] ------------------ 1034| 0| ai_assert(0 != (*it)->mNumVertices); 1035| 0| ai_assert(0 != (*it)->mNumFaces); 1036| | 1037| 0| (*it)->mTextureCoords[0] = new aiVector3D[(*it)->mNumVertices]; 1038| 0| (*it)->mNumFaces = (*it)->mNumVertices = 0; 1039| 0| } 1040| | 1041| 0| for (int i = 0; i < mesh->totface; ++i) { ------------------ | Branch (1041:25): [True: 0, False: 0] ------------------ 1042| 0| const TFace *v = &mesh->tface[i]; 1043| | 1044| 0| aiMesh *const out = temp[mat_num_to_mesh_idx[mesh->mface[i].mat_nr]]; 1045| 0| const aiFace &f = out->mFaces[out->mNumFaces++]; 1046| | 1047| 0| aiVector3D *vo = &out->mTextureCoords[0][out->mNumVertices]; 1048| 0| for (unsigned int j = 0; j < f.mNumIndices; ++j, ++vo, ++out->mNumVertices) { ------------------ | Branch (1048:38): [True: 0, False: 0] ------------------ 1049| 0| vo->x = v->uv[j][0]; 1050| 0| vo->y = v->uv[j][1]; 1051| 0| } 1052| 0| } 1053| 0| } 1054| | 1055| | // collect vertex colors, stored separately as well 1056| 38| if (mesh->mcol || mesh->mloopcol) { ------------------ | Branch (1056:9): [True: 1, False: 37] | Branch (1056:23): [True: 0, False: 37] ------------------ 1057| 1| if (mesh->totface > static_cast((mesh->mcol.size() / 4))) { ------------------ | Branch (1057:13): [True: 0, False: 1] ------------------ 1058| 0| ThrowException("Number of faces is larger than the corresponding color face array"); 1059| 0| } 1060| 2| for (std::vector::iterator it = temp->begin() + old; it != temp->end(); ++it) { ------------------ | Branch (1060:72): [True: 1, False: 1] ------------------ 1061| 1| ai_assert(0 != (*it)->mNumVertices); 1062| 1| ai_assert(0 != (*it)->mNumFaces); 1063| | 1064| 1| (*it)->mColors[0] = new aiColor4D[(*it)->mNumVertices]; 1065| 1| (*it)->mNumFaces = (*it)->mNumVertices = 0; 1066| 1| } 1067| | 1068| 7| for (int i = 0; i < mesh->totface; ++i) { ------------------ | Branch (1068:25): [True: 6, False: 1] ------------------ 1069| | 1070| 6| aiMesh *const out = temp[mat_num_to_mesh_idx[mesh->mface[i].mat_nr]]; 1071| 6| const aiFace &f = out->mFaces[out->mNumFaces++]; 1072| | 1073| 6| aiColor4D *vo = &out->mColors[0][out->mNumVertices]; 1074| 30| for (unsigned int n = 0; n < f.mNumIndices; ++n, ++vo, ++out->mNumVertices) { ------------------ | Branch (1074:38): [True: 24, False: 6] ------------------ 1075| 24| const MCol *col = &mesh->mcol[(i << 2) + n]; 1076| | 1077| 24| vo->r = col->r; 1078| 24| vo->g = col->g; 1079| 24| vo->b = col->b; 1080| 24| vo->a = col->a; 1081| 24| } 1082| 6| for (unsigned int n = f.mNumIndices; n < 4; ++n) ------------------ | Branch (1082:50): [True: 0, False: 6] ------------------ 1083| 0| ; 1084| 6| } 1085| | 1086| 1| for (int i = 0; i < mesh->totpoly; ++i) { ------------------ | Branch (1086:25): [True: 0, False: 1] ------------------ 1087| 0| const MPoly &v = mesh->mpoly[i]; 1088| 0| aiMesh *const out = temp[mat_num_to_mesh_idx[v.mat_nr]]; 1089| 0| const aiFace &f = out->mFaces[out->mNumFaces++]; 1090| | 1091| 0| aiColor4D *vo = &out->mColors[0][out->mNumVertices]; 1092| 0| const ai_real scaleZeroToOne = 1.f / 255.f; 1093| 0| for (unsigned int j = 0; j < f.mNumIndices; ++j, ++vo, ++out->mNumVertices) { ------------------ | Branch (1093:38): [True: 0, False: 0] ------------------ 1094| 0| const MLoopCol &col = mesh->mloopcol[v.loopstart + j]; 1095| 0| vo->r = ai_real(col.r) * scaleZeroToOne; 1096| 0| vo->g = ai_real(col.g) * scaleZeroToOne; 1097| 0| vo->b = ai_real(col.b) * scaleZeroToOne; 1098| 0| vo->a = ai_real(col.a) * scaleZeroToOne; 1099| 0| } 1100| 0| } 1101| 1| } 1102| | 1103| 38| return; 1104| 38|} _ZN6Assimp15BlenderImporter13ConvertCameraERKNS_7Blender5SceneEPKNS1_6ObjectEPKNS1_6CameraERNS1_14ConversionDataE: 1107| 26|aiCamera *BlenderImporter::ConvertCamera(const Scene & /*in*/, const Object *obj, const Camera *cam, ConversionData & /*conv_data*/) { 1108| 26| std::unique_ptr out(new aiCamera()); 1109| 26| out->mName = obj->id.name + 2; 1110| 26| out->mPosition = aiVector3D(0.f, 0.f, 0.f); 1111| 26| out->mUp = aiVector3D(0.f, 1.f, 0.f); 1112| 26| out->mLookAt = aiVector3D(0.f, 0.f, -1.f); 1113| 26| if (cam->sensor_x && cam->lens) { ------------------ | Branch (1113:9): [True: 10, False: 16] | Branch (1113:26): [True: 10, False: 0] ------------------ 1114| 10| out->mHorizontalFOV = 2.f * std::atan2(cam->sensor_x, 2.f * cam->lens); 1115| 10| } 1116| 26| out->mClipPlaneNear = cam->clipsta; 1117| 26| out->mClipPlaneFar = cam->clipend; 1118| | 1119| 26| return out.release(); 1120| 26|} _ZN6Assimp15BlenderImporter12ConvertLightERKNS_7Blender5SceneEPKNS1_6ObjectEPKNS1_4LampERNS1_14ConversionDataE: 1123| 31|aiLight *BlenderImporter::ConvertLight(const Scene & /*in*/, const Object *obj, const Lamp *lamp, ConversionData & /*conv_data*/) { 1124| 31| std::unique_ptr out(new aiLight()); 1125| 31| out->mName = obj->id.name + 2; 1126| | 1127| 31| switch (lamp->type) { 1128| 29| case Lamp::Type_Local: ------------------ | Branch (1128:5): [True: 29, False: 2] ------------------ 1129| 29| out->mType = aiLightSource_POINT; 1130| 29| break; 1131| 0| case Lamp::Type_Spot: ------------------ | Branch (1131:5): [True: 0, False: 31] ------------------ 1132| 0| out->mType = aiLightSource_SPOT; 1133| | 1134| | // blender orients directional lights as facing toward -z 1135| 0| out->mDirection = aiVector3D(0.f, 0.f, -1.f); 1136| 0| out->mUp = aiVector3D(0.f, 1.f, 0.f); 1137| | 1138| 0| out->mAngleInnerCone = lamp->spotsize * (1.0f - lamp->spotblend); 1139| 0| out->mAngleOuterCone = lamp->spotsize; 1140| 0| break; 1141| 0| case Lamp::Type_Sun: ------------------ | Branch (1141:5): [True: 0, False: 31] ------------------ 1142| 0| out->mType = aiLightSource_DIRECTIONAL; 1143| | 1144| | // blender orients directional lights as facing toward -z 1145| 0| out->mDirection = aiVector3D(0.f, 0.f, -1.f); 1146| 0| out->mUp = aiVector3D(0.f, 1.f, 0.f); 1147| 0| break; 1148| | 1149| 2| case Lamp::Type_Area: ------------------ | Branch (1149:5): [True: 2, False: 29] ------------------ 1150| 2| out->mType = aiLightSource_AREA; 1151| | 1152| 2| if (lamp->area_shape == 0) { ------------------ | Branch (1152:13): [True: 1, False: 1] ------------------ 1153| 1| out->mSize = aiVector2D(lamp->area_size, lamp->area_size); 1154| 1| } else { 1155| 1| out->mSize = aiVector2D(lamp->area_size, lamp->area_sizey); 1156| 1| } 1157| | 1158| | // blender orients directional lights as facing toward -z 1159| 2| out->mDirection = aiVector3D(0.f, 0.f, -1.f); 1160| 2| out->mUp = aiVector3D(0.f, 1.f, 0.f); 1161| 2| break; 1162| | 1163| 0| default: ------------------ | Branch (1163:5): [True: 0, False: 31] ------------------ 1164| 0| break; 1165| 31| } 1166| | 1167| 31| out->mColorAmbient = aiColor3D(lamp->r, lamp->g, lamp->b) * lamp->energy; 1168| 31| out->mColorSpecular = aiColor3D(lamp->r, lamp->g, lamp->b) * lamp->energy; 1169| 31| out->mColorDiffuse = aiColor3D(lamp->r, lamp->g, lamp->b) * lamp->energy; 1170| | 1171| | // If default values are supplied, compute the coefficients from light's max distance 1172| | // Read this: https://imdoingitwrong.wordpress.com/2011/01/31/light-attenuation/ 1173| | // 1174| 31| if (lamp->constant_coefficient == 1.0f && lamp->linear_coefficient == 0.0f && lamp->quadratic_coefficient == 0.0f && lamp->dist > 0.0f) { ------------------ | Branch (1174:9): [True: 0, False: 31] | Branch (1174:47): [True: 0, False: 0] | Branch (1174:83): [True: 0, False: 0] | Branch (1174:122): [True: 0, False: 0] ------------------ 1175| 0| out->mAttenuationConstant = 1.0f; 1176| 0| out->mAttenuationLinear = 2.0f / lamp->dist; 1177| 0| out->mAttenuationQuadratic = 1.0f / (lamp->dist * lamp->dist); 1178| 31| } else { 1179| 31| out->mAttenuationConstant = lamp->constant_coefficient; 1180| 31| out->mAttenuationLinear = lamp->linear_coefficient; 1181| 31| out->mAttenuationQuadratic = lamp->quadratic_coefficient; 1182| 31| } 1183| | 1184| 31| return out.release(); 1185| 31|} _ZN6Assimp15BlenderImporter11ConvertNodeERKNS_7Blender5SceneEPKNS1_6ObjectERNS1_14ConversionDataERK12aiMatrix4x4tIfE: 1188| 95|aiNode *BlenderImporter::ConvertNode(const Scene &in, const Object *obj, ConversionData &conv_data, const aiMatrix4x4 &parentTransform) { 1189| 95| std::deque children; 1190| 138| for (ObjectSet::iterator it = conv_data.objects.begin(); it != conv_data.objects.end();) { ------------------ | Branch (1190:62): [True: 43, False: 95] ------------------ 1191| 43| const Object *object = *it; 1192| 43| if (object->parent == obj) { ------------------ | Branch (1192:13): [True: 6, False: 37] ------------------ 1193| 6| children.push_back(object); 1194| | 1195| 6| conv_data.objects.erase(it++); 1196| 6| continue; 1197| 6| } 1198| 37| ++it; 1199| 37| } 1200| | 1201| 95| std::unique_ptr node(new aiNode(obj->id.name + 2)); // skip over the name prefix 'OB' 1202| 95| if (obj->data) { ------------------ | Branch (1202:9): [True: 95, False: 0] ------------------ 1203| 95| switch (obj->type) { 1204| 0| case Object ::Type_EMPTY: ------------------ | Branch (1204:9): [True: 0, False: 95] ------------------ 1205| 0| break; // do nothing 1206| | 1207| | // supported object types 1208| 38| case Object ::Type_MESH: { ------------------ | Branch (1208:9): [True: 38, False: 57] ------------------ 1209| 38| const size_t old = conv_data.meshes->size(); 1210| | 1211| 38| CheckActualType(obj->data.get(), "Mesh"); 1212| 38| ConvertMesh(in, obj, static_cast(obj->data.get()), conv_data, conv_data.meshes); 1213| | 1214| 38| if (conv_data.meshes->size() > old) { ------------------ | Branch (1214:17): [True: 38, False: 0] ------------------ 1215| 38| node->mMeshes = new unsigned int[node->mNumMeshes = static_cast(conv_data.meshes->size() - old)]; 1216| 77| for (unsigned int i = 0; i < node->mNumMeshes; ++i) { ------------------ | Branch (1216:42): [True: 39, False: 38] ------------------ 1217| 39| node->mMeshes[i] = static_cast(i + old); 1218| 39| } 1219| 38| } 1220| 38| } break; 1221| 31| case Object ::Type_LAMP: { ------------------ | Branch (1221:9): [True: 31, False: 64] ------------------ 1222| 31| CheckActualType(obj->data.get(), "Lamp"); 1223| 31| aiLight *mesh = ConvertLight(in, obj, static_cast(obj->data.get()), conv_data); 1224| | 1225| 31| if (mesh) { ------------------ | Branch (1225:17): [True: 31, False: 0] ------------------ 1226| 31| conv_data.lights->push_back(mesh); 1227| 31| } 1228| 31| } break; 1229| 26| case Object ::Type_CAMERA: { ------------------ | Branch (1229:9): [True: 26, False: 69] ------------------ 1230| 26| CheckActualType(obj->data.get(), "Camera"); 1231| 26| aiCamera *mesh = ConvertCamera(in, obj, static_cast(obj->data.get()), conv_data); 1232| | 1233| 26| if (mesh) { ------------------ | Branch (1233:17): [True: 26, False: 0] ------------------ 1234| 26| conv_data.cameras->push_back(mesh); 1235| 26| } 1236| 26| } break; 1237| | 1238| | // unsupported object types / log, but do not break 1239| 0| case Object ::Type_CURVE: ------------------ | Branch (1239:9): [True: 0, False: 95] ------------------ 1240| 0| NotSupportedObjectType(obj, "Curve"); 1241| 0| break; 1242| 0| case Object ::Type_SURF: ------------------ | Branch (1242:9): [True: 0, False: 95] ------------------ 1243| 0| NotSupportedObjectType(obj, "Surface"); 1244| 0| break; 1245| 0| case Object ::Type_FONT: ------------------ | Branch (1245:9): [True: 0, False: 95] ------------------ 1246| 0| NotSupportedObjectType(obj, "Font"); 1247| 0| break; 1248| 0| case Object ::Type_MBALL: ------------------ | Branch (1248:9): [True: 0, False: 95] ------------------ 1249| 0| NotSupportedObjectType(obj, "MetaBall"); 1250| 0| break; 1251| 0| case Object ::Type_WAVE: ------------------ | Branch (1251:9): [True: 0, False: 95] ------------------ 1252| 0| NotSupportedObjectType(obj, "Wave"); 1253| 0| break; 1254| 0| case Object ::Type_LATTICE: ------------------ | Branch (1254:9): [True: 0, False: 95] ------------------ 1255| 0| NotSupportedObjectType(obj, "Lattice"); 1256| 0| break; 1257| | 1258| | // invalid or unknown type 1259| 0| default: ------------------ | Branch (1259:9): [True: 0, False: 95] ------------------ 1260| 0| break; 1261| 95| } 1262| 95| } 1263| | 1264| 475| for (unsigned int x = 0; x < 4; ++x) { ------------------ | Branch (1264:30): [True: 380, False: 95] ------------------ 1265| 1.90k| for (unsigned int y = 0; y < 4; ++y) { ------------------ | Branch (1265:34): [True: 1.52k, False: 380] ------------------ 1266| 1.52k| node->mTransformation[y][x] = obj->obmat[x][y]; 1267| 1.52k| } 1268| 380| } 1269| | 1270| 95| aiMatrix4x4 m = parentTransform; 1271| 95| m = m.Inverse(); 1272| | 1273| 95| node->mTransformation = m * node->mTransformation; 1274| | 1275| 95| if (children.size()) { ------------------ | Branch (1275:9): [True: 4, False: 91] ------------------ 1276| 4| node->mNumChildren = static_cast(children.size()); 1277| 4| aiNode **nd = node->mChildren = new aiNode *[node->mNumChildren](); 1278| 6| for (const Object *nobj : children) { ------------------ | Branch (1278:33): [True: 6, False: 4] ------------------ 1279| 6| *nd = ConvertNode(in, nobj, conv_data, node->mTransformation * parentTransform); 1280| 6| (*nd++)->mParent = node.get(); 1281| 6| } 1282| 4| } 1283| | 1284| | // apply modifiers 1285| 95| modifier_cache->ApplyModifiers(*node, conv_data, in, *obj); 1286| | 1287| 95| return node.release(); 1288| 95|} _ZNK6Assimp15BlenderImporter15ParseMagicTokenERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemE: 1290| 131|BlenderImporter::StreamOrError BlenderImporter::ParseMagicToken(const std::string &pFile, IOSystem *pIOHandler) const { 1291| 131| std::shared_ptr stream(pIOHandler->Open(pFile, "rb")); 1292| 131| if (stream == nullptr) { ------------------ | Branch (1292:9): [True: 0, False: 131] ------------------ 1293| 0| return {{}, {}, "Could not open file for reading"}; 1294| 0| } 1295| | 1296| 131| char magic[8] = { 0 }; 1297| 131| stream->Read(magic, 7, 1); 1298| 131| if (strcmp(magic, Token) == 0) { ------------------ | Branch (1298:9): [True: 56, False: 75] ------------------ 1299| 56| return {stream, {}, {}}; 1300| 56| } 1301| | 1302| | // Check for presence of the gzip header. If yes, assume it is a 1303| | // compressed blend file and try uncompressing it, else fail. This is to 1304| | // avoid uncompressing random files which our loader might end up with. 1305| |#ifdef ASSIMP_BUILD_NO_COMPRESSED_BLEND 1306| | return {{}, {}, "BLENDER magic bytes are missing, is this file compressed (Assimp was built without decompression support)?"}; 1307| |#else 1308| 75| if (magic[0] != 0x1f || static_cast(magic[1]) != 0x8b) { ------------------ | Branch (1308:9): [True: 57, False: 18] | Branch (1308:29): [True: 0, False: 18] ------------------ 1309| 57| return {{}, {}, "BLENDER magic bytes are missing, couldn't find GZIP header either"}; 1310| 57| } 1311| | 1312| 18| LogDebug("Found no BLENDER magic word but a GZIP header, might be a compressed file"); 1313| 18| if (magic[2] != 8) { ------------------ | Branch (1313:9): [True: 0, False: 18] ------------------ 1314| 0| return {{}, {}, "Unsupported GZIP compression method"}; 1315| 0| } 1316| | 1317| | // http://www.gzip.org/zlib/rfc-gzip.html#header-trailer 1318| 18| stream->Seek(0L, aiOrigin_SET); 1319| 18| std::shared_ptr reader = std::shared_ptr(new StreamReaderLE(stream)); 1320| | 1321| 18| size_t total = 0; 1322| 18| Compression compression; 1323| 18| auto uncompressed = std::make_shared>(); 1324| 18| if (compression.open(Compression::Format::Binary, Compression::FlushMode::NoFlush, 16 + Compression::MaxWBits)) { ------------------ | Branch (1324:9): [True: 18, False: 0] ------------------ 1325| 18| total = compression.decompress((unsigned char *)reader->GetPtr(), reader->GetRemainingSize(), *uncompressed); 1326| 18| compression.close(); 1327| 18| } 1328| | 1329| | // replace the input stream with a memory stream 1330| 18| stream = std::make_shared(reinterpret_cast(uncompressed->data()), total); 1331| | 1332| | // .. and retry 1333| 18| stream->Read(magic, 7, 1); 1334| 18| if (strcmp(magic, Token) == 0) { ------------------ | Branch (1334:9): [True: 8, False: 10] ------------------ 1335| 8| return {stream, uncompressed, {}}; 1336| 8| } 1337| 10| return {{}, {}, "Found no BLENDER magic word in decompressed GZIP file"}; 1338| 18|#endif 1339| 18|} _ZN6Assimp7Blender23BlenderModifierShowcase14ApplyModifiersER6aiNodeRNS0_14ConversionDataERKNS0_5SceneERKNS0_6ObjectE: 75| 95|void BlenderModifierShowcase::ApplyModifiers(aiNode &out, ConversionData &conv_data, const Scene &in, const Object &orig_object) { 76| 95| size_t cnt = 0u, ful = 0u; 77| | 78| | // NOTE: this cast is potentially unsafe by design, so we need to perform type checks before 79| | // we're allowed to dereference the pointers without risking to crash. We might still be 80| | // invoking UB btw - we're assuming that the ModifierData member of the respective modifier 81| | // structures is at offset sizeof(vftable) with no padding. 82| 95| const SharedModifierData *cur = static_cast(orig_object.modifiers.first.get()); 83| 101| for (; cur; cur = static_cast(cur->modifier.next.get()), ++ful) { ------------------ | Branch (83:12): [True: 6, False: 95] ------------------ 84| 6| ai_assert(cur->dna_type); 85| | 86| 6| const Structure *s = conv_data.db.dna.Get(cur->dna_type); 87| 6| if (!s) { ------------------ | Branch (87:13): [True: 0, False: 6] ------------------ 88| 0| ASSIMP_LOG_WARN("BlendModifier: could not resolve DNA name: ", cur->dna_type); 89| 0| continue; 90| 0| } 91| | 92| | // this is a common trait of all XXXMirrorData structures in BlenderDNA 93| 6| const Field *f = s->Get("modifier"); 94| 6| if (!f || f->offset != 0) { ------------------ | Branch (94:13): [True: 0, False: 6] | Branch (94:19): [True: 0, False: 6] ------------------ 95| 0| ASSIMP_LOG_WARN("BlendModifier: expected a `modifier` member at offset 0"); 96| 0| continue; 97| 0| } 98| | 99| 6| s = conv_data.db.dna.Get(f->type); 100| 6| if (!s || s->name != "ModifierData") { ------------------ | Branch (100:13): [True: 0, False: 6] | Branch (100:19): [True: 0, False: 6] ------------------ 101| 0| ASSIMP_LOG_WARN("BlendModifier: expected a ModifierData structure as first member"); 102| 0| continue; 103| 0| } 104| | 105| | // now, we can be sure that we should be fine to dereference *cur* as 106| | // ModifierData (with the above note). 107| 6| const ModifierData &dat = cur->modifier; 108| | 109| 6| const fpCreateModifier *curgod = creators; 110| 6| std::vector::iterator curmod = cached_modifiers->begin(), endmod = cached_modifiers->end(); 111| | 112| 10| for (; *curgod; ++curgod, ++curmod) { // allocate modifiers on the fly ------------------ | Branch (112:16): [True: 10, False: 0] ------------------ 113| 10| if (curmod == endmod) { ------------------ | Branch (113:17): [True: 9, False: 1] ------------------ 114| 9| cached_modifiers->push_back((*curgod)()); 115| | 116| 9| endmod = cached_modifiers->end(); 117| 9| curmod = endmod - 1; 118| 9| } 119| | 120| 10| BlenderModifier *const modifier = *curmod; 121| 10| if (modifier->IsActive(dat)) { ------------------ | Branch (121:17): [True: 6, False: 4] ------------------ 122| 6| modifier->DoIt(out, conv_data, *static_cast(cur), in, orig_object); 123| 6| cnt++; 124| | 125| 6| curgod = nullptr; 126| 6| break; 127| 6| } 128| 10| } 129| 6| if (curgod) { ------------------ | Branch (129:13): [True: 0, False: 6] ------------------ 130| 0| ASSIMP_LOG_WARN("Couldn't find a handler for modifier: ", dat.name); 131| 0| } 132| 6| } 133| | 134| | // Even though we managed to resolve some or all of the modifiers on this 135| | // object, we still can't say whether our modifier implementations were 136| | // able to fully do their job. 137| 95| if (ful) { ------------------ | Branch (137:9): [True: 5, False: 90] ------------------ 138| | ASSIMP_LOG_DEBUG("BlendModifier: found handlers for ", cnt, " of ", ful, " modifiers on `", orig_object.id.name, 139| 5| "`, check log messages above for errors"); 140| 5| } 141| 95|} _ZN6Assimp7Blender22BlenderModifier_Mirror8IsActiveERKNS0_12ModifierDataE: 144| 6|bool BlenderModifier_Mirror ::IsActive(const ModifierData &modin) { 145| 6| return modin.type == ModifierData::eModifierType_Mirror; 146| 6|} _ZN6Assimp7Blender22BlenderModifier_Mirror4DoItER6aiNodeRNS0_14ConversionDataERKNS0_8ElemBaseERKNS0_5SceneERKNS0_6ObjectE: 151| 2| const Object &orig_object) { 152| | // hijacking the ABI, see the big note in BlenderModifierShowcase::ApplyModifiers() 153| 2| const MirrorModifierData &mir = static_cast(orig_modifier); 154| 2| ai_assert(mir.modifier.type == ModifierData::eModifierType_Mirror); 155| 2| std::shared_ptr mirror_ob = mir.mirror_ob.lock(); 156| | 157| 2| conv_data.meshes->reserve(conv_data.meshes->size() + out.mNumMeshes); 158| | 159| | // XXX not entirely correct, mirroring on two axes results in 4 distinct objects in blender ... 160| | 161| | // take all input meshes and clone them 162| 4| for (unsigned int i = 0; i < out.mNumMeshes; ++i) { ------------------ | Branch (162:30): [True: 2, False: 2] ------------------ 163| 2| aiMesh *mesh; 164| 2| SceneCombiner::Copy(&mesh, conv_data.meshes[out.mMeshes[i]]); 165| | 166| 2| const float xs = mir.flag & MirrorModifierData::Flags_AXIS_X ? -1.f : 1.f; ------------------ | Branch (166:26): [True: 2, False: 0] ------------------ 167| 2| const float ys = mir.flag & MirrorModifierData::Flags_AXIS_Y ? -1.f : 1.f; ------------------ | Branch (167:26): [True: 1, False: 1] ------------------ 168| 2| const float zs = mir.flag & MirrorModifierData::Flags_AXIS_Z ? -1.f : 1.f; ------------------ | Branch (168:26): [True: 1, False: 1] ------------------ 169| | 170| 2| if (mirror_ob) { ------------------ | Branch (170:13): [True: 1, False: 1] ------------------ 171| 1| const aiVector3D center(mirror_ob->obmat[3][0], mirror_ob->obmat[3][1], mirror_ob->obmat[3][2]); 172| 25| for (unsigned int j = 0; j < mesh->mNumVertices; ++j) { ------------------ | Branch (172:38): [True: 24, False: 1] ------------------ 173| 24| aiVector3D &v = mesh->mVertices[j]; 174| | 175| 24| v.x = center.x + xs * (center.x - v.x); 176| 24| v.y = center.y + ys * (center.y - v.y); 177| 24| v.z = center.z + zs * (center.z - v.z); 178| 24| } 179| 1| } else { 180| 536| for (unsigned int j = 0; j < mesh->mNumVertices; ++j) { ------------------ | Branch (180:38): [True: 535, False: 1] ------------------ 181| 535| aiVector3D &v = mesh->mVertices[j]; 182| 535| v.x *= xs; 183| 535| v.y *= ys; 184| 535| v.z *= zs; 185| 535| } 186| 1| } 187| | 188| 2| if (mesh->mNormals) { ------------------ | Branch (188:13): [True: 2, False: 0] ------------------ 189| 561| for (unsigned int j = 0; j < mesh->mNumVertices; ++j) { ------------------ | Branch (189:38): [True: 559, False: 2] ------------------ 190| 559| aiVector3D &v = mesh->mNormals[j]; 191| 559| v.x *= xs; 192| 559| v.y *= ys; 193| 559| v.z *= zs; 194| 559| } 195| 2| } 196| | 197| 2| if (mesh->mTangents) { ------------------ | Branch (197:13): [True: 0, False: 2] ------------------ 198| 0| for (unsigned int j = 0; j < mesh->mNumVertices; ++j) { ------------------ | Branch (198:38): [True: 0, False: 0] ------------------ 199| 0| aiVector3D &v = mesh->mTangents[j]; 200| 0| v.x *= xs; 201| 0| v.y *= ys; 202| 0| v.z *= zs; 203| 0| } 204| 0| } 205| | 206| 2| if (mesh->mBitangents) { ------------------ | Branch (206:13): [True: 0, False: 2] ------------------ 207| 0| for (unsigned int j = 0; j < mesh->mNumVertices; ++j) { ------------------ | Branch (207:38): [True: 0, False: 0] ------------------ 208| 0| aiVector3D &v = mesh->mBitangents[j]; 209| 0| v.x *= xs; 210| 0| v.y *= ys; 211| 0| v.z *= zs; 212| 0| } 213| 0| } 214| | 215| 2| const float us = mir.flag & MirrorModifierData::Flags_MIRROR_U ? -1.f : 1.f; ------------------ | Branch (215:26): [True: 0, False: 2] ------------------ 216| 2| const float vs = mir.flag & MirrorModifierData::Flags_MIRROR_V ? -1.f : 1.f; ------------------ | Branch (216:26): [True: 0, False: 2] ------------------ 217| | 218| 2| for (unsigned int n = 0; mesh->HasTextureCoords(n); ++n) { ------------------ | Branch (218:34): [True: 0, False: 2] ------------------ 219| 0| for (unsigned int j = 0; j < mesh->mNumVertices; ++j) { ------------------ | Branch (219:38): [True: 0, False: 0] ------------------ 220| 0| aiVector3D &v = mesh->mTextureCoords[n][j]; 221| 0| v.x *= us; 222| 0| v.y *= vs; 223| 0| } 224| 0| } 225| | 226| | // Only reverse the winding order if an odd number of axes were mirrored. 227| 2| if (xs * ys * zs < 0) { ------------------ | Branch (227:13): [True: 2, False: 0] ------------------ 228| 142| for (unsigned int j = 0; j < mesh->mNumFaces; ++j) { ------------------ | Branch (228:38): [True: 140, False: 2] ------------------ 229| 140| aiFace &face = mesh->mFaces[j]; 230| 419| for (unsigned int fi = 0; fi < face.mNumIndices / 2; ++fi) ------------------ | Branch (230:43): [True: 279, False: 140] ------------------ 231| 279| std::swap(face.mIndices[fi], face.mIndices[face.mNumIndices - 1 - fi]); 232| 140| } 233| 2| } 234| | 235| 2| conv_data.meshes->push_back(mesh); 236| 2| } 237| 2| unsigned int *nind = new unsigned int[out.mNumMeshes * 2]; 238| | 239| 2| std::copy(out.mMeshes, out.mMeshes + out.mNumMeshes, nind); 240| 2| std::transform(out.mMeshes, out.mMeshes + out.mNumMeshes, nind + out.mNumMeshes, 241| 2| [&out](unsigned int n) { return out.mNumMeshes + n; }); 242| | 243| 2| delete[] out.mMeshes; 244| 2| out.mMeshes = nind; 245| 2| out.mNumMeshes *= 2; 246| | 247| | ASSIMP_LOG_INFO("BlendModifier: Applied the `Mirror` modifier to `", 248| 2| orig_object.id.name, "`"); 249| 2|} _ZN6Assimp7Blender27BlenderModifier_Subdivision8IsActiveERKNS0_12ModifierDataE: 252| 4|bool BlenderModifier_Subdivision ::IsActive(const ModifierData &modin) { 253| 4| return modin.type == ModifierData::eModifierType_Subsurf; 254| 4|} _ZN6Assimp7Blender27BlenderModifier_Subdivision4DoItER6aiNodeRNS0_14ConversionDataERKNS0_8ElemBaseERKNS0_5SceneERKNS0_6ObjectE: 259| 4| const Object &orig_object) { 260| | // hijacking the ABI, see the big note in BlenderModifierShowcase::ApplyModifiers() 261| 4| const SubsurfModifierData &mir = static_cast(orig_modifier); 262| 4| ai_assert(mir.modifier.type == ModifierData::eModifierType_Subsurf); 263| | 264| 4| Subdivider::Algorithm algo; 265| 4| switch (mir.subdivType) { 266| 4| case SubsurfModifierData::TYPE_CatmullClarke: ------------------ | Branch (266:5): [True: 4, False: 0] ------------------ 267| 4| algo = Subdivider::CATMULL_CLARKE; 268| 4| break; 269| | 270| 0| case SubsurfModifierData::TYPE_Simple: ------------------ | Branch (270:5): [True: 0, False: 4] ------------------ 271| 0| ASSIMP_LOG_WARN("BlendModifier: The `SIMPLE` subdivision algorithm is not currently implemented, using Catmull-Clarke"); 272| 0| algo = Subdivider::CATMULL_CLARKE; 273| 0| break; 274| | 275| 0| default: ------------------ | Branch (275:5): [True: 0, False: 4] ------------------ 276| 0| ASSIMP_LOG_WARN("BlendModifier: Unrecognized subdivision algorithm: ", mir.subdivType); 277| 0| return; 278| 4| }; 279| | 280| 4| std::unique_ptr subd(Subdivider::Create(algo)); 281| 4| ai_assert(subd); 282| 4| if (conv_data.meshes->empty()) { ------------------ | Branch (282:9): [True: 0, False: 4] ------------------ 283| 0| return; 284| 0| } 285| 4| const size_t meshIndex = conv_data.meshes->size() - out.mNumMeshes; 286| 4| if (meshIndex >= conv_data.meshes->size()) { ------------------ | Branch (286:9): [True: 0, False: 4] ------------------ 287| 0| ASSIMP_LOG_ERROR("Invalid index detected."); 288| 0| return; 289| 0| } 290| 4| aiMesh **const meshes = &conv_data.meshes[conv_data.meshes->size() - out.mNumMeshes]; 291| 4| std::unique_ptr tempmeshes(new aiMesh *[out.mNumMeshes]()); 292| | 293| 4| subd->Subdivide(meshes, out.mNumMeshes, tempmeshes.get(), std::max(mir.renderLevels, mir.levels), true); 294| 4| std::copy(tempmeshes.get(), tempmeshes.get() + out.mNumMeshes, meshes); 295| | 296| | ASSIMP_LOG_INFO("BlendModifier: Applied the `Subdivision` modifier to `", 297| 4| orig_object.id.name, "`"); 298| 4|} _Z3godIN6Assimp7Blender22BlenderModifier_MirrorEEPNS1_15BlenderModifierEv: 60| 5|BlenderModifier *god() { 61| 5| return new T(); 62| 5|} _Z3godIN6Assimp7Blender27BlenderModifier_SubdivisionEEPNS1_15BlenderModifierEv: 60| 4|BlenderModifier *god() { 61| 4| return new T(); 62| 4|} BlenderModifier.cpp:_ZZN6Assimp7Blender22BlenderModifier_Mirror4DoItER6aiNodeRNS0_14ConversionDataERKNS0_8ElemBaseERKNS0_5SceneERKNS0_6ObjectEENK3$_0clEj: 241| 2| [&out](unsigned int n) { return out.mNumMeshes + n; }); _ZN6Assimp7Blender15BlenderModifierD2Ev: 64| 9| virtual ~BlenderModifier() = default; _ZNK6Assimp7Blender9Structure7ConvertINS0_6ObjectEEEvRT_RKNS0_12FileDatabaseE: 59| 100| const FileDatabase &db) const { 60| | 61| 100| ReadField(dest.id, "id", db); 62| 100| int temp = 0; 63| 100| ReadField(temp, "type", db); 64| 100| dest.type = static_cast(temp); 65| 100| ReadFieldArray2(dest.obmat, "obmat", db); 66| 100| ReadFieldArray2(dest.parentinv, "parentinv", db); 67| 100| ReadFieldArray(dest.parsubstr, "parsubstr", db); 68| 100| { 69| 100| std::shared_ptr parent; 70| 100| ReadFieldPtr(parent, "*parent", db); 71| 100| dest.parent = parent.get(); 72| 100| } 73| 100| ReadFieldPtr(dest.track, "*track", db); 74| 100| ReadFieldPtr(dest.proxy, "*proxy", db); 75| 100| ReadFieldPtr(dest.proxy_from, "*proxy_from", db); 76| 100| ReadFieldPtr(dest.proxy_group, "*proxy_group", db); 77| 100| ReadFieldPtr(dest.dup_group, "*dup_group", db); 78| 100| ReadFieldPtr(dest.data, "*data", db); 79| 100| ReadField(dest.modifiers, "modifiers", db); 80| | 81| 100| db.reader->IncPtr(size); 82| 100|} _ZNK6Assimp7Blender9Structure7ConvertINS0_16CollectionObjectEEEvRT_RKNS0_12FileDatabaseE: 101| 3| const FileDatabase &db) const { 102| | 103| 3| ReadFieldPtr(dest.next, "*next", db); 104| 3| { 105| 3| std::shared_ptr ob; 106| 3| ReadFieldPtr(ob, "*ob", db); 107| 3| dest.ob = ob.get(); 108| 3| } 109| | 110| 3| db.reader->IncPtr(size); 111| 3|} _ZNK6Assimp7Blender9Structure7ConvertINS0_15CollectionChildEEEvRT_RKNS0_12FileDatabaseE: 117| 1| const FileDatabase &db) const { 118| | 119| 1| ReadFieldPtr(dest.prev, "*prev", db); 120| 1| ReadFieldPtr(dest.next, "*next", db); 121| 1| ReadFieldPtr(dest.collection, "*collection", db); 122| | 123| 1| db.reader->IncPtr(size); 124| 1|} _ZNK6Assimp7Blender9Structure7ConvertINS0_10CollectionEEEvRT_RKNS0_12FileDatabaseE: 130| 2| const FileDatabase &db) const { 131| | 132| 2| ReadField(dest.id, "id", db); 133| 2| ReadField(dest.gobject, "gobject", db); 134| 2| ReadField(dest.children, "children", db); 135| | 136| 2| db.reader->IncPtr(size); 137| 2|} _ZNK6Assimp7Blender9Structure7ConvertINS0_4MTexEEEvRT_RKNS0_12FileDatabaseE: 143| 28| const FileDatabase &db) const { 144| | 145| 28| int temp_short = 0; 146| 28| ReadField(temp_short, "mapto", db); 147| 28| dest.mapto = static_cast(temp_short); 148| 28| int temp = 0; 149| 28| ReadField(temp, "blendtype", db); 150| 28| dest.blendtype = static_cast(temp); 151| 28| ReadFieldPtr(dest.object, "*object", db); 152| 28| ReadFieldPtr(dest.tex, "*tex", db); 153| 28| ReadFieldArray(dest.uvname, "uvname", db); 154| 28| ReadField(temp, "projx", db); 155| 28| dest.projx = static_cast(temp); 156| 28| ReadField(temp, "projy", db); 157| 28| dest.projy = static_cast(temp); 158| 28| ReadField(temp, "projz", db); 159| 28| dest.projz = static_cast(temp); 160| 28| ReadField(dest.mapping, "mapping", db); 161| 28| ReadFieldArray(dest.ofs, "ofs", db); 162| 28| ReadFieldArray(dest.size, "size", db); 163| 28| ReadField(dest.rot, "rot", db); 164| 28| ReadField(dest.texflag, "texflag", db); 165| 28| ReadField(dest.colormodel, "colormodel", db); 166| 28| ReadField(dest.pmapto, "pmapto", db); 167| 28| ReadField(dest.pmaptoneg, "pmaptoneg", db); 168| 28| ReadField(dest.r, "r", db); 169| 28| ReadField(dest.g, "g", db); 170| 28| ReadField(dest.b, "b", db); 171| 28| ReadField(dest.k, "k", db); 172| 28| ReadField(dest.colspecfac, "colspecfac", db); 173| 28| ReadField(dest.mirrfac, "mirrfac", db); 174| 28| ReadField(dest.alphafac, "alphafac", db); 175| 28| ReadField(dest.difffac, "difffac", db); 176| 28| ReadField(dest.specfac, "specfac", db); 177| 28| ReadField(dest.emitfac, "emitfac", db); 178| 28| ReadField(dest.hardfac, "hardfac", db); 179| 28| ReadField(dest.norfac, "norfac", db); 180| | 181| 28| db.reader->IncPtr(size); 182| 28|} _ZNK6Assimp7Blender9Structure7ConvertINS0_19SubsurfModifierDataEEEvRT_RKNS0_12FileDatabaseE: 204| 4| const FileDatabase &db) const { 205| | 206| 4| ReadField(dest.modifier, "modifier", db); 207| 4| ReadField(dest.subdivType, "subdivType", db); 208| 4| ReadField(dest.levels, "levels", db); 209| 4| ReadField(dest.renderLevels, "renderLevels", db); 210| 4| ReadField(dest.flags, "flags", db); 211| | 212| 4| db.reader->IncPtr(size); 213| 4|} _ZNK6Assimp7Blender9Structure7ConvertINS0_5MFaceEEEvRT_RKNS0_12FileDatabaseE: 219| 15.0k| const FileDatabase &db) const { 220| | 221| 15.0k| ReadField(dest.v1, "v1", db); 222| 15.0k| ReadField(dest.v2, "v2", db); 223| 15.0k| ReadField(dest.v3, "v3", db); 224| 15.0k| ReadField(dest.v4, "v4", db); 225| 15.0k| ReadField(dest.mat_nr, "mat_nr", db); 226| 15.0k| ReadField(dest.flag, "flag", db); 227| | 228| 15.0k| db.reader->IncPtr(size); 229| 15.0k|} _ZNK6Assimp7Blender9Structure7ConvertINS0_4LampEEEvRT_RKNS0_12FileDatabaseE: 235| 31| const FileDatabase &db) const { 236| | 237| 31| ReadField(dest.id, "id", db); 238| 31| int temp = 0; 239| 31| ReadField(temp, "type", db); 240| 31| dest.type = static_cast(temp); 241| 31| ReadField(dest.flags, "flag", db); 242| 31| ReadField(dest.colormodel, "colormodel", db); 243| 31| ReadField(dest.totex, "totex", db); 244| 31| ReadField(dest.r, "r", db); 245| 31| ReadField(dest.g, "g", db); 246| 31| ReadField(dest.b, "b", db); 247| 31| ReadField(dest.k, "k", db); 248| 31| ReadField(dest.energy, "energy", db); 249| 31| ReadField(dest.dist, "dist", db); 250| 31| ReadField(dest.spotsize, "spotsize", db); 251| 31| ReadField(dest.spotblend, "spotblend", db); 252| 31| ReadField(dest.constant_coefficient, "coeff_const", db); 253| 31| ReadField(dest.linear_coefficient, "coeff_lin", db); 254| 31| ReadField(dest.quadratic_coefficient, "coeff_quad", db); 255| 31| ReadField(dest.att1, "att1", db); 256| 31| ReadField(dest.att2, "att2", db); 257| 31| ReadField(temp, "falloff_type", db); 258| 31| dest.falloff_type = static_cast(temp); 259| 31| ReadField(dest.sun_brightness, "sun_brightness", db); 260| 31| ReadField(dest.area_size, "area_size", db); 261| 31| ReadField(dest.area_sizey, "area_sizey", db); 262| 31| ReadField(dest.area_sizez, "area_sizez", db); 263| 31| ReadField(dest.area_shape, "area_shape", db); 264| | 265| 31| db.reader->IncPtr(size); 266| 31|} _ZNK6Assimp7Blender9Structure7ConvertINS0_10PackedFileEEEvRT_RKNS0_12FileDatabaseE: 284| 1| const FileDatabase &db) const { 285| | 286| 1| ReadField(dest.size, "size", db); 287| 1| ReadField(dest.seek, "seek", db); 288| 1| ReadFieldPtr(dest.data, "*data", db); 289| | 290| 1| db.reader->IncPtr(size); 291| 1|} _ZNK6Assimp7Blender9Structure7ConvertINS0_4BaseEEEvRT_RKNS0_12FileDatabaseE: 297| 31| const FileDatabase &db) const { 298| | // note: as per https://github.com/assimp/assimp/issues/128, 299| | // reading the Object linked list recursively is prone to stack overflow. 300| | // This structure converter is therefore a hand-written exception that 301| | // does it iteratively. 302| | 303| 31| const int initial_pos = db.reader->GetCurrentPos(); 304| | 305| 31| std::pair todo = std::make_pair(&dest, initial_pos); 306| 96| for (;;) { 307| | 308| 96| Base &cur_dest = *todo.first; 309| 96| db.reader->SetCurrentPos(todo.second); 310| | 311| | // we know that this is a double-linked, circular list which we never 312| | // traverse backwards, so don't bother resolving the back links. 313| 96| cur_dest.prev = nullptr; 314| | 315| 96| ReadFieldPtr(cur_dest.object, "*object", db); 316| | 317| | // the return value of ReadFieldPtr indicates whether the object 318| | // was already cached. In this case, we don't need to resolve 319| | // it again. 320| 96| if (!ReadFieldPtr(cur_dest.next, "*next", db, true) && cur_dest.next) { ------------------ | Branch (320:13): [True: 89, False: 7] | Branch (320:82): [True: 65, False: 24] ------------------ 321| 65| todo = std::make_pair(&*cur_dest.next, db.reader->GetCurrentPos()); 322| 65| continue; 323| 65| } 324| 31| break; 325| 96| } 326| | 327| 31| db.reader->SetCurrentPos(initial_pos + size); 328| 31|} _ZNK6Assimp7Blender9Structure7ConvertINS0_6MTFaceEEEvRT_RKNS0_12FileDatabaseE: 334| 28| const FileDatabase &db) const { 335| | 336| 28| ReadFieldArray2(dest.uv, "uv", db); 337| 28| ReadField(dest.flag, "flag", db); 338| 28| ReadField(dest.mode, "mode", db); 339| 28| ReadField(dest.tile, "tile", db); 340| 28| ReadField(dest.unwrap, "unwrap", db); 341| | 342| 28| db.reader->IncPtr(size); 343| 28|} _ZNK6Assimp7Blender9Structure7ConvertINS0_8MaterialEEEvRT_RKNS0_12FileDatabaseE: 349| 28| const FileDatabase &db) const { 350| 28| ReadField(dest.id, "id", db); 351| 28| ReadField(dest.r, "r", db); 352| 28| ReadField(dest.g, "g", db); 353| 28| ReadField(dest.b, "b", db); 354| 28| ReadField(dest.specr, "specr", db); 355| 28| ReadField(dest.specg, "specg", db); 356| 28| ReadField(dest.specb, "specb", db); 357| 28| ReadField(dest.har, "har", db); 358| 28| ReadField(dest.ambr, "ambr", db); 359| 28| ReadField(dest.ambg, "ambg", db); 360| 28| ReadField(dest.ambb, "ambb", db); 361| 28| ReadField(dest.mirr, "mirr", db); 362| 28| ReadField(dest.mirg, "mirg", db); 363| 28| ReadField(dest.mirb, "mirb", db); 364| 28| ReadField(dest.emit, "emit", db); 365| 28| ReadField(dest.ray_mirror, "ray_mirror", db); 366| 28| ReadField(dest.alpha, "alpha", db); 367| 28| ReadField(dest.ref, "ref", db); 368| 28| ReadField(dest.translucency, "translucency", db); 369| 28| ReadField(dest.mode, "mode", db); 370| 28| ReadField(dest.roughness, "roughness", db); 371| 28| ReadField(dest.darkness, "darkness", db); 372| 28| ReadField(dest.refrac, "refrac", db); 373| 28| ReadFieldPtr(dest.group, "*group", db); 374| 28| ReadField(dest.diff_shader, "diff_shader", db); 375| 28| ReadField(dest.spec_shader, "spec_shader", db); 376| 28| ReadFieldPtr(dest.mtex, "*mtex", db); 377| | 378| 28| ReadField(dest.amb, "amb", db); 379| 28| ReadField(dest.ang, "ang", db); 380| 28| ReadField(dest.spectra, "spectra", db); 381| 28| ReadField(dest.spec, "spec", db); 382| 28| ReadField(dest.zoffs, "zoffs", db); 383| 28| ReadField(dest.add, "add", db); 384| 28| ReadField(dest.fresnel_mir, "fresnel_mir", db); 385| 28| ReadField(dest.fresnel_mir_i, "fresnel_mir_i", db); 386| 28| ReadField(dest.fresnel_tra, "fresnel_tra", db); 387| 28| ReadField(dest.fresnel_tra_i, "fresnel_tra_i", db); 388| 28| ReadField(dest.filter, "filter", db); 389| 28| ReadField(dest.tx_limit, "tx_limit", db); 390| 28| ReadField(dest.tx_falloff, "tx_falloff", db); 391| 28| ReadField(dest.gloss_mir, "gloss_mir", db); 392| 28| ReadField(dest.gloss_tra, "gloss_tra", db); 393| 28| ReadField(dest.adapt_thresh_mir, "adapt_thresh_mir", db); 394| 28| ReadField(dest.adapt_thresh_tra, "adapt_thresh_tra", db); 395| 28| ReadField(dest.aniso_gloss_mir, "aniso_gloss_mir", db); 396| 28| ReadField(dest.dist_mir, "dist_mir", db); 397| 28| ReadField(dest.hasize, "hasize", db); 398| 28| ReadField(dest.flaresize, "flaresize", db); 399| 28| ReadField(dest.subsize, "subsize", db); 400| 28| ReadField(dest.flareboost, "flareboost", db); 401| 28| ReadField(dest.strand_sta, "strand_sta", db); 402| 28| ReadField(dest.strand_end, "strand_end", db); 403| 28| ReadField(dest.strand_ease, "strand_ease", db); 404| 28| ReadField(dest.strand_surfnor, "strand_surfnor", db); 405| 28| ReadField(dest.strand_min, "strand_min", db); 406| 28| ReadField(dest.strand_widthfade, "strand_widthfade", db); 407| 28| ReadField(dest.sbias, "sbias", db); 408| 28| ReadField(dest.lbias, "lbias", db); 409| 28| ReadField(dest.shad_alpha, "shad_alpha", db); 410| 28| ReadField(dest.param, "param", db); 411| 28| ReadField(dest.rms, "rms", db); 412| 28| ReadField(dest.rampfac_col, "rampfac_col", db); 413| 28| ReadField(dest.rampfac_spec, "rampfac_spec", db); 414| 28| ReadField(dest.friction, "friction", db); 415| 28| ReadField(dest.fh, "fh", db); 416| 28| ReadField(dest.reflect, "reflect", db); 417| 28| ReadField(dest.fhdist, "fhdist", db); 418| 28| ReadField(dest.xyfrict, "xyfrict", db); 419| 28| ReadField(dest.sss_radius, "sss_radius", db); 420| 28| ReadField(dest.sss_col, "sss_col", db); 421| 28| ReadField(dest.sss_error, "sss_error", db); 422| 28| ReadField(dest.sss_scale, "sss_scale", db); 423| 28| ReadField(dest.sss_ior, "sss_ior", db); 424| 28| ReadField(dest.sss_colfac, "sss_colfac", db); 425| 28| ReadField(dest.sss_texfac, "sss_texfac", db); 426| 28| ReadField(dest.sss_front, "sss_front", db); 427| 28| ReadField(dest.sss_back, "sss_back", db); 428| | 429| 28| ReadField(dest.material_type, "material_type", db); 430| 28| ReadField(dest.flag, "flag", db); 431| 28| ReadField(dest.ray_depth, "ray_depth", db); 432| 28| ReadField(dest.ray_depth_tra, "ray_depth_tra", db); 433| 28| ReadField(dest.samp_gloss_mir, "samp_gloss_mir", db); 434| 28| ReadField(dest.samp_gloss_tra, "samp_gloss_tra", db); 435| 28| ReadField(dest.fadeto_mir, "fadeto_mir", db); 436| 28| ReadField(dest.shade_flag, "shade_flag", db); 437| 28| ReadField(dest.flarec, "flarec", db); 438| 28| ReadField(dest.starc, "starc", db); 439| 28| ReadField(dest.linec, "linec", db); 440| 28| ReadField(dest.ringc, "ringc", db); 441| 28| ReadField(dest.pr_lamp, "pr_lamp", db); 442| 28| ReadField(dest.pr_texture, "pr_texture", db); 443| 28| ReadField(dest.ml_flag, "ml_flag", db); 444| 28| ReadField(dest.diff_shader, "diff_shader", db); 445| 28| ReadField(dest.spec_shader, "spec_shader", db); 446| 28| ReadField(dest.texco, "texco", db); 447| 28| ReadField(dest.mapto, "mapto", db); 448| 28| ReadField(dest.ramp_show, "ramp_show", db); 449| 28| ReadField(dest.pad3, "pad3", db); 450| 28| ReadField(dest.dynamode, "dynamode", db); 451| 28| ReadField(dest.pad2, "pad2", db); 452| 28| ReadField(dest.sss_flag, "sss_flag", db); 453| 28| ReadField(dest.sss_preset, "sss_preset", db); 454| 28| ReadField(dest.shadowonly_flag, "shadowonly_flag", db); 455| 28| ReadField(dest.index, "index", db); 456| 28| ReadField(dest.vcol_alpha, "vcol_alpha", db); 457| 28| ReadField(dest.pad4, "pad4", db); 458| | 459| 28| ReadField(dest.seed1, "seed1", db); 460| 28| ReadField(dest.seed2, "seed2", db); 461| | 462| 28| db.reader->IncPtr(size); 463| 28|} _ZNK6Assimp7Blender9Structure7ConvertINS0_8MTexPolyEEEvRT_RKNS0_12FileDatabaseE: 469| 91| const FileDatabase &db) const { 470| | 471| 91| { 472| 91| std::shared_ptr tpage; 473| 91| ReadFieldPtr(tpage, "*tpage", db); 474| 91| dest.tpage = tpage.get(); 475| 91| } 476| 91| ReadField(dest.flag, "flag", db); 477| 91| ReadField(dest.transp, "transp", db); 478| 91| ReadField(dest.mode, "mode", db); 479| 91| ReadField(dest.tile, "tile", db); 480| 91| ReadField(dest.pad, "pad", db); 481| | 482| 91| db.reader->IncPtr(size); 483| 91|} _ZNK6Assimp7Blender9Structure7ConvertINS0_4MeshEEEvRT_RKNS0_12FileDatabaseE: 489| 42| const FileDatabase &db) const { 490| | 491| 42| ReadField(dest.id, "id", db); 492| 42| ReadField(dest.totface, "totface", db); 493| 42| ReadField(dest.totedge, "totedge", db); 494| 42| ReadField(dest.totvert, "totvert", db); 495| 42| ReadField(dest.totloop, "totloop", db); 496| 42| ReadField(dest.totpoly, "totpoly", db); 497| 42| ReadField(dest.subdiv, "subdiv", db); 498| 42| ReadField(dest.subdivr, "subdivr", db); 499| 42| ReadField(dest.subsurftype, "subsurftype", db); 500| 42| ReadField(dest.smoothresh, "smoothresh", db); 501| 42| ReadFieldPtr(dest.mface, "*mface", db); 502| 42| ReadFieldPtr(dest.mtface, "*mtface", db); 503| 42| ReadFieldPtr(dest.tface, "*tface", db); 504| 42| ReadFieldPtr(dest.mvert, "*mvert", db); 505| 42| ReadFieldPtr(dest.medge, "*medge", db); 506| 42| ReadFieldPtr(dest.mloop, "*mloop", db); 507| 42| ReadFieldPtr(dest.mloopuv, "*mloopuv", db); 508| 42| ReadFieldPtr(dest.mloopcol, "*mloopcol", db); 509| 42| ReadFieldPtr(dest.mpoly, "*mpoly", db); 510| 42| ReadFieldPtr(dest.mtpoly, "*mtpoly", db); 511| 42| ReadFieldPtr(dest.dvert, "*dvert", db); 512| 42| ReadFieldPtr(dest.mcol, "*mcol", db); 513| 42| ReadFieldPtr(dest.mat, "**mat", db); 514| | 515| 42| ReadField(dest.vdata, "vdata", db); 516| 42| ReadField(dest.edata, "edata", db); 517| 42| ReadField(dest.fdata, "fdata", db); 518| 42| ReadField(dest.pdata, "pdata", db); 519| 42| ReadField(dest.ldata, "ldata", db); 520| | 521| 42| db.reader->IncPtr(size); 522| 42|} _ZNK6Assimp7Blender9Structure7ConvertINS0_5WorldEEEvRT_RKNS0_12FileDatabaseE: 540| 26| const FileDatabase &db) const { 541| | 542| 26| ReadField(dest.id, "id", db); 543| | 544| 26| db.reader->IncPtr(size); 545| 26|} _ZNK6Assimp7Blender9Structure7ConvertINS0_5MVertEEEvRT_RKNS0_12FileDatabaseE: 565| 18.0k| const FileDatabase &db) const { 566| | 567| 18.0k| ReadFieldArray(dest.co, "co", db); 568| 18.0k| ReadFieldArray(dest.no, "no", db); 569| 18.0k| ReadField(dest.flag, "flag", db); 570| | //ReadField(dest.mat_nr,"mat_nr",db); 571| 18.0k| ReadField(dest.bweight, "bweight", db); 572| | 573| 18.0k| db.reader->IncPtr(size); 574| 18.0k|} _ZNK6Assimp7Blender9Structure7ConvertINS0_5MEdgeEEEvRT_RKNS0_12FileDatabaseE: 580| 33.9k| const FileDatabase &db) const { 581| | 582| 33.9k| ReadField(dest.v1, "v1", db); 583| 33.9k| ReadField(dest.v2, "v2", db); 584| 33.9k| ReadField(dest.crease, "crease", db); 585| 33.9k| ReadField(dest.bweight, "bweight", db); 586| 33.9k| ReadField(dest.flag, "flag", db); 587| | 588| 33.9k| db.reader->IncPtr(size); 589| 33.9k|} _ZNK6Assimp7Blender9Structure7ConvertINS0_7MLoopUVEEEvRT_RKNS0_12FileDatabaseE: 595| 324| const FileDatabase &db) const { 596| | 597| 324| ReadFieldArray(dest.uv, "uv", db); 598| 324| ReadField(dest.flag, "flag", db); 599| | 600| 324| db.reader->IncPtr(size); 601| 324|} _ZNK6Assimp7Blender9Structure7ConvertINS0_8ListBaseEEEvRT_RKNS0_12FileDatabaseE: 620| 128| const FileDatabase &db) const { 621| | 622| 128| ReadFieldPtr(dest.first, "*first", db); 623| 128| std::shared_ptr last; 624| 128| ReadFieldPtr(last, "*last", db); 625| 128| dest.last = last; 626| | 627| 128| db.reader->IncPtr(size); 628| 128|} _ZNK6Assimp7Blender9Structure7ConvertINS0_5MLoopEEEvRT_RKNS0_12FileDatabaseE: 634| 5.31k| const FileDatabase &db) const { 635| | 636| 5.31k| ReadField(dest.v, "v", db); 637| 5.31k| ReadField(dest.e, "e", db); 638| | 639| 5.31k| db.reader->IncPtr(size); 640| 5.31k|} _ZNK6Assimp7Blender9Structure7ConvertINS0_12ModifierDataEEEvRT_RKNS0_12FileDatabaseE: 646| 6| const FileDatabase &db) const { 647| | 648| 6| ReadFieldPtr(dest.next, "*next", db); 649| 6| std::shared_ptr prev; 650| 6| ReadFieldPtr(prev, "*prev", db); 651| 6| dest.prev = prev; 652| 6| ReadField(dest.type, "type", db); 653| 6| ReadField(dest.mode, "mode", db); 654| 6| ReadFieldArray(dest.name, "name", db); 655| | 656| 6| db.reader->IncPtr(size); 657| 6|} _ZNK6Assimp7Blender9Structure7ConvertINS0_2IDEEEvRT_RKNS0_12FileDatabaseE: 663| 290| const FileDatabase &db) const { 664| | 665| 290| ReadFieldArray(dest.name, "name", db); 666| 290| ReadField(dest.flag, "flag", db); 667| | 668| 290| db.reader->IncPtr(size); 669| 290|} _ZNK6Assimp7Blender9Structure7ConvertINS0_4MColEEEvRT_RKNS0_12FileDatabaseE: 675| 24| const FileDatabase &db) const { 676| | 677| 24| ReadField(dest.r, "r", db); 678| 24| ReadField(dest.g, "g", db); 679| 24| ReadField(dest.b, "b", db); 680| 24| ReadField(dest.a, "a", db); 681| | 682| 24| db.reader->IncPtr(size); 683| 24|} _ZNK6Assimp7Blender9Structure7ConvertINS0_5MPolyEEEvRT_RKNS0_12FileDatabaseE: 689| 1.36k| const FileDatabase &db) const { 690| | 691| 1.36k| ReadField(dest.loopstart, "loopstart", db); 692| 1.36k| ReadField(dest.totloop, "totloop", db); 693| 1.36k| ReadField(dest.mat_nr, "mat_nr", db); 694| 1.36k| ReadField(dest.flag, "flag", db); 695| | 696| 1.36k| db.reader->IncPtr(size); 697| 1.36k|} _ZNK6Assimp7Blender9Structure7ConvertINS0_5SceneEEEvRT_RKNS0_12FileDatabaseE: 703| 26| const FileDatabase &db) const { 704| | 705| 26| ReadField(dest.id, "id", db); 706| 26| ReadFieldPtr(dest.camera, "*camera", db); 707| 26| ReadFieldPtr(dest.world, "*world", db); 708| 26| ReadFieldPtr(dest.basact, "*basact", db); 709| 26| ReadFieldPtr(dest.master_collection, "*master_collection", db); 710| 26| ReadField(dest.base, "base", db); 711| | 712| 26| db.reader->IncPtr(size); 713| 26|} _ZNK6Assimp7Blender9Structure7ConvertINS0_3TexEEEvRT_RKNS0_12FileDatabaseE: 733| 24| const FileDatabase &db) const { 734| 24| short temp_short = 0; 735| 24| ReadField(temp_short, "imaflag", db); 736| 24| dest.imaflag = static_cast(temp_short); 737| 24| int temp = 0; 738| 24| ReadField(temp, "type", db); 739| 24| dest.type = static_cast(temp); 740| 24| ReadFieldPtr(dest.ima, "*ima", db); 741| | 742| 24| db.reader->IncPtr(size); 743| 24|} _ZNK6Assimp7Blender9Structure7ConvertINS0_6CameraEEEvRT_RKNS0_12FileDatabaseE: 749| 27| const FileDatabase &db) const { 750| | 751| 27| ReadField(dest.id, "id", db); 752| 27| int temp = 0; 753| 27| ReadField(temp, "type", db); 754| 27| dest.type = static_cast(temp); 755| 27| ReadField(temp, "flag", db); 756| 27| dest.flag = static_cast(temp); 757| 27| ReadField(dest.lens, "lens", db); 758| 27| ReadField(dest.sensor_x, "sensor_x", db); 759| 27| ReadField(dest.clipsta, "clipsta", db); 760| 27| ReadField(dest.clipend, "clipend", db); 761| | 762| 27| db.reader->IncPtr(size); 763| 27|} _ZNK6Assimp7Blender9Structure7ConvertINS0_18MirrorModifierDataEEEvRT_RKNS0_12FileDatabaseE: 769| 2| const FileDatabase &db) const { 770| | 771| 2| ReadField(dest.modifier, "modifier", db); 772| 2| ReadField(dest.axis, "axis", db); 773| 2| ReadField(dest.flag, "flag", db); 774| 2| ReadField(dest.tolerance, "tolerance", db); 775| 2| std::shared_ptr mirror_ob; 776| 2| ReadFieldPtr(mirror_ob, "*mirror_ob", db); 777| 2| dest.mirror_ob = mirror_ob; 778| | 779| 2| db.reader->IncPtr(size); 780| 2|} _ZNK6Assimp7Blender9Structure7ConvertINS0_5ImageEEEvRT_RKNS0_12FileDatabaseE: 786| 8| const FileDatabase &db) const { 787| | 788| 8| ReadField(dest.id, "id", db); 789| 8| ReadFieldArray(dest.name, "name", db); 790| 8| ReadField(dest.ok, "ok", db); 791| 8| ReadField(dest.flag, "flag", db); 792| 8| ReadField(dest.source, "source", db); 793| 8| ReadField(dest.type, "type", db); 794| 8| ReadField(dest.pad, "pad", db); 795| 8| ReadField(dest.pad1, "pad1", db); 796| 8| ReadField(dest.lastframe, "lastframe", db); 797| 8| ReadField(dest.tpageflag, "tpageflag", db); 798| 8| ReadField(dest.totbind, "totbind", db); 799| 8| ReadField(dest.xrep, "xrep", db); 800| 8| ReadField(dest.yrep, "yrep", db); 801| 8| ReadField(dest.twsta, "twsta", db); 802| 8| ReadField(dest.twend, "twend", db); 803| 8| ReadFieldPtr(dest.packedfile, "*packedfile", db); 804| 8| ReadField(dest.lastupdate, "lastupdate", db); 805| 8| ReadField(dest.lastused, "lastused", db); 806| 8| ReadField(dest.animspeed, "animspeed", db); 807| 8| ReadField(dest.gen_x, "gen_x", db); 808| 8| ReadField(dest.gen_y, "gen_y", db); 809| 8| ReadField(dest.gen_type, "gen_type", db); 810| | 811| 8| db.reader->IncPtr(size); 812| 8|} _ZNK6Assimp7Blender9Structure7ConvertINS0_10CustomDataEEEvRT_RKNS0_12FileDatabaseE: 818| 148| const FileDatabase &db) const { 819| 148| ReadFieldArray(dest.typemap, "typemap", db); 820| 148| ReadField(dest.totlayer, "totlayer", db); 821| 148| ReadField(dest.maxlayer, "maxlayer", db); 822| 148| ReadField(dest.totsize, "totsize", db); 823| 148| ReadFieldPtrVector(dest.layers, "*layers", db); 824| | 825| 148| db.reader->IncPtr(size); 826| 148|} _ZNK6Assimp7Blender9Structure7ConvertINS0_15CustomDataLayerEEEvRT_RKNS0_12FileDatabaseE: 832| 595| const FileDatabase &db) const { 833| 595| ReadField(dest.type, "type", db); 834| 595| ReadField(dest.offset, "offset", db); 835| 595| ReadField(dest.flag, "flag", db); 836| 595| ReadField(dest.active, "active", db); 837| 595| ReadField(dest.active_rnd, "active_rnd", db); 838| 595| ReadField(dest.active_clone, "active_clone", db); 839| 595| ReadField(dest.active_mask, "active_mask", db); 840| 595| ReadField(dest.uid, "uid", db); 841| 595| ReadFieldArray(dest.name, "name", db); 842| 595| ReadCustomDataPtr(dest.data, dest.type, "*data", db); 843| | 844| 595| db.reader->IncPtr(size); 845| 595|} _ZN6Assimp7Blender3DNA18RegisterConvertersEv: 848| 26|void DNA::RegisterConverters() { 849| | 850| 26| converters["Object"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 851| 26| converters["Group"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 852| 26| converters["MTex"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 853| 26| converters["TFace"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 854| 26| converters["SubsurfModifierData"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 855| 26| converters["MFace"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 856| 26| converters["Lamp"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 857| 26| converters["MDeformWeight"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 858| 26| converters["PackedFile"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 859| 26| converters["Base"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 860| 26| converters["MTFace"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 861| 26| converters["Material"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 862| 26| converters["MTexPoly"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 863| 26| converters["Mesh"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 864| 26| converters["MDeformVert"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 865| 26| converters["World"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 866| 26| converters["MLoopCol"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 867| 26| converters["MVert"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 868| 26| converters["MEdge"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 869| 26| converters["MLoopUV"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 870| 26| converters["GroupObject"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 871| 26| converters["ListBase"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 872| 26| converters["MLoop"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 873| 26| converters["ModifierData"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 874| 26| converters["ID"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 875| 26| converters["MCol"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 876| 26| converters["MPoly"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 877| 26| converters["Scene"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 878| 26| converters["Library"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 879| 26| converters["Tex"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 880| 26| converters["Camera"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 881| 26| converters["MirrorModifierData"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 882| 26| converters["Image"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 883| 26| converters["CustomData"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 884| 26| converters["CustomDataLayer"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 885| 26| converters["Collection"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 886| 26| converters["CollectionChild"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 887| 26| converters["CollectionObject"] = DNA::FactoryPair(&Structure::Allocate, &Structure::Convert); 888| 26|} _ZN6Assimp7Blender5SceneC2Ev: 756| 26| Scene() = default; _ZN6Assimp7Blender5MVertC2Ev: 183| 27.0k| flag(0), mat_nr(0), bweight(0) {} _ZN6Assimp7Blender6MTFaceC2Ev: 250| 42| flag(0), 251| 42| mode(0), 252| 42| tile(0), 253| 42| unwrap(0) { 254| 42| } _ZN6Assimp7Blender15CustomDataLayerC2Ev: 418| 595| type(0), 419| 595| offset(0), 420| 595| flag(0), 421| 595| active(0), 422| 595| active_rnd(0), 423| 595| active_clone(0), 424| 595| active_mask(0), 425| 595| uid(0), 426| 595| data(nullptr) { 427| 595| memset(name, 0, sizeof name); 428| 595| } _ZN6Assimp7Blender6ObjectC2Ev: 728| 100| type(Type_EMPTY), parent(nullptr) { 729| | // empty 730| 100| } _ZN6Assimp7Blender4BaseC2Ev: 740| 96| prev(nullptr) { 741| | // empty 742| 96| } _ZN6Assimp7Blender3TexC2Ev: 875| 24| Tex() : imaflag(ImageFlags_INTERPOL), type(Type_CLOUDS) { 876| | // empty 877| 24| } _ZN6Assimp7Blender4MTexC2Ev: 967| 28| MTex() = default; _ZN6Assimp7Blender5ImageC2Ev: 786| 8| Image() = default; _ZNK6Assimp11COBImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 95| 99|bool COBImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 96| 99| static const char *tokens[] = { "Caligary" }; 97| | return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); 98| 99|} _ZNK6Assimp11COBImporter7GetInfoEv: 102| 634|const aiImporterDesc *COBImporter::GetInfo() const { 103| 634| return &desc; 104| 634|} _ZN6Assimp11COBImporterC2Ev: 77| 624| COBImporter() = default; _ZN6Assimp11CSMImporterC2Ev: 76| 624|CSMImporter::CSMImporter() : noSkeletonMesh() { 77| | // empty 78| 624|} _ZNK6Assimp11CSMImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 82| 287|bool CSMImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const { 83| 287| static const char* tokens[] = {"$Filename"}; 84| | return SearchFileHeaderForToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens)); 85| 287|} _ZNK6Assimp11CSMImporter7GetInfoEv: 89| 634|const aiImporterDesc* CSMImporter::GetInfo () const { 90| 634| return &desc; 91| 634|} _ZN6Assimp7Collada25MakeColladaAssimpMetaKeysEv: 51| 1|const MetaKeyPairVector MakeColladaAssimpMetaKeys() { 52| 1| MetaKeyPairVector result; 53| 1| result.emplace_back("authoring_tool", AI_METADATA_SOURCE_GENERATOR); 54| | result.emplace_back("copyright", AI_METADATA_SOURCE_COPYRIGHT); 55| 1| return result; 56| 1|} _ZN6Assimp7Collada34MakeColladaAssimpMetaKeysCamelCaseEv: 63| 1|const MetaKeyPairVector MakeColladaAssimpMetaKeysCamelCase() { 64| 1| MetaKeyPairVector result = MakeColladaAssimpMetaKeys(); 65| 2| for (auto &val : result) { ------------------ | Branch (65:20): [True: 2, False: 1] ------------------ 66| 2| ToCamelCase(val.first); 67| 2| } 68| 1| return result; 69| 1|} _ZN6Assimp7Collada33GetColladaAssimpMetaKeysCamelCaseEv: 71| 232|const MetaKeyPairVector &GetColladaAssimpMetaKeysCamelCase() { 72| 232| static const MetaKeyPairVector result = MakeColladaAssimpMetaKeysCamelCase(); 73| 232| return result; 74| 232|} _ZN6Assimp7Collada11ToCamelCaseERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 78| 234|void ToCamelCase(std::string &text) { 79| 234| if (text.empty()) ------------------ | Branch (79:9): [True: 0, False: 234] ------------------ 80| 0| return; 81| | // Capitalise first character 82| 234| auto it = text.begin(); 83| 234| (*it) = ai_toupper(*it); 84| 234| ++it; 85| 1.92k| for (/*started above*/; it != text.end(); /*iterated below*/) { ------------------ | Branch (85:29): [True: 1.69k, False: 234] ------------------ 86| 1.69k| if ((*it) == '_') { ------------------ | Branch (86:13): [True: 36, False: 1.65k] ------------------ 87| 36| it = text.erase(it); 88| 36| if (it != text.end()) ------------------ | Branch (88:17): [True: 36, False: 0] ------------------ 89| 36| (*it) = ai_toupper(*it); 90| 1.65k| } else { 91| | // Make lower case 92| 1.65k| (*it) = ai_tolower(*it); 93| 1.65k| ++it; 94| 1.65k| } 95| 1.69k| } 96| 234|} _ZN6Assimp7Collada6CameraC2Ev: 125| 10| mOrtho(false), 126| 10| mHorFov(10e10f), 127| 10| mVerFov(10e10f), 128| 10| mAspect(10e10f), 129| 10| mZNear(0.1f), 130| 10| mZFar(1000.f) {} _ZN6Assimp7Collada5LightC2Ev: 156| 30| mType(aiLightSource_UNDEFINED), 157| 30| mAttConstant(1.f), 158| 30| mAttLinear(0.f), 159| 30| mAttQuadratic(0.f), 160| 30| mFalloffAngle(180.f), 161| 30| mFalloffExponent(0.f), 162| 30| mPenumbraAngle(ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET), ------------------ | | 151| 30|#define ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET 1e9f ------------------ 163| 30| mOuterAngle(ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET), ------------------ | | 151| 30|#define ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET 1e9f ------------------ 164| 30| mIntensity(1.f) {} _ZN6Assimp7Collada21InputSemanticMapEntryC2Ev: 193| 28| mSet(0), 194| 28| mType(IT_Invalid) {} _ZN6Assimp7Collada4NodeC2Ev: 274| 333| mParent(nullptr) { 275| | // empty 276| 333| } _ZN6Assimp7Collada4NodeD2Ev: 279| 196| ~Node() { 280| 376| for (std::vector::iterator it = mChildren.begin(); it != mChildren.end(); ++it) { ------------------ | Branch (280:68): [True: 180, False: 196] ------------------ 281| 180| delete *it; 282| 180| } 283| 196| } _ZN6Assimp7Collada8AccessorC2Ev: 305| 3.35k| Accessor() { 306| 3.35k| mCount = 0; 307| 3.35k| mSize = 0; 308| 3.35k| mOffset = 0; 309| 3.35k| mStride = 0; 310| 3.35k| mData = nullptr; 311| 3.35k| mSubOffset[0] = mSubOffset[1] = mSubOffset[2] = mSubOffset[3] = 0; 312| 3.35k| } _ZN6Assimp7Collada12InputChannelC2Ev: 328| 659| InputChannel() { 329| 659| mType = IT_Invalid; 330| 659| mIndex = 0; 331| 659| mOffset = 0; 332| 659| mResolved = nullptr; 333| 659| } _ZN6Assimp7Collada4MeshC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 345| 165| mId(id) { 346| 1.48k| for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) { ------------------ | Branch (346:34): [True: 1.32k, False: 165] ------------------ 347| 1.32k| mNumUVComponents[i] = 2; 348| 1.32k| } 349| 165| } _ZN6Assimp7Collada7SamplerC2Ev: 460| 504| mWrapU(true), 461| 504| mWrapV(true), 462| | mMirrorU(), 463| | mMirrorV(), 464| 504| mOp(aiTextureOp_Multiply), 465| 504| mUVId(UINT_MAX), 466| 504| mWeighting(1.f), 467| 504| mMixWithPrevious(1.f) {} _ZN6Assimp7Collada6EffectC2Ev: 537| 72| mShadeType(Shade_Phong), 538| 72| mEmissive(0, 0, 0, 1), 539| 72| mAmbient(0.1f, 0.1f, 0.1f, 1), 540| 72| mDiffuse(0.6f, 0.6f, 0.6f, 1), 541| 72| mSpecular(0.4f, 0.4f, 0.4f, 1), 542| 72| mTransparent(0, 0, 0, 1), 543| 72| mShininess(10.0f), 544| 72| mRefractIndex(1.f), 545| 72| mReflectivity(0.f), 546| 72| mTransparency(1.f), 547| 72| mHasTransparency(false), 548| 72| mRGBTransparency(false), 549| 72| mInvertTransparency(false), 550| 72| mDoubleSided(false), 551| 72| mWireframe(false), 552| 72| mFaceted(false) { 553| 72| } _ZN6Assimp7Collada9AnimationD2Ev: 597| 428| ~Animation() { 598| 633| for (std::vector::iterator it = mSubAnims.begin(); it != mSubAnims.end(); ++it) { ------------------ | Branch (598:73): [True: 205, False: 428] ------------------ 599| 205| delete *it; 600| 205| } 601| 428| } _ZN6Assimp7Collada9Animation30CombineSingleChannelAnimationsEv: 614| 16| void CombineSingleChannelAnimations() { 615| 16| CombineSingleChannelAnimationsRecursively(this); 616| 16| } _ZN6Assimp7Collada9Animation41CombineSingleChannelAnimationsRecursivelyEPS1_: 618| 220| void CombineSingleChannelAnimationsRecursively(Animation *pParent) { 619| 220| std::set childrenTargets; 620| 220| bool childrenAnimationsHaveDifferentChannels = true; 621| | 622| 424| for (std::vector::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();) { ------------------ | Branch (622:82): [True: 204, False: 220] ------------------ 623| 204| Animation *anim = *it; 624| | // Assign the first animation name to the parent if empty. 625| | // This prevents the animation name from being lost when animations are combined 626| 204| if (mName.empty()) { ------------------ | Branch (626:17): [True: 2, False: 202] ------------------ 627| 2| mName = anim->mName; 628| 2| } 629| 204| CombineSingleChannelAnimationsRecursively(anim); 630| | 631| 204| if (childrenAnimationsHaveDifferentChannels && anim->mChannels.size() == 1 && ------------------ | Branch (631:17): [True: 199, False: 5] | Branch (631:17): [True: 198, False: 6] | Branch (631:60): [True: 199, False: 0] ------------------ 632| 199| childrenTargets.find(anim->mChannels[0].mTarget) == childrenTargets.end()) { ------------------ | Branch (632:21): [True: 198, False: 1] ------------------ 633| 198| childrenTargets.insert(anim->mChannels[0].mTarget); 634| 198| } else { 635| 6| childrenAnimationsHaveDifferentChannels = false; 636| 6| } 637| | 638| 204| ++it; 639| 204| } 640| | 641| | // We only want to combine animations if they have different channels 642| 220| if (childrenAnimationsHaveDifferentChannels) { ------------------ | Branch (642:13): [True: 219, False: 1] ------------------ 643| 411| for (std::vector::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();) { ------------------ | Branch (643:86): [True: 192, False: 219] ------------------ 644| 192| Animation *anim = *it; 645| | 646| 192| pParent->mChannels.push_back(anim->mChannels[0]); 647| | 648| 192| it = pParent->mSubAnims.erase(it); 649| | 650| 192| delete anim; 651| 192| continue; 652| 192| } 653| 219| } 654| 220| } _ZN6Assimp7Collada12ChannelEntryC2Ev: 678| 24.8k| mValueData() {} _ZN6Assimp13ColladaLoaderC2Ev: 103| 624| noSkeletonMesh(false), 104| 624| removeEmptyBones(false), 105| 624| ignoreUpDirection(false), 106| 624| ignoreUnitSize(false), 107| 624| useColladaName(false), 108| 624| mNodeNameCounter(0) { 109| | // empty 110| 624|} _ZNK6Assimp13ColladaLoader7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 114| 320|bool ColladaLoader::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 115| | // Look for a DAE file inside, but don't extract it 116| 320| ZipArchiveIOSystem zip_archive(pIOHandler, pFile); 117| 320| if (zip_archive.isOpen()) { ------------------ | Branch (117:9): [True: 10, False: 310] ------------------ 118| 10| return !ColladaParser::ReadZaeManifest(zip_archive).empty(); 119| 10| } 120| | 121| 310| static const char *tokens[] = { "GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, 0) != 0; 128| 31| removeEmptyBones = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_REMOVE_EMPTY_BONES, true) != 0; 129| 31| ignoreUpDirection = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION, 0) != 0; 130| 31| ignoreUnitSize = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_IGNORE_UNIT_SIZE, 0) != 0; 131| | useColladaName = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_USE_COLLADA_NAMES, 0) != 0; 132| 31|} _ZNK6Assimp13ColladaLoader7GetInfoEv: 136| 665|const aiImporterDesc *ColladaLoader::GetInfo() const { 137| 665| return &desc; 138| 665|} _ZN6Assimp13ColladaLoader14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 142| 31|void ColladaLoader::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { 143| 31| mFileName = pFile; 144| | 145| | // clean all member arrays - just for safety, it should work even if we did not 146| 31| mMeshIndexByID.clear(); 147| 31| mMaterialIndexByName.clear(); 148| 31| mMeshes.clear(); 149| 31| mTargetMeshes.clear(); 150| 31| newMats.clear(); 151| 31| mLights.clear(); 152| 31| mCameras.clear(); 153| 31| mTextures.clear(); 154| 31| mAnims.clear(); 155| | 156| | // parse the input file 157| 31| ColladaParser parser(pIOHandler, pFile); 158| | 159| 31| if (!parser.mRootNode) { ------------------ | Branch (159:9): [True: 0, False: 31] ------------------ 160| 0| throw DeadlyImportError("Collada: File came out empty. Something is wrong here."); 161| 0| } 162| | 163| | // reserve some storage to avoid unnecessary reallocates 164| 31| newMats.reserve(parser.mMaterialLibrary.size() * 2u); 165| 31| mMeshes.reserve(parser.mMeshLibrary.size() * 2u); 166| | 167| 31| mCameras.reserve(parser.mCameraLibrary.size()); 168| 31| mLights.reserve(parser.mLightLibrary.size()); 169| | 170| | // create the materials first, for the meshes to find 171| 31| BuildMaterials(parser, pScene); 172| | 173| | // build the node hierarchy from it 174| 31| pScene->mRootNode = BuildHierarchy(parser, parser.mRootNode); 175| | 176| | // ... then fill the materials with the now adjusted settings 177| 31| FillMaterials(parser, pScene); 178| | 179| 31| if (!ignoreUnitSize) { ------------------ | Branch (179:9): [True: 16, False: 15] ------------------ 180| | // Apply unit-size scale calculation 181| 16| pScene->mRootNode->mTransformation *= aiMatrix4x4( 182| 16| parser.mUnitSize, 0, 0, 0, 183| 16| 0, parser.mUnitSize, 0, 0, 184| 16| 0, 0, parser.mUnitSize, 0, 185| 16| 0, 0, 0, 1); 186| 16| } 187| | 188| 31| if (!ignoreUpDirection) { ------------------ | Branch (188:9): [True: 16, False: 15] ------------------ 189| | // Convert to Y_UP, if different orientation 190| 16| if (parser.mUpDirection == ColladaParser::UP_X) { ------------------ | Branch (190:13): [True: 0, False: 16] ------------------ 191| 0| pScene->mRootNode->mTransformation *= aiMatrix4x4( 192| 0| 0, -1, 0, 0, 193| 0| 1, 0, 0, 0, 194| 0| 0, 0, 1, 0, 195| 0| 0, 0, 0, 1); 196| 16| } else if (parser.mUpDirection == ColladaParser::UP_Z) { ------------------ | Branch (196:20): [True: 6, False: 10] ------------------ 197| 6| pScene->mRootNode->mTransformation *= aiMatrix4x4( 198| 6| 1, 0, 0, 0, 199| 6| 0, 0, 1, 0, 200| 6| 0, -1, 0, 0, 201| 6| 0, 0, 0, 1); 202| 6| } 203| 16| } 204| | 205| | // Store scene metadata 206| 31| if (!parser.mAssetMetaData.empty()) { ------------------ | Branch (206:9): [True: 16, False: 15] ------------------ 207| 16| const size_t numMeta(parser.mAssetMetaData.size()); 208| 16| pScene->mMetaData = aiMetadata::Alloc(static_cast(numMeta)); 209| 16| size_t i = 0; 210| 136| for (auto it = parser.mAssetMetaData.cbegin(); it != parser.mAssetMetaData.cend(); ++it, ++i) { ------------------ | Branch (210:56): [True: 120, False: 16] ------------------ 211| 120| pScene->mMetaData->Set(static_cast(i), (*it).first, (*it).second); 212| 120| } 213| 16| } 214| | 215| 31| StoreSceneMeshes(pScene); 216| 31| StoreSceneMaterials(pScene); 217| 31| StoreSceneTextures(pScene); 218| 31| StoreSceneLights(pScene); 219| 31| StoreSceneCameras(pScene); 220| 31| StoreAnimations(pScene, parser); 221| | 222| | // If no meshes have been loaded, it's probably just an animated skeleton. 223| 31| if (0u == pScene->mNumMeshes) { ------------------ | Branch (223:9): [True: 1, False: 30] ------------------ 224| 1| if (!noSkeletonMesh) { ------------------ | Branch (224:13): [True: 1, False: 0] ------------------ 225| 1| SkeletonMeshBuilder hero(pScene); 226| 1| } 227| | pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; 228| 1| } 229| 31|} _ZN6Assimp13ColladaLoader14BuildHierarchyERKNS_13ColladaParserEPKNS_7Collada4NodeE: 233| 196|aiNode *ColladaLoader::BuildHierarchy(const ColladaParser &pParser, const Collada::Node *pNode) { 234| | // create a node for it 235| 196| auto *node = new aiNode(); 236| | 237| | // find a name for the new node. It's more complicated than you might think 238| 196| node->mName.Set(FindNameForNode(pNode)); 239| | // if we're not using the unique IDs, hold onto them for reference and export 240| 196| if (useColladaName) { ------------------ | Branch (240:9): [True: 0, False: 196] ------------------ 241| 0| if (!pNode->mID.empty()) { ------------------ | Branch (241:13): [True: 0, False: 0] ------------------ 242| 0| AddNodeMetaData(node, AI_METADATA_COLLADA_ID, aiString(pNode->mID)); 243| 0| } 244| 0| if (!pNode->mSID.empty()) { ------------------ | Branch (244:13): [True: 0, False: 0] ------------------ 245| 0| AddNodeMetaData(node, AI_METADATA_COLLADA_SID, aiString(pNode->mSID)); 246| 0| } 247| 0| } 248| | 249| | // calculate the transformation matrix for it 250| 196| node->mTransformation = pParser.CalculateResultTransform(pNode->mTransforms); 251| | 252| | // now resolve node instances 253| 196| std::vector instances; 254| 196| ResolveNodeInstances(pParser, pNode, instances); 255| | 256| | // add children. first the *real* ones 257| 196| node->mNumChildren = static_cast(pNode->mChildren.size() + instances.size()); 258| 196| if (node->mNumChildren != 0) { ------------------ | Branch (258:9): [True: 84, False: 112] ------------------ 259| 84| node->mChildren = new aiNode * [node->mNumChildren]; 260| 84| } 261| | 262| 376| for (size_t a = 0; a < pNode->mChildren.size(); ++a) { ------------------ | Branch (262:24): [True: 180, False: 196] ------------------ 263| 180| node->mChildren[a] = BuildHierarchy(pParser, pNode->mChildren[a]); 264| 180| node->mChildren[a]->mParent = node; 265| 180| } 266| | 267| | // ... and finally the resolved node instances 268| 196| for (size_t a = 0; a < instances.size(); ++a) { ------------------ | Branch (268:24): [True: 0, False: 196] ------------------ 269| 0| node->mChildren[pNode->mChildren.size() + a] = BuildHierarchy(pParser, instances[a]); 270| 0| node->mChildren[pNode->mChildren.size() + a]->mParent = node; 271| 0| } 272| | 273| 196| BuildMeshesForNode(pParser, pNode, node); 274| 196| BuildCamerasForNode(pParser, pNode, node); 275| 196| BuildLightsForNode(pParser, pNode, node); 276| | 277| 196| return node; 278| 196|} _ZNK6Assimp13ColladaLoader20ResolveNodeInstancesERKNS_13ColladaParserEPKNS_7Collada4NodeERNSt3__16vectorIS7_NS8_9allocatorIS7_EEEE: 283| 196| std::vector &resolved) const { 284| | // reserve enough storage 285| 196| resolved.reserve(pNode->mNodeInstances.size()); 286| | 287| | // ... and iterate through all nodes to be instanced as children of pNode 288| 196| for (const auto &[mNode] : pNode->mNodeInstances) { ------------------ | Branch (288:30): [True: 0, False: 196] ------------------ 289| | // find the corresponding node in the library 290| 0| const auto itt = pParser.mNodeLibrary.find(mNode); 291| 0| const Node *nd = itt == pParser.mNodeLibrary.end() ? nullptr : (*itt).second; ------------------ | Branch (291:26): [True: 0, False: 0] ------------------ 292| | 293| | // FIX for http://sourceforge.net/tracker/?func=detail&aid=3054873&group_id=226462&atid=1067632 294| | // need to check for both name and ID to catch all. To avoid breaking valid files, 295| | // the workaround is only enabled when the first attempt to resolve the node has failed. 296| 0| if (nullptr == nd) { ------------------ | Branch (296:13): [True: 0, False: 0] ------------------ 297| 0| nd = FindNode(pParser.mRootNode, mNode); 298| 0| } 299| 0| if (nullptr == nd) { ------------------ | Branch (299:13): [True: 0, False: 0] ------------------ 300| 0| ASSIMP_LOG_ERROR("Collada: Unable to resolve reference to instanced node ", mNode); 301| 0| } else { 302| | // attach this node to the list of children 303| 0| resolved.push_back(nd); 304| 0| } 305| 0| } 306| 196|} _ZN6Assimp13ColladaLoader18BuildLightsForNodeERKNS_13ColladaParserEPKNS_7Collada4NodeEP6aiNode: 325| 196|void ColladaLoader::BuildLightsForNode(const ColladaParser &pParser, const Node *pNode, aiNode *pTarget) { 326| 196| for (const LightInstance &lid : pNode->mLights) { ------------------ | Branch (326:35): [True: 15, False: 196] ------------------ 327| | // find the referred light 328| 15| auto srcLightIt = pParser.mLightLibrary.find(lid.mLight); 329| 15| if (srcLightIt == pParser.mLightLibrary.end()) { ------------------ | Branch (329:13): [True: 0, False: 15] ------------------ 330| 0| ASSIMP_LOG_WARN("Collada: Unable to find light for ID \"", lid.mLight, "\". Skipping."); 331| 0| continue; 332| 0| } 333| 15| const Collada::Light *srcLight = &srcLightIt->second; 334| | 335| | // now fill our ai data structure 336| 15| auto out = new aiLight(); 337| 15| out->mName = pTarget->mName; 338| 15| out->mType = (aiLightSourceType)srcLight->mType; 339| | 340| | // collada lights point in -Z by default, rest is specified in node transform 341| 15| out->mDirection = aiVector3D(0.f, 0.f, -1.f); 342| | 343| 15| out->mAttenuationConstant = srcLight->mAttConstant; 344| 15| out->mAttenuationLinear = srcLight->mAttLinear; 345| 15| out->mAttenuationQuadratic = srcLight->mAttQuadratic; 346| | 347| 15| out->mColorDiffuse = out->mColorSpecular = out->mColorAmbient = srcLight->mColor * srcLight->mIntensity; 348| 15| if (out->mType == aiLightSource_AMBIENT) { ------------------ | Branch (348:13): [True: 1, False: 14] ------------------ 349| 1| out->mColorDiffuse = out->mColorSpecular = aiColor3D(0, 0, 0); 350| 1| out->mColorAmbient = srcLight->mColor * srcLight->mIntensity; 351| 14| } else { 352| | // collada doesn't differentiate between these color types 353| 14| out->mColorDiffuse = out->mColorSpecular = srcLight->mColor * srcLight->mIntensity; 354| 14| out->mColorAmbient = aiColor3D(0, 0, 0); 355| 14| } 356| | 357| | // convert falloff angle and falloff exponent in our representation, if given 358| 15| if (out->mType == aiLightSource_SPOT) { ------------------ | Branch (358:13): [True: 1, False: 14] ------------------ 359| 1| out->mAngleInnerCone = AI_DEG_TO_RAD(srcLight->mFalloffAngle); 360| | 361| | // ... some extension magic. 362| 1| if (srcLight->mOuterAngle >= ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET * (1 - ai_epsilon)) { ------------------ | | 151| 1|#define ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET 1e9f ------------------ | Branch (362:17): [True: 1, False: 0] ------------------ 363| | // ... some deprecation magic. 364| 1| if (srcLight->mPenumbraAngle >= ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET * (1 - ai_epsilon)) { ------------------ | | 151| 1|#define ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET 1e9f ------------------ | Branch (364:21): [True: 1, False: 0] ------------------ 365| | // Need to rely on falloff_exponent. I don't know how to interpret it, so I need to guess .... 366| | // epsilon chosen to be 0.1 367| 1| float f = 1.0f; 368| 1| if ( 0.0f != srcLight->mFalloffExponent ) { ------------------ | Branch (368:26): [True: 1, False: 0] ------------------ 369| 1| f = 1.f / srcLight->mFalloffExponent; 370| 1| } 371| 1| out->mAngleOuterCone = std::acos(std::pow(0.1f, f)) + 372| 1| out->mAngleInnerCone; 373| 1| } else { 374| 0| out->mAngleOuterCone = out->mAngleInnerCone + AI_DEG_TO_RAD(srcLight->mPenumbraAngle); 375| 0| if (out->mAngleOuterCone < out->mAngleInnerCone) ------------------ | Branch (375:25): [True: 0, False: 0] ------------------ 376| 0| std::swap(out->mAngleInnerCone, out->mAngleOuterCone); 377| 0| } 378| 1| } else { 379| 0| out->mAngleOuterCone = AI_DEG_TO_RAD(srcLight->mOuterAngle); 380| 0| } 381| 1| } 382| | 383| | // add to light list 384| 15| mLights.push_back(out); 385| 15| } 386| 196|} _ZN6Assimp13ColladaLoader19BuildCamerasForNodeERKNS_13ColladaParserEPKNS_7Collada4NodeEP6aiNode: 390| 196|void ColladaLoader::BuildCamerasForNode(const ColladaParser &pParser, const Node *pNode, aiNode *pTarget) { 391| 196| for (const CameraInstance &cid : pNode->mCameras) { ------------------ | Branch (391:36): [True: 10, False: 196] ------------------ 392| | // find the referred light 393| 10| auto srcCameraIt = pParser.mCameraLibrary.find(cid.mCamera); 394| 10| if (srcCameraIt == pParser.mCameraLibrary.end()) { ------------------ | Branch (394:13): [True: 0, False: 10] ------------------ 395| 0| ASSIMP_LOG_WARN("Collada: Unable to find camera for ID \"", cid.mCamera, "\". Skipping."); 396| 0| continue; 397| 0| } 398| 10| const Collada::Camera *srcCamera = &srcCameraIt->second; 399| | 400| | // orthographic cameras not yet supported in Assimp 401| 10| if (srcCamera->mOrtho) { ------------------ | Branch (401:13): [True: 0, False: 10] ------------------ 402| 0| ASSIMP_LOG_WARN("Collada: Orthographic cameras are not supported."); 403| 0| } 404| | 405| | // now fill our ai data structure 406| 10| auto *out = new aiCamera(); 407| 10| out->mName = pTarget->mName; 408| | 409| | // collada cameras point in -Z by default, rest is specified in node transform 410| 10| out->mLookAt = aiVector3D(0.f, 0.f, -1.f); 411| | 412| | // near/far z is already ok 413| 10| out->mClipPlaneFar = srcCamera->mZFar; 414| 10| out->mClipPlaneNear = srcCamera->mZNear; 415| | 416| | // ... but for the rest some values are optional 417| | // and we need to compute the others in any combination. 418| 10| if (srcCamera->mAspect != 10e10f) { ------------------ | Branch (418:13): [True: 10, False: 0] ------------------ 419| 10| out->mAspect = srcCamera->mAspect; 420| 10| } 421| | 422| 10| if (srcCamera->mHorFov != 10e10f) { ------------------ | Branch (422:13): [True: 0, False: 10] ------------------ 423| 0| out->mHorizontalFOV = srcCamera->mHorFov; 424| | 425| 0| if (srcCamera->mVerFov != 10e10f && srcCamera->mAspect == 10e10f) { ------------------ | Branch (425:17): [True: 0, False: 0] | Branch (425:49): [True: 0, False: 0] ------------------ 426| 0| out->mAspect = std::tan(AI_DEG_TO_RAD(srcCamera->mHorFov)) / 427| 0| std::tan(AI_DEG_TO_RAD(srcCamera->mVerFov)); 428| 0| } 429| | 430| 10| } else if (srcCamera->mAspect != 10e10f && srcCamera->mVerFov != 10e10f) { ------------------ | Branch (430:20): [True: 10, False: 0] | Branch (430:52): [True: 10, False: 0] ------------------ 431| 10| out->mHorizontalFOV = 2.0f * AI_RAD_TO_DEG(std::atan(srcCamera->mAspect * 432| 10| std::tan(AI_DEG_TO_RAD(srcCamera->mVerFov) * 0.5f))); 433| 10| } 434| | 435| | // Collada uses degrees, we use radians 436| 10| out->mHorizontalFOV = AI_DEG_TO_RAD(out->mHorizontalFOV); 437| | 438| | // add to camera list 439| 10| mCameras.push_back(out); 440| 10| } 441| 196|} _ZN6Assimp13ColladaLoader18BuildMeshesForNodeERKNS_13ColladaParserEPKNS_7Collada4NodeEP6aiNode: 445| 196|void ColladaLoader::BuildMeshesForNode(const ColladaParser &pParser, const Node *pNode, aiNode *pTarget) { 446| | // accumulated mesh references by this node 447| 196| std::vector newMeshRefs; 448| 196| newMeshRefs.reserve(pNode->mMeshes.size()); 449| | 450| | // add a mesh for each subgroup in each collada mesh 451| 196| for (const MeshInstance &mid : pNode->mMeshes) { ------------------ | Branch (451:34): [True: 85, False: 196] ------------------ 452| 85| const Mesh *srcMesh = nullptr; 453| 85| const Controller *srcController = nullptr; 454| | 455| | // find the referred mesh 456| 85| auto srcMeshIt = pParser.mMeshLibrary.find(mid.mMeshOrController); 457| 85| if (srcMeshIt == pParser.mMeshLibrary.end()) { ------------------ | Branch (457:13): [True: 1, False: 84] ------------------ 458| | // if not found in the mesh-library, it might also be a controller referring to a mesh 459| 1| auto srcContrIt = pParser.mControllerLibrary.find(mid.mMeshOrController); 460| 1| if (srcContrIt != pParser.mControllerLibrary.end()) { ------------------ | Branch (460:17): [True: 1, False: 0] ------------------ 461| 1| srcController = &srcContrIt->second; 462| 1| srcMeshIt = pParser.mMeshLibrary.find(srcController->mMeshId); 463| 1| if (srcMeshIt != pParser.mMeshLibrary.end()) { ------------------ | Branch (463:21): [True: 1, False: 0] ------------------ 464| 1| srcMesh = srcMeshIt->second; 465| 1| } 466| 1| } 467| | 468| 1| if (nullptr == srcMesh) { ------------------ | Branch (468:17): [True: 0, False: 1] ------------------ 469| 0| ASSIMP_LOG_WARN("Collada: Unable to find geometry for ID \"", mid.mMeshOrController, "\". Skipping."); 470| 0| continue; 471| 0| } 472| 84| } else { 473| | // ID found in the mesh library -> direct reference to a not skinned mesh 474| 84| srcMesh = srcMeshIt->second; 475| 84| } 476| | 477| | // build a mesh for each of its subgroups 478| 85| size_t vertexStart = 0, faceStart = 0; 479| 175| for (size_t sm = 0; sm < srcMesh->mSubMeshes.size(); ++sm) { ------------------ | Branch (479:29): [True: 90, False: 85] ------------------ 480| 90| const Collada::SubMesh &submesh = srcMesh->mSubMeshes[sm]; 481| 90| if (submesh.mNumFaces == 0) { ------------------ | Branch (481:17): [True: 0, False: 90] ------------------ 482| 0| continue; 483| 0| } 484| | 485| | // find material assigned to this submesh 486| 90| std::string meshMaterial; 487| 90| auto meshMatIt = mid.mMaterials.find(submesh.mMaterial); 488| | 489| 90| const Collada::SemanticMappingTable *table = nullptr; 490| 90| if (meshMatIt != mid.mMaterials.end()) { ------------------ | Branch (490:17): [True: 25, False: 65] ------------------ 491| 25| table = &meshMatIt->second; 492| 25| meshMaterial = table->mMatName; 493| 65| } else { 494| 65| ASSIMP_LOG_WARN("Collada: No material specified for subgroup <", submesh.mMaterial, "> in geometry <", 495| 65| mid.mMeshOrController, ">."); 496| 65| if (!mid.mMaterials.empty()) { ------------------ | Branch (496:21): [True: 0, False: 65] ------------------ 497| 0| meshMaterial = mid.mMaterials.begin()->second.mMatName; 498| 0| } 499| 65| } 500| | 501| | // OK ... here the *real* fun starts ... we have the vertex-input-to-effect-semantic-table 502| | // given. The only mapping stuff which we do actually support is the UV channel. 503| 90| auto matIt = mMaterialIndexByName.find(meshMaterial); 504| 90| unsigned int matIdx = 0; 505| 90| if (matIt != mMaterialIndexByName.end()) { ------------------ | Branch (505:17): [True: 25, False: 65] ------------------ 506| 25| matIdx = static_cast(matIt->second); 507| 25| } 508| | 509| 90| if (table && !table->mMap.empty()) { ------------------ | Branch (509:17): [True: 25, False: 65] | Branch (509:26): [True: 13, False: 12] ------------------ 510| 13| std::pair &mat = newMats[matIdx]; 511| | 512| | // Iterate through all texture channels assigned to the effect and 513| | // check whether we have mapping information for it. 514| 13| ApplyVertexToEffectSemanticMapping(mat.first->mTexDiffuse, *table); 515| 13| ApplyVertexToEffectSemanticMapping(mat.first->mTexAmbient, *table); 516| 13| ApplyVertexToEffectSemanticMapping(mat.first->mTexSpecular, *table); 517| 13| ApplyVertexToEffectSemanticMapping(mat.first->mTexEmissive, *table); 518| 13| ApplyVertexToEffectSemanticMapping(mat.first->mTexTransparent, *table); 519| 13| ApplyVertexToEffectSemanticMapping(mat.first->mTexBump, *table); 520| 13| } 521| | 522| | // built lookup index of the Mesh-Submesh-Material combination 523| 90| ColladaMeshIndex index(mid.mMeshOrController, sm, meshMaterial); 524| | 525| | // if we already have the mesh at the library, just add its index to the node's array 526| 90| auto dstMeshIt = mMeshIndexByID.find(index); 527| 90| if (dstMeshIt != mMeshIndexByID.end()) { ------------------ | Branch (527:17): [True: 0, False: 90] ------------------ 528| 0| newMeshRefs.push_back(dstMeshIt->second); 529| 90| } else { 530| | // else we have to add the mesh to the collection and store its newly assigned index at the node 531| 90| aiMesh *dstMesh = CreateMesh(pParser, srcMesh, submesh, srcController, vertexStart, faceStart); 532| | 533| | // store the mesh, and store its new index in the node 534| 90| newMeshRefs.push_back(mMeshes.size()); 535| 90| mMeshIndexByID[index] = mMeshes.size(); 536| 90| mMeshes.push_back(dstMesh); 537| 90| vertexStart += dstMesh->mNumVertices; 538| 90| faceStart += submesh.mNumFaces; 539| | 540| | // assign the material index 541| 90| auto subMatIt = mMaterialIndexByName.find(submesh.mMaterial); 542| 90| if (subMatIt != mMaterialIndexByName.end()) { ------------------ | Branch (542:21): [True: 10, False: 80] ------------------ 543| 10| dstMesh->mMaterialIndex = static_cast(subMatIt->second); 544| 80| } else { 545| 80| dstMesh->mMaterialIndex = matIdx; 546| 80| } 547| 90| if (dstMesh->mName.length == 0) { ------------------ | Branch (547:21): [True: 0, False: 90] ------------------ 548| 0| dstMesh->mName = mid.mMeshOrController; 549| 0| } 550| 90| } 551| 90| } 552| 85| } 553| | 554| | // now place all mesh references we gathered in the target node 555| 196| pTarget->mNumMeshes = static_cast(newMeshRefs.size()); 556| 196| if (!newMeshRefs.empty()) { ------------------ | Branch (556:9): [True: 85, False: 111] ------------------ 557| 85| struct UIntTypeConverter { 558| 85| unsigned int operator()(const size_t &v) const { 559| 85| return static_cast(v); 560| 85| } 561| 85| }; 562| | 563| 85| pTarget->mMeshes = new unsigned int[pTarget->mNumMeshes]; 564| 85| std::transform(newMeshRefs.begin(), newMeshRefs.end(), pTarget->mMeshes, UIntTypeConverter()); 565| 85| } 566| 196|} _ZN6Assimp13ColladaLoader10CreateMeshERKNS_13ColladaParserEPKNS_7Collada4MeshERKNS4_7SubMeshEPKNS4_10ControllerEmm: 593| 90| const Controller *pSrcController, size_t pStartVertex, size_t pStartFace) { 594| 90| std::unique_ptr dstMesh(new aiMesh); 595| | 596| 90| if (useColladaName) { ------------------ | Branch (596:9): [True: 0, False: 90] ------------------ 597| 0| dstMesh->mName = pSrcMesh->mName; 598| 90| } else { 599| 90| dstMesh->mName = pSrcMesh->mId; 600| 90| } 601| | 602| 90| if (pSrcMesh->mPositions.empty()) { ------------------ | Branch (602:9): [True: 0, False: 90] ------------------ 603| 0| return dstMesh.release(); 604| 0| } 605| | 606| | // count the vertices addressed by its faces 607| 90| const size_t numVertices = std::accumulate(pSrcMesh->mFaceSize.begin() + pStartFace, 608| 90| pSrcMesh->mFaceSize.begin() + pStartFace + pSubMesh.mNumFaces, size_t(0)); 609| | 610| | // copy positions 611| 90| dstMesh->mNumVertices = static_cast(numVertices); 612| 90| dstMesh->mVertices = new aiVector3D[numVertices]; 613| 90| std::copy(pSrcMesh->mPositions.begin() + pStartVertex, pSrcMesh->mPositions.begin() + pStartVertex + numVertices, dstMesh->mVertices); 614| | 615| | // normals, if given. HACK: (thom) Due to the glorious Collada spec we never 616| | // know if we have the same number of normals as there are positions. So we 617| | // also ignore any vertex attribute if it has a different count 618| 90| if (pSrcMesh->mNormals.size() >= pStartVertex + numVertices) { ------------------ | Branch (618:9): [True: 90, False: 0] ------------------ 619| 90| dstMesh->mNormals = new aiVector3D[numVertices]; 620| 90| std::copy(pSrcMesh->mNormals.begin() + pStartVertex, pSrcMesh->mNormals.begin() + pStartVertex + numVertices, dstMesh->mNormals); 621| 90| } 622| | 623| | // tangents, if given. 624| 90| if (pSrcMesh->mTangents.size() >= pStartVertex + numVertices) { ------------------ | Branch (624:9): [True: 0, False: 90] ------------------ 625| 0| dstMesh->mTangents = new aiVector3D[numVertices]; 626| 0| std::copy(pSrcMesh->mTangents.begin() + pStartVertex, pSrcMesh->mTangents.begin() + pStartVertex + numVertices, dstMesh->mTangents); 627| 0| } 628| | 629| | // bi-tangents, if given. 630| 90| if (pSrcMesh->mBitangents.size() >= pStartVertex + numVertices) { ------------------ | Branch (630:9): [True: 0, False: 90] ------------------ 631| 0| dstMesh->mBitangents = new aiVector3D[numVertices]; 632| 0| std::copy(pSrcMesh->mBitangents.begin() + pStartVertex, pSrcMesh->mBitangents.begin() + pStartVertex + numVertices, dstMesh->mBitangents); 633| 0| } 634| | 635| | // same for texture coords, as many as we have 636| 810| for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) { ------------------ | Branch (636:24): [True: 720, False: 90] ------------------ 637| 720| if (pSrcMesh->mTexCoords[a].size() >= pStartVertex + numVertices) { ------------------ | Branch (637:13): [True: 84, False: 636] ------------------ 638| 84| dstMesh->mTextureCoords[a] = new aiVector3D[numVertices]; 639| 59.8k| for (size_t b = 0; b < numVertices; ++b) { ------------------ | Branch (639:32): [True: 59.7k, False: 84] ------------------ 640| 59.7k| dstMesh->mTextureCoords[a][b] = pSrcMesh->mTexCoords[a][pStartVertex + b]; 641| 59.7k| } 642| | 643| 84| dstMesh->mNumUVComponents[a] = pSrcMesh->mNumUVComponents[a]; 644| 84| } 645| 720| } 646| | 647| | // same for vertex colors, as many as we have. again the same packing to avoid empty slots 648| 810| for (size_t a = 0, real = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) { ------------------ | Branch (648:34): [True: 720, False: 90] ------------------ 649| 720| if (pSrcMesh->mColors[a].size() >= pStartVertex + numVertices) { ------------------ | Branch (649:13): [True: 1, False: 719] ------------------ 650| 1| dstMesh->mColors[real] = new aiColor4D[numVertices]; 651| 1| std::copy(pSrcMesh->mColors[a].begin() + pStartVertex, pSrcMesh->mColors[a].begin() + pStartVertex + numVertices, dstMesh->mColors[real]); 652| 1| ++real; 653| 1| } 654| 720| } 655| | 656| | // create faces. Due to the fact that each face uses unique vertices, we can simply count up on each vertex 657| 90| size_t vertex = 0; 658| 90| dstMesh->mNumFaces = static_cast(pSubMesh.mNumFaces); 659| 90| dstMesh->mFaces = new aiFace[dstMesh->mNumFaces]; 660| 32.1k| for (size_t a = 0; a < dstMesh->mNumFaces; ++a) { ------------------ | Branch (660:24): [True: 32.0k, False: 90] ------------------ 661| 32.0k| size_t s = pSrcMesh->mFaceSize[pStartFace + a]; 662| 32.0k| aiFace &face = dstMesh->mFaces[a]; 663| 32.0k| face.mNumIndices = static_cast(s); 664| 32.0k| face.mIndices = new unsigned int[s]; 665| 135k| for (size_t b = 0; b < s; ++b) { ------------------ | Branch (665:28): [True: 103k, False: 32.0k] ------------------ 666| 103k| face.mIndices[b] = static_cast(vertex++); 667| 103k| } 668| 32.0k| } 669| | 670| | // create morph target meshes if any 671| 90| std::vector targetMeshes; 672| 90| std::vector targetWeights; 673| 90| Collada::MorphMethod method = Normalized; 674| | 675| 90| for (auto it = pParser.mControllerLibrary.begin(); 676| 91| it != pParser.mControllerLibrary.end(); ++it) { ------------------ | Branch (676:13): [True: 1, False: 90] ------------------ 677| 1| const Controller &c = it->second; 678| 1| const Collada::Mesh *baseMesh = pParser.ResolveLibraryReference(pParser.mMeshLibrary, c.mMeshId); 679| | 680| 1| if (c.mType == Collada::Morph && baseMesh->mName == pSrcMesh->mName) { ------------------ | Branch (680:13): [True: 0, False: 1] | Branch (680:42): [True: 0, False: 0] ------------------ 681| 0| const Collada::Accessor &targetAccessor = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, c.mMorphTarget); 682| 0| const Collada::Accessor &weightAccessor = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, c.mMorphWeight); 683| 0| const Collada::Data &targetData = pParser.ResolveLibraryReference(pParser.mDataLibrary, targetAccessor.mSource); 684| 0| const Collada::Data &weightData = pParser.ResolveLibraryReference(pParser.mDataLibrary, weightAccessor.mSource); 685| | 686| | // take method 687| 0| method = c.mMethod; 688| | 689| 0| if (!targetData.mIsStringArray) { ------------------ | Branch (689:17): [True: 0, False: 0] ------------------ 690| 0| throw DeadlyImportError("target data must contain id. "); 691| 0| } 692| 0| if (weightData.mIsStringArray) { ------------------ | Branch (692:17): [True: 0, False: 0] ------------------ 693| 0| throw DeadlyImportError("target weight data must not be textual "); 694| 0| } 695| | 696| 0| for (const auto & mString : targetData.mStrings) { ------------------ | Branch (696:39): [True: 0, False: 0] ------------------ 697| 0| const Mesh *targetMesh = pParser.ResolveLibraryReference(pParser.mMeshLibrary, mString); 698| | 699| 0| aiMesh *aimesh = findMesh(useColladaName ? targetMesh->mName : targetMesh->mId); ------------------ | Branch (699:43): [True: 0, False: 0] ------------------ 700| 0| if (!aimesh) { ------------------ | Branch (700:21): [True: 0, False: 0] ------------------ 701| 0| if (targetMesh->mSubMeshes.size() > 1) { ------------------ | Branch (701:25): [True: 0, False: 0] ------------------ 702| 0| throw DeadlyImportError("Morphing target mesh must be a single"); 703| 0| } 704| 0| aimesh = CreateMesh(pParser, targetMesh, targetMesh->mSubMeshes.at(0), nullptr, 0, 0); 705| 0| mTargetMeshes.push_back(aimesh); 706| 0| } 707| 0| targetMeshes.push_back(aimesh); 708| 0| } 709| 0| for (float mValue : weightData.mValues) { ------------------ | Branch (709:31): [True: 0, False: 0] ------------------ 710| 0| targetWeights.push_back(mValue); 711| 0| } 712| 0| } 713| 1| } 714| 90| if (!targetMeshes.empty() && targetWeights.size() == targetMeshes.size()) { ------------------ | Branch (714:9): [True: 0, False: 90] | Branch (714:34): [True: 0, False: 0] ------------------ 715| 0| std::vector animMeshes; 716| 0| for (unsigned int i = 0; i < targetMeshes.size(); ++i) { ------------------ | Branch (716:34): [True: 0, False: 0] ------------------ 717| 0| aiMesh *targetMesh = targetMeshes.at(i); 718| 0| aiAnimMesh *animMesh = aiCreateAnimMesh(targetMesh); 719| 0| float weight = targetWeights[i]; 720| 0| animMesh->mWeight = weight == 0 ? 1.0f : weight; ------------------ | Branch (720:33): [True: 0, False: 0] ------------------ 721| 0| animMesh->mName = targetMesh->mName; 722| 0| animMeshes.push_back(animMesh); 723| 0| } 724| 0| dstMesh->mMethod = (method == Relative) ? aiMorphingMethod_MORPH_RELATIVE : aiMorphingMethod_MORPH_NORMALIZED; ------------------ | Branch (724:28): [True: 0, False: 0] ------------------ 725| 0| dstMesh->mAnimMeshes = new aiAnimMesh *[animMeshes.size()]; 726| 0| dstMesh->mNumAnimMeshes = static_cast(animMeshes.size()); 727| 0| for (unsigned int i = 0; i < animMeshes.size(); ++i) { ------------------ | Branch (727:34): [True: 0, False: 0] ------------------ 728| 0| dstMesh->mAnimMeshes[i] = animMeshes.at(i); 729| 0| } 730| 0| } 731| | 732| | // create bones if given 733| 90| if (pSrcController && pSrcController->mType == Collada::Skin) { ------------------ | Branch (733:9): [True: 1, False: 89] | Branch (733:27): [True: 1, False: 0] ------------------ 734| | // resolve references - joint names 735| 1| const Collada::Accessor &jointNamesAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mJointNameSource); 736| 1| const Collada::Data &jointNames = pParser.ResolveLibraryReference(pParser.mDataLibrary, jointNamesAcc.mSource); 737| | // joint offset matrices 738| 1| const Collada::Accessor &jointMatrixAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mJointOffsetMatrixSource); 739| 1| const Collada::Data &jointMatrices = pParser.ResolveLibraryReference(pParser.mDataLibrary, jointMatrixAcc.mSource); 740| | // joint vertex_weight name list - should refer to the same list as the joint names above. If not, report and reconsider 741| 1| const Collada::Accessor &weightNamesAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mWeightInputJoints.mAccessor); 742| 1| if (&weightNamesAcc != &jointNamesAcc) ------------------ | Branch (742:13): [True: 0, False: 1] ------------------ 743| 0| throw DeadlyImportError("Temporary implementational laziness. If you read this, please report to the author."); 744| | // vertex weights 745| 1| const Collada::Accessor &weightsAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mWeightInputWeights.mAccessor); 746| 1| const Collada::Data &weights = pParser.ResolveLibraryReference(pParser.mDataLibrary, weightsAcc.mSource); 747| | 748| 1| if (!jointNames.mIsStringArray || jointMatrices.mIsStringArray || weights.mIsStringArray) { ------------------ | Branch (748:13): [True: 0, False: 1] | Branch (748:43): [True: 0, False: 1] | Branch (748:75): [True: 0, False: 1] ------------------ 749| 0| throw DeadlyImportError("Data type mismatch while resolving mesh joints"); 750| 0| } 751| | // sanity check: we rely on the vertex weights always coming as pairs of BoneIndex-WeightIndex 752| 1| if (pSrcController->mWeightInputJoints.mOffset != 0 || pSrcController->mWeightInputWeights.mOffset != 1) { ------------------ | Branch (752:13): [True: 0, False: 1] | Branch (752:64): [True: 0, False: 1] ------------------ 753| 0| throw DeadlyImportError("Unsupported vertex_weight addressing scheme. "); 754| 0| } 755| | 756| | // create containers to collect the weights for each bone 757| 1| size_t numBones = jointNames.mStrings.size(); 758| 1| std::vector> dstBones(numBones); 759| | 760| | // build a temporary array of pointers to the start of each vertex's weights 761| 1| using IndexPairVector = std::vector>; 762| 1| std::vector weightStartPerVertex; 763| 1| weightStartPerVertex.resize(pSrcController->mWeightCounts.size(), pSrcController->mWeights.end()); 764| | 765| 1| auto pit = pSrcController->mWeights.begin(); 766| 73| for (size_t a = 0; a < pSrcController->mWeightCounts.size(); ++a) { ------------------ | Branch (766:28): [True: 72, False: 1] ------------------ 767| 72| weightStartPerVertex[a] = pit; 768| 72| pit += pSrcController->mWeightCounts[a]; 769| 72| } 770| | 771| | // now for each vertex put the corresponding vertex weights into each bone's weight collection 772| 105| for (size_t a = pStartVertex; a < pStartVertex + numVertices; ++a) { ------------------ | Branch (772:39): [True: 104, False: 1] ------------------ 773| | // which position index was responsible for this vertex? that's also the index by which 774| | // the controller assigns the vertex weights 775| 104| size_t orgIndex = pSrcMesh->mFacePosIndices[a]; 776| | // find the vertex weights for this vertex 777| 104| auto iit = weightStartPerVertex[orgIndex]; 778| 104| size_t pairCount = pSrcController->mWeightCounts[orgIndex]; 779| | 780| 265| for (size_t b = 0; b < pairCount; ++b, ++iit) { ------------------ | Branch (780:32): [True: 161, False: 104] ------------------ 781| 161| const size_t jointIndex = iit->first; 782| 161| const size_t vertexIndex = iit->second; 783| 161| ai_real weight = 1.0f; 784| 161| if (!weights.mValues.empty()) { ------------------ | Branch (784:21): [True: 161, False: 0] ------------------ 785| 161| weight = ReadFloat(weightsAcc, weights, vertexIndex, 0); 786| 161| } 787| | 788| | // one day I gonna kill that XSI Collada exporter 789| 161| if (weight > 0.0f) { ------------------ | Branch (789:21): [True: 161, False: 0] ------------------ 790| 161| aiVertexWeight w; 791| 161| w.mVertexId = static_cast(a - pStartVertex); 792| 161| w.mWeight = weight; 793| 161| dstBones[jointIndex].push_back(w); 794| 161| } 795| 161| } 796| 104| } 797| | 798| | // count the number of bones which influence vertices of the current submesh 799| 1| size_t numRemainingBones = 0; 800| 5| for (const auto & dstBone : dstBones) { ------------------ | Branch (800:35): [True: 5, False: 1] ------------------ 801| 5| if (dstBone.empty() && removeEmptyBones) { ------------------ | Branch (801:17): [True: 1, False: 4] | Branch (801:36): [True: 1, False: 0] ------------------ 802| 1| continue; 803| 1| } 804| 4| ++numRemainingBones; 805| 4| } 806| | 807| | // create bone array and copy bone weights one by one 808| 1| dstMesh->mNumBones = static_cast(numRemainingBones); 809| 1| dstMesh->mBones = new aiBone *[numRemainingBones]; 810| 1| size_t boneCount = 0; 811| 6| for (size_t a = 0; a < numBones; ++a) { ------------------ | Branch (811:28): [True: 5, False: 1] ------------------ 812| | // omit bones without weights 813| 5| if (dstBones[a].empty() && removeEmptyBones) { ------------------ | Branch (813:17): [True: 1, False: 4] | Branch (813:40): [True: 1, False: 0] ------------------ 814| 1| continue; 815| 1| } 816| | 817| | // create bone with its weights 818| 4| auto bone = new aiBone; 819| 4| bone->mName = ReadString(jointNamesAcc, jointNames, a); 820| 4| bone->mOffsetMatrix.a1 = ReadFloat(jointMatrixAcc, jointMatrices, a, 0); 821| 4| bone->mOffsetMatrix.a2 = ReadFloat(jointMatrixAcc, jointMatrices, a, 1); 822| 4| bone->mOffsetMatrix.a3 = ReadFloat(jointMatrixAcc, jointMatrices, a, 2); 823| 4| bone->mOffsetMatrix.a4 = ReadFloat(jointMatrixAcc, jointMatrices, a, 3); 824| 4| bone->mOffsetMatrix.b1 = ReadFloat(jointMatrixAcc, jointMatrices, a, 4); 825| 4| bone->mOffsetMatrix.b2 = ReadFloat(jointMatrixAcc, jointMatrices, a, 5); 826| 4| bone->mOffsetMatrix.b3 = ReadFloat(jointMatrixAcc, jointMatrices, a, 6); 827| 4| bone->mOffsetMatrix.b4 = ReadFloat(jointMatrixAcc, jointMatrices, a, 7); 828| 4| bone->mOffsetMatrix.c1 = ReadFloat(jointMatrixAcc, jointMatrices, a, 8); 829| 4| bone->mOffsetMatrix.c2 = ReadFloat(jointMatrixAcc, jointMatrices, a, 9); 830| 4| bone->mOffsetMatrix.c3 = ReadFloat(jointMatrixAcc, jointMatrices, a, 10); 831| 4| bone->mOffsetMatrix.c4 = ReadFloat(jointMatrixAcc, jointMatrices, a, 11); 832| 4| bone->mNumWeights = static_cast(dstBones[a].size()); 833| 4| bone->mWeights = new aiVertexWeight[bone->mNumWeights]; 834| 4| std::copy(dstBones[a].begin(), dstBones[a].end(), bone->mWeights); 835| | 836| | // apply bind shape matrix to offset matrix 837| 4| aiMatrix4x4 bindShapeMatrix; 838| 4| bindShapeMatrix.a1 = pSrcController->mBindShapeMatrix[0]; 839| 4| bindShapeMatrix.a2 = pSrcController->mBindShapeMatrix[1]; 840| 4| bindShapeMatrix.a3 = pSrcController->mBindShapeMatrix[2]; 841| 4| bindShapeMatrix.a4 = pSrcController->mBindShapeMatrix[3]; 842| 4| bindShapeMatrix.b1 = pSrcController->mBindShapeMatrix[4]; 843| 4| bindShapeMatrix.b2 = pSrcController->mBindShapeMatrix[5]; 844| 4| bindShapeMatrix.b3 = pSrcController->mBindShapeMatrix[6]; 845| 4| bindShapeMatrix.b4 = pSrcController->mBindShapeMatrix[7]; 846| 4| bindShapeMatrix.c1 = pSrcController->mBindShapeMatrix[8]; 847| 4| bindShapeMatrix.c2 = pSrcController->mBindShapeMatrix[9]; 848| 4| bindShapeMatrix.c3 = pSrcController->mBindShapeMatrix[10]; 849| 4| bindShapeMatrix.c4 = pSrcController->mBindShapeMatrix[11]; 850| 4| bindShapeMatrix.d1 = pSrcController->mBindShapeMatrix[12]; 851| 4| bindShapeMatrix.d2 = pSrcController->mBindShapeMatrix[13]; 852| 4| bindShapeMatrix.d3 = pSrcController->mBindShapeMatrix[14]; 853| 4| bindShapeMatrix.d4 = pSrcController->mBindShapeMatrix[15]; 854| 4| bone->mOffsetMatrix *= bindShapeMatrix; 855| | 856| | // HACK: (thom) Some exporters address the bone nodes by SID, others address them by ID or even name. 857| | // Therefore I added a little name replacement here: I search for the bone's node by either name, ID or SID, 858| | // and replace the bone's name by the node's name so that the user can use the standard 859| | // find-by-name method to associate nodes with bones. 860| 4| const Collada::Node *bnode = FindNode(pParser.mRootNode, bone->mName.data); 861| 4| if (nullptr == bnode) { ------------------ | Branch (861:17): [True: 4, False: 0] ------------------ 862| 4| bnode = FindNodeBySID(pParser.mRootNode, bone->mName.data); 863| 4| } 864| | 865| | // assign the name that we would have assigned for the source node 866| 4| if (nullptr != bnode) { ------------------ | Branch (866:17): [True: 4, False: 0] ------------------ 867| 4| bone->mName.Set(FindNameForNode(bnode)); 868| 4| } else { 869| 0| ASSIMP_LOG_WARN("ColladaLoader::CreateMesh(): could not find corresponding node for joint \"", bone->mName.data, "\"."); 870| 0| } 871| | 872| | // and insert bone 873| 4| dstMesh->mBones[boneCount++] = bone; 874| 4| } 875| 1| } 876| | 877| 90| return dstMesh.release(); 878| 90|} _ZN6Assimp13ColladaLoader16StoreSceneMeshesEP7aiScene: 882| 16|void ColladaLoader::StoreSceneMeshes(aiScene *pScene) { 883| 16| pScene->mNumMeshes = static_cast(mMeshes.size()); 884| 16| if (mMeshes.empty()) { ------------------ | Branch (884:9): [True: 1, False: 15] ------------------ 885| 1| return; 886| 1| } 887| 15| pScene->mMeshes = new aiMesh *[mMeshes.size()]; 888| 15| std::copy(mMeshes.begin(), mMeshes.end(), pScene->mMeshes); 889| 15| mMeshes.clear(); 890| 15|} _ZN6Assimp13ColladaLoader17StoreSceneCamerasEP7aiScene: 894| 16|void ColladaLoader::StoreSceneCameras(aiScene *pScene) { 895| 16| pScene->mNumCameras = static_cast(mCameras.size()); 896| 16| if (mCameras.empty()) { ------------------ | Branch (896:9): [True: 9, False: 7] ------------------ 897| 9| return; 898| 9| } 899| 7| pScene->mCameras = new aiCamera *[mCameras.size()]; 900| 7| std::copy(mCameras.begin(), mCameras.end(), pScene->mCameras); 901| 7| mCameras.clear(); 902| 7|} _ZN6Assimp13ColladaLoader16StoreSceneLightsEP7aiScene: 906| 16|void ColladaLoader::StoreSceneLights(aiScene *pScene) { 907| 16| pScene->mNumLights = static_cast(mLights.size()); 908| 16| if (mLights.empty()) { ------------------ | Branch (908:9): [True: 8, False: 8] ------------------ 909| 8| return; 910| 8| } 911| 8| pScene->mLights = new aiLight *[mLights.size()]; 912| 8| std::copy(mLights.begin(), mLights.end(), pScene->mLights); 913| 8| mLights.clear(); 914| 8|} _ZN6Assimp13ColladaLoader18StoreSceneTexturesEP7aiScene: 918| 16|void ColladaLoader::StoreSceneTextures(aiScene *pScene) { 919| 16| pScene->mNumTextures = static_cast(mTextures.size()); 920| 16| if (mTextures.empty()) { ------------------ | Branch (920:9): [True: 14, False: 2] ------------------ 921| 14| return; 922| 14| } 923| 2| pScene->mTextures = new aiTexture *[mTextures.size()]; 924| 2| std::copy(mTextures.begin(), mTextures.end(), pScene->mTextures); 925| 2| mTextures.clear(); 926| 2|} _ZN6Assimp13ColladaLoader19StoreSceneMaterialsEP7aiScene: 930| 16|void ColladaLoader::StoreSceneMaterials(aiScene *pScene) { 931| 16| pScene->mNumMaterials = static_cast(newMats.size()); 932| 16| if (newMats.empty()) { ------------------ | Branch (932:9): [True: 2, False: 14] ------------------ 933| 2| return; 934| 2| } 935| 14| pScene->mMaterials = new aiMaterial *[newMats.size()]; 936| 38| for (unsigned int i = 0; i < newMats.size(); ++i) { ------------------ | Branch (936:30): [True: 24, False: 14] ------------------ 937| 24| pScene->mMaterials[i] = newMats[i].second; 938| 24| } 939| 14| newMats.clear(); 940| 14|} _ZN6Assimp13ColladaLoader15StoreAnimationsEP7aiSceneRKNS_13ColladaParserE: 944| 16|void ColladaLoader::StoreAnimations(aiScene *pScene, const ColladaParser &pParser) { 945| | // recursively collect all animations from the collada scene 946| 16| StoreAnimations(pScene, pParser, &pParser.mAnims, ""); 947| | 948| | // catch special case: many animations with the same length, each affecting only a single node. 949| | // we need to unite all those single-node-anims to a proper combined animation 950| 19| for (size_t a = 0; a < mAnims.size(); ++a) { ------------------ | Branch (950:24): [True: 3, False: 16] ------------------ 951| 3| aiAnimation *templateAnim = mAnims[a]; 952| | 953| 3| if (templateAnim->mNumChannels == 1) { ------------------ | Branch (953:13): [True: 2, False: 1] ------------------ 954| | // search for other single-channel-anims with the same duration 955| 2| std::vector collectedAnimIndices; 956| 18| for (size_t b = a + 1; b < mAnims.size(); ++b) { ------------------ | Branch (956:36): [True: 16, False: 2] ------------------ 957| 16| aiAnimation *other = mAnims[b]; 958| 16| if (other->mNumChannels == 1 && other->mDuration == templateAnim->mDuration && ------------------ | Branch (958:21): [True: 16, False: 0] | Branch (958:49): [True: 10, False: 6] ------------------ 959| 10| other->mTicksPerSecond == templateAnim->mTicksPerSecond) ------------------ | Branch (959:25): [True: 10, False: 0] ------------------ 960| 10| collectedAnimIndices.push_back(b); 961| 16| } 962| | 963| | // We only want to combine the animations if they have different channels 964| 2| std::set animTargets; 965| 2| animTargets.insert(templateAnim->mChannels[0]->mNodeName.C_Str()); 966| 2| bool collectedAnimationsHaveDifferentChannels = true; 967| 10| for (unsigned long long collectedAnimIndice : collectedAnimIndices) { ------------------ | Branch (967:57): [True: 10, False: 2] ------------------ 968| 10| aiAnimation *srcAnimation = mAnims[(int)collectedAnimIndice]; 969| 10| std::string channelName = std::string(srcAnimation->mChannels[0]->mNodeName.C_Str()); 970| 10| if (animTargets.find(channelName) == animTargets.end()) { ------------------ | Branch (970:21): [True: 10, False: 0] ------------------ 971| 10| animTargets.insert(channelName); 972| 10| } else { 973| 0| collectedAnimationsHaveDifferentChannels = false; 974| 0| break; 975| 0| } 976| 10| } 977| | 978| 2| if (!collectedAnimationsHaveDifferentChannels) { ------------------ | Branch (978:17): [True: 0, False: 2] ------------------ 979| 0| continue; 980| 0| } 981| | 982| | // if there are other animations which fit the template anim, combine all channels into a single anim 983| 2| if (!collectedAnimIndices.empty()) { ------------------ | Branch (983:17): [True: 2, False: 0] ------------------ 984| 2| auto *combinedAnim = new aiAnimation(); 985| 2| combinedAnim->mName = aiString(std::string("combinedAnim_") + char('0' + a)); 986| 2| combinedAnim->mDuration = templateAnim->mDuration; 987| 2| combinedAnim->mTicksPerSecond = templateAnim->mTicksPerSecond; 988| 2| combinedAnim->mNumChannels = static_cast(collectedAnimIndices.size() + 1); 989| 2| combinedAnim->mChannels = new aiNodeAnim *[combinedAnim->mNumChannels]; 990| | // add the template anim as first channel by moving its aiNodeAnim to the combined animation 991| 2| combinedAnim->mChannels[0] = templateAnim->mChannels[0]; 992| 2| templateAnim->mChannels[0] = nullptr; 993| 2| delete templateAnim; 994| | // combined animation replaces template animation in the anim array 995| 2| mAnims[a] = combinedAnim; 996| | 997| | // move the memory of all other anims to the combined anim and erase them from the source anims 998| 12| for (size_t b = 0; b < collectedAnimIndices.size(); ++b) { ------------------ | Branch (998:36): [True: 10, False: 2] ------------------ 999| 10| aiAnimation *srcAnimation = mAnims[collectedAnimIndices[b]]; 1000| 10| combinedAnim->mChannels[1 + b] = srcAnimation->mChannels[0]; 1001| 10| srcAnimation->mChannels[0] = nullptr; 1002| 10| delete srcAnimation; 1003| 10| } 1004| | 1005| | // in a second go, delete all the single-channel-anims that we've stripped from their channels 1006| | // back to front to preserve indices - you know, removing an element from a vector moves all elements behind the removed one 1007| 12| while (!collectedAnimIndices.empty()) { ------------------ | Branch (1007:24): [True: 10, False: 2] ------------------ 1008| 10| mAnims.erase(mAnims.begin() + collectedAnimIndices.back()); 1009| 10| collectedAnimIndices.pop_back(); 1010| 10| } 1011| 2| } 1012| 2| } 1013| 3| } 1014| | 1015| | // now store all anims in the scene 1016| 16| if (!mAnims.empty()) { ------------------ | Branch (1016:9): [True: 2, False: 14] ------------------ 1017| 2| pScene->mNumAnimations = static_cast(mAnims.size()); 1018| 2| pScene->mAnimations = new aiAnimation *[mAnims.size()]; 1019| 2| std::copy(mAnims.begin(), mAnims.end(), pScene->mAnimations); 1020| 2| } 1021| | 1022| 16| mAnims.clear(); 1023| 16|} _ZN6Assimp13ColladaLoader15StoreAnimationsEP7aiSceneRKNS_13ColladaParserEPKNS_7Collada9AnimationERKNSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEE: 1027| 28|void ColladaLoader::StoreAnimations(aiScene *pScene, const ColladaParser &pParser, const Animation *pSrcAnim, const std::string &pPrefix) { 1028| 28| std::string animName = pPrefix.empty() ? pSrcAnim->mName : pPrefix + "_" + pSrcAnim->mName; ------------------ | Branch (1028:28): [True: 16, False: 12] ------------------ 1029| | 1030| | // create nested animations, if given 1031| 28| for (auto mSubAnim : pSrcAnim->mSubAnims) { ------------------ | Branch (1031:24): [True: 12, False: 28] ------------------ 1032| 12| StoreAnimations(pScene, pParser, mSubAnim, animName); 1033| 12| } 1034| | 1035| | // create animation channels, if any 1036| 28| if (!pSrcAnim->mChannels.empty()) { ------------------ | Branch (1036:9): [True: 13, False: 15] ------------------ 1037| 13| CreateAnimation(pScene, pParser, pSrcAnim, animName); 1038| 13| } 1039| 28|} _ZN6Assimp13ColladaLoader15CreateAnimationEP7aiSceneRKNS_13ColladaParserEPKNS_7Collada9AnimationERKNSt3__112basic_stringIcNSA_11char_traitsIcEENSA_9allocatorIcEEEE: 1096| 13|void ColladaLoader::CreateAnimation(aiScene *pScene, const ColladaParser &pParser, const Animation *pSrcAnim, const std::string &pName) { 1097| | // collect a list of animatable nodes 1098| 13| std::vector nodes; 1099| 13| CollectNodes(pScene->mRootNode, nodes); 1100| | 1101| 13| std::vector anims; 1102| 13| std::vector morphAnims; 1103| | 1104| 225| for (auto node : nodes) { ------------------ | Branch (1104:20): [True: 225, False: 13] ------------------ 1105| | // find all the collada anim channels which refer to the current node 1106| 225| std::vector entries; 1107| 225| std::string nodeName = node->mName.data; 1108| | 1109| | // find the collada node corresponding to the aiNode 1110| 225| const Node *srcNode = FindNode(pParser.mRootNode, nodeName); 1111| 225| if (!srcNode) { ------------------ | Branch (1111:13): [True: 0, False: 225] ------------------ 1112| 0| continue; 1113| 0| } 1114| | 1115| | // now check all channels if they affect the current node 1116| 225| std::string targetID, subElement; 1117| 225| for (auto cit = pSrcAnim->mChannels.begin(); 1118| 25.0k| cit != pSrcAnim->mChannels.end(); ++cit) { ------------------ | Branch (1118:17): [True: 24.8k, False: 225] ------------------ 1119| 24.8k| const AnimationChannel &srcChannel = *cit; 1120| 24.8k| ChannelEntry entry; 1121| | 1122| | // we expect the animation target to be of type "nodeName/transformID.subElement". Ignore all others 1123| | // find the slash that separates the node name - there should be only one 1124| 24.8k| std::string::size_type slashPos = srcChannel.mTarget.find('/'); 1125| 24.8k| if (slashPos == std::string::npos) { ------------------ | Branch (1125:17): [True: 0, False: 24.8k] ------------------ 1126| 0| std::string::size_type targetPos = srcChannel.mTarget.find(srcNode->mID); 1127| 0| if (targetPos == std::string::npos) { ------------------ | Branch (1127:21): [True: 0, False: 0] ------------------ 1128| 0| continue; 1129| 0| } 1130| | 1131| | // not node transform, but something else. store as unknown animation channel for now 1132| 0| entry.mChannel = &(*cit); 1133| 0| entry.mTargetId = srcChannel.mTarget.substr(targetPos + pSrcAnim->mName.length(), 1134| 0| srcChannel.mTarget.length() - targetPos - pSrcAnim->mName.length()); 1135| 0| if (entry.mTargetId.front() == '-') { ------------------ | Branch (1135:21): [True: 0, False: 0] ------------------ 1136| 0| entry.mTargetId = entry.mTargetId.substr(1); 1137| 0| } 1138| 0| entries.push_back(entry); 1139| 0| continue; 1140| 0| } 1141| 24.8k| if (srcChannel.mTarget.find('/', slashPos + 1) != std::string::npos) { ------------------ | Branch (1141:17): [True: 0, False: 24.8k] ------------------ 1142| 0| continue; 1143| 0| } 1144| | 1145| 24.8k| targetID.clear(); 1146| 24.8k| targetID = srcChannel.mTarget.substr(0, slashPos); 1147| 24.8k| if (targetID != srcNode->mID) { ------------------ | Branch (1147:17): [True: 24.6k, False: 204] ------------------ 1148| 24.6k| continue; 1149| 24.6k| } 1150| | 1151| | // find the dot that separates the transformID - there should be only one or zero 1152| 204| std::string::size_type dotPos = srcChannel.mTarget.find('.'); 1153| 204| if (dotPos != std::string::npos) { ------------------ | Branch (1153:17): [True: 192, False: 12] ------------------ 1154| 192| if (srcChannel.mTarget.find('.', dotPos + 1) != std::string::npos) { ------------------ | Branch (1154:21): [True: 0, False: 192] ------------------ 1155| 0| continue; 1156| 0| } 1157| | 1158| 192| entry.mTransformId = srcChannel.mTarget.substr(slashPos + 1, dotPos - slashPos - 1); 1159| | 1160| 192| subElement.clear(); 1161| 192| subElement = srcChannel.mTarget.substr(dotPos + 1); 1162| 192| if (subElement == "ANGLE") ------------------ | Branch (1162:21): [True: 192, False: 0] ------------------ 1163| 192| entry.mSubElement = 3; // last number in an Axis-Angle-Transform is the angle 1164| 0| else if (subElement == "X") ------------------ | Branch (1164:26): [True: 0, False: 0] ------------------ 1165| 0| entry.mSubElement = 0; 1166| 0| else if (subElement == "Y") ------------------ | Branch (1166:26): [True: 0, False: 0] ------------------ 1167| 0| entry.mSubElement = 1; 1168| 0| else if (subElement == "Z") ------------------ | Branch (1168:26): [True: 0, False: 0] ------------------ 1169| 0| entry.mSubElement = 2; 1170| 0| else 1171| 0| ASSIMP_LOG_WARN("Unknown anim subelement <", subElement, ">. Ignoring"); 1172| 192| } else { 1173| | // no sub-element following, transformId is remaining string 1174| 12| entry.mTransformId = srcChannel.mTarget.substr(slashPos + 1); 1175| 12| } 1176| | 1177| 204| std::string::size_type bracketPos = srcChannel.mTarget.find('('); 1178| 204| if (bracketPos != std::string::npos) { ------------------ | Branch (1178:17): [True: 0, False: 204] ------------------ 1179| 0| entry.mTransformId = srcChannel.mTarget.substr(slashPos + 1, bracketPos - slashPos - 1); 1180| 0| subElement.clear(); 1181| 0| subElement = srcChannel.mTarget.substr(bracketPos); 1182| | 1183| 0| if (subElement == "(0)(0)") ------------------ | Branch (1183:21): [True: 0, False: 0] ------------------ 1184| 0| entry.mSubElement = 0; 1185| 0| else if (subElement == "(1)(0)") ------------------ | Branch (1185:26): [True: 0, False: 0] ------------------ 1186| 0| entry.mSubElement = 1; 1187| 0| else if (subElement == "(2)(0)") ------------------ | Branch (1187:26): [True: 0, False: 0] ------------------ 1188| 0| entry.mSubElement = 2; 1189| 0| else if (subElement == "(3)(0)") ------------------ | Branch (1189:26): [True: 0, False: 0] ------------------ 1190| 0| entry.mSubElement = 3; 1191| 0| else if (subElement == "(0)(1)") ------------------ | Branch (1191:26): [True: 0, False: 0] ------------------ 1192| 0| entry.mSubElement = 4; 1193| 0| else if (subElement == "(1)(1)") ------------------ | Branch (1193:26): [True: 0, False: 0] ------------------ 1194| 0| entry.mSubElement = 5; 1195| 0| else if (subElement == "(2)(1)") ------------------ | Branch (1195:26): [True: 0, False: 0] ------------------ 1196| 0| entry.mSubElement = 6; 1197| 0| else if (subElement == "(3)(1)") ------------------ | Branch (1197:26): [True: 0, False: 0] ------------------ 1198| 0| entry.mSubElement = 7; 1199| 0| else if (subElement == "(0)(2)") ------------------ | Branch (1199:26): [True: 0, False: 0] ------------------ 1200| 0| entry.mSubElement = 8; 1201| 0| else if (subElement == "(1)(2)") ------------------ | Branch (1201:26): [True: 0, False: 0] ------------------ 1202| 0| entry.mSubElement = 9; 1203| 0| else if (subElement == "(2)(2)") ------------------ | Branch (1203:26): [True: 0, False: 0] ------------------ 1204| 0| entry.mSubElement = 10; 1205| 0| else if (subElement == "(3)(2)") ------------------ | Branch (1205:26): [True: 0, False: 0] ------------------ 1206| 0| entry.mSubElement = 11; 1207| 0| else if (subElement == "(0)(3)") ------------------ | Branch (1207:26): [True: 0, False: 0] ------------------ 1208| 0| entry.mSubElement = 12; 1209| 0| else if (subElement == "(1)(3)") ------------------ | Branch (1209:26): [True: 0, False: 0] ------------------ 1210| 0| entry.mSubElement = 13; 1211| 0| else if (subElement == "(2)(3)") ------------------ | Branch (1211:26): [True: 0, False: 0] ------------------ 1212| 0| entry.mSubElement = 14; 1213| 0| else if (subElement == "(3)(3)") ------------------ | Branch (1213:26): [True: 0, False: 0] ------------------ 1214| 0| entry.mSubElement = 15; 1215| 0| } 1216| | 1217| | // determine which transform step is affected by this channel 1218| 204| entry.mTransformIndex = SIZE_MAX; 1219| 792| for (size_t a = 0; a < srcNode->mTransforms.size(); ++a) ------------------ | Branch (1219:32): [True: 588, False: 204] ------------------ 1220| 588| if (srcNode->mTransforms[a].mID == entry.mTransformId) ------------------ | Branch (1220:21): [True: 204, False: 384] ------------------ 1221| 204| entry.mTransformIndex = a; 1222| | 1223| 204| if (entry.mTransformIndex == SIZE_MAX) { ------------------ | Branch (1223:17): [True: 0, False: 204] ------------------ 1224| 0| if (entry.mTransformId.find("morph-weights") == std::string::npos) { ------------------ | Branch (1224:21): [True: 0, False: 0] ------------------ 1225| 0| continue; 1226| 0| } 1227| 0| entry.mTargetId = entry.mTransformId; 1228| 0| entry.mTransformId = std::string(); 1229| 0| } 1230| | 1231| 204| entry.mChannel = &(*cit); 1232| 204| entries.push_back(entry); 1233| 204| } 1234| | 1235| | // if there's no channel affecting the current node, we skip it 1236| 225| if (entries.empty()) { ------------------ | Branch (1236:13): [True: 149, False: 76] ------------------ 1237| 149| continue; 1238| 149| } 1239| | 1240| | // resolve the data pointers for all anim channels. Find the minimum time while we're at it 1241| 76| ai_real startTime = ai_real(1e20), endTime = ai_real(-1e20); 1242| 204| for (ChannelEntry & e : entries) { ------------------ | Branch (1242:31): [True: 204, False: 76] ------------------ 1243| 204| e.mTimeAccessor = &pParser.ResolveLibraryReference(pParser.mAccessorLibrary, e.mChannel->mSourceTimes); 1244| 204| e.mTimeData = &pParser.ResolveLibraryReference(pParser.mDataLibrary, e.mTimeAccessor->mSource); 1245| 204| e.mValueAccessor = &pParser.ResolveLibraryReference(pParser.mAccessorLibrary, e.mChannel->mSourceValues); 1246| 204| e.mValueData = &pParser.ResolveLibraryReference(pParser.mDataLibrary, e.mValueAccessor->mSource); 1247| | 1248| | // time count and value count must match 1249| 204| if (e.mTimeAccessor->mCount != e.mValueAccessor->mCount) { ------------------ | Branch (1249:17): [True: 0, False: 204] ------------------ 1250| 0| throw DeadlyImportError("Time count / value count mismatch in animation channel \"", e.mChannel->mTarget, "\"."); 1251| 0| } 1252| | 1253| 204| if (e.mTimeAccessor->mCount > 0) { ------------------ | Branch (1253:17): [True: 204, False: 0] ------------------ 1254| | // find bounding times 1255| 204| startTime = std::min(startTime, ReadFloat(*e.mTimeAccessor, *e.mTimeData, 0, 0)); 1256| 204| endTime = std::max(endTime, ReadFloat(*e.mTimeAccessor, *e.mTimeData, e.mTimeAccessor->mCount - 1, 0)); 1257| 204| } 1258| 204| } 1259| | 1260| 76| std::vector resultTrafos; 1261| 76| if (!entries.empty() && entries.front().mTimeAccessor->mCount > 0) { ------------------ | Branch (1261:13): [True: 76, False: 0] | Branch (1261:33): [True: 76, False: 0] ------------------ 1262| | // create a local transformation chain of the node's transforms 1263| 76| std::vector transforms = srcNode->mTransforms; 1264| | 1265| | // now for every unique point in time, find or interpolate the key values for that time 1266| | // and apply them to the transform chain. Then the node's present transformation can be calculated. 1267| 76| ai_real time = startTime; 1268| 536| while (true) { ------------------ | Branch (1268:20): [True: 536, Folded] ------------------ 1269| 1.17k| for (ChannelEntry & e : entries) { ------------------ | Branch (1269:39): [True: 1.17k, False: 536] ------------------ 1270| | // find the keyframe behind the current point in time 1271| 1.17k| size_t pos = 0; 1272| 1.17k| ai_real postTime = 0.0; 1273| 3.83k| while (true) { ------------------ | Branch (1273:28): [True: 3.83k, Folded] ------------------ 1274| 3.83k| if (pos >= e.mTimeAccessor->mCount) { ------------------ | Branch (1274:29): [True: 0, False: 3.83k] ------------------ 1275| 0| break; 1276| 0| } 1277| 3.83k| postTime = ReadFloat(*e.mTimeAccessor, *e.mTimeData, pos, 0); 1278| 3.83k| if (postTime >= time) { ------------------ | Branch (1278:29): [True: 1.17k, False: 2.65k] ------------------ 1279| 1.17k| break; 1280| 1.17k| } 1281| 2.65k| ++pos; 1282| 2.65k| } 1283| | 1284| 1.17k| pos = std::min(pos, e.mTimeAccessor->mCount - 1); 1285| | 1286| | // read values from there 1287| 1.17k| ai_real temp[16]; 1288| 5.59k| for (size_t c = 0; c < e.mValueAccessor->mSize; ++c) { ------------------ | Branch (1288:40): [True: 4.41k, False: 1.17k] ------------------ 1289| 4.41k| temp[c] = ReadFloat(*e.mValueAccessor, *e.mValueData, pos, c); 1290| 4.41k| } 1291| | 1292| | // if not exactly at the key time, interpolate with previous value set 1293| 1.17k| if (postTime > time && pos > 0) { ------------------ | Branch (1293:25): [True: 576, False: 600] | Branch (1293:44): [True: 576, False: 0] ------------------ 1294| 576| ai_real preTime = ReadFloat(*e.mTimeAccessor, *e.mTimeData, pos - 1, 0); 1295| 576| ai_real factor = (time - postTime) / (preTime - postTime); 1296| | 1297| 1.15k| for (size_t c = 0; c < e.mValueAccessor->mSize; ++c) { ------------------ | Branch (1297:44): [True: 576, False: 576] ------------------ 1298| 576| ai_real v = ReadFloat(*e.mValueAccessor, *e.mValueData, pos - 1, c); 1299| 576| temp[c] += (v - temp[c]) * factor; 1300| 576| } 1301| 576| } 1302| | 1303| | // Apply values to current transformation 1304| 1.17k| std::copy(temp, temp + e.mValueAccessor->mSize, transforms[e.mTransformIndex].f + e.mSubElement); 1305| 1.17k| } 1306| | 1307| | // Calculate resulting transformation 1308| 536| aiMatrix4x4 mat = pParser.CalculateResultTransform(transforms); 1309| | 1310| | // out of laziness: we store the time in matrix.d4 1311| 536| mat.d4 = time; 1312| 536| resultTrafos.push_back(mat); 1313| | 1314| | // find next point in time to evaluate. That's the closest frame larger than the current in any channel 1315| 536| ai_real nextTime = ai_real(1e20); 1316| 1.17k| for (ChannelEntry & channelElement : entries) { ------------------ | Branch (1316:52): [True: 1.17k, False: 536] ------------------ 1317| | // find the next time value larger than the current 1318| 1.17k| size_t pos = 0; 1319| 4.43k| while (pos < channelElement.mTimeAccessor->mCount) { ------------------ | Branch (1319:28): [True: 4.23k, False: 204] ------------------ 1320| 4.23k| const ai_real t = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos, 0); 1321| 4.23k| if (t > time) { ------------------ | Branch (1321:29): [True: 972, False: 3.25k] ------------------ 1322| 972| nextTime = std::min(nextTime, t); 1323| 972| break; 1324| 972| } 1325| 3.25k| ++pos; 1326| 3.25k| } 1327| | 1328| | // https://github.com/assimp/assimp/issues/458 1329| | // Sub-sample axis-angle channels if the delta between two consecutive 1330| | // key-frame angles is >= 180 degrees. 1331| 1.17k| if (transforms[channelElement.mTransformIndex].mType == TF_ROTATE && channelElement.mSubElement == 3 && pos > 0 && pos < channelElement.mTimeAccessor->mCount) { ------------------ | Branch (1331:25): [True: 960, False: 216] | Branch (1331:90): [True: 960, False: 0] | Branch (1331:125): [True: 960, False: 0] | Branch (1331:136): [True: 768, False: 192] ------------------ 1332| 768| const ai_real cur_key_angle = ReadFloat(*channelElement.mValueAccessor, *channelElement.mValueData, pos, 0); 1333| 768| const ai_real last_key_angle = ReadFloat(*channelElement.mValueAccessor, *channelElement.mValueData, pos - 1, 0); 1334| 768| const ai_real cur_key_time = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos, 0); 1335| 768| const ai_real last_key_time = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos - 1, 0); 1336| 768| const ai_real last_eval_angle = last_key_angle + (cur_key_angle - last_key_angle) * (time - last_key_time) / (cur_key_time - last_key_time); 1337| 768| const ai_real delta = std::abs(cur_key_angle - last_eval_angle); 1338| 768| if (delta >= 180.0) { ------------------ | Branch (1338:29): [True: 192, False: 576] ------------------ 1339| 192| const int subSampleCount = static_cast(std::floor(delta / 90.0)); 1340| 192| if (cur_key_time != time) { ------------------ | Branch (1340:33): [True: 192, False: 0] ------------------ 1341| 192| const ai_real nextSampleTime = time + (cur_key_time - time) / subSampleCount; 1342| 192| nextTime = std::min(nextTime, nextSampleTime); 1343| 192| } 1344| 192| } 1345| 768| } 1346| 1.17k| } 1347| | 1348| | // no more keys on any channel after the current time -> we're done 1349| 536| if (nextTime > 1e19) { ------------------ | Branch (1349:21): [True: 76, False: 460] ------------------ 1350| 76| break; 1351| 76| } 1352| | 1353| | // else construct next key-frame at this following time point 1354| 460| time = nextTime; 1355| 460| } 1356| 76| } 1357| | 1358| | // build an animation channel for the given node out of these trafo keys 1359| 76| if (!resultTrafos.empty()) { ------------------ | Branch (1359:13): [True: 76, False: 0] ------------------ 1360| 76| auto *dstAnim = new aiNodeAnim; 1361| 76| dstAnim->mNodeName = nodeName; 1362| 76| dstAnim->mNumPositionKeys = static_cast(resultTrafos.size()); 1363| 76| dstAnim->mNumRotationKeys = static_cast(resultTrafos.size()); 1364| 76| dstAnim->mNumScalingKeys = static_cast(resultTrafos.size()); 1365| 76| dstAnim->mPositionKeys = new aiVectorKey[resultTrafos.size()]; 1366| 76| dstAnim->mRotationKeys = new aiQuatKey[resultTrafos.size()]; 1367| 76| dstAnim->mScalingKeys = new aiVectorKey[resultTrafos.size()]; 1368| | 1369| 612| for (size_t a = 0; a < resultTrafos.size(); ++a) { ------------------ | Branch (1369:32): [True: 536, False: 76] ------------------ 1370| 536| aiMatrix4x4 mat = resultTrafos[a]; 1371| 536| double time = double(mat.d4); // remember? time is stored in mat.d4 1372| 536| mat.d4 = 1.0f; 1373| | 1374| 536| dstAnim->mPositionKeys[a].mTime = time * kMillisecondsFromSeconds; 1375| 536| dstAnim->mRotationKeys[a].mTime = time * kMillisecondsFromSeconds; 1376| 536| dstAnim->mScalingKeys[a].mTime = time * kMillisecondsFromSeconds; 1377| 536| mat.Decompose(dstAnim->mScalingKeys[a].mValue, dstAnim->mRotationKeys[a].mValue, dstAnim->mPositionKeys[a].mValue); 1378| 536| } 1379| | 1380| 76| anims.push_back(dstAnim); 1381| 76| } else { 1382| 0| ASSIMP_LOG_WARN("Collada loader: found empty animation channel, ignored. Please check your exporter."); 1383| 0| } 1384| | 1385| 76| if (!entries.empty() && entries.front().mTimeAccessor->mCount > 0) { ------------------ | Branch (1385:13): [True: 76, False: 0] | Branch (1385:33): [True: 76, False: 0] ------------------ 1386| 76| std::vector morphChannels; 1387| 204| for (ChannelEntry & e : entries) { ------------------ | Branch (1387:35): [True: 204, False: 76] ------------------ 1388| | // skip non-transform types 1389| 204| if (e.mTargetId.empty()) { ------------------ | Branch (1389:21): [True: 204, False: 0] ------------------ 1390| 204| continue; 1391| 204| } 1392| | 1393| 0| if (e.mTargetId.find("morph-weights") != std::string::npos) { ------------------ | Branch (1393:21): [True: 0, False: 0] ------------------ 1394| 0| morphChannels.push_back(e); 1395| 0| } 1396| 0| } 1397| 76| if (!morphChannels.empty()) { ------------------ | Branch (1397:17): [True: 0, False: 76] ------------------ 1398| | // either 1) morph weight animation count should contain morph target count channels 1399| | // or 2) one channel with morph target count arrays 1400| | // assume first 1401| | 1402| 0| auto *morphAnim = new aiMeshMorphAnim; 1403| 0| morphAnim->mName.Set(nodeName); 1404| | 1405| 0| std::vector morphTimeValues; 1406| 0| int morphAnimChannelIndex = 0; 1407| 0| for (ChannelEntry & e : morphChannels) { ------------------ | Branch (1407:39): [True: 0, False: 0] ------------------ 1408| 0| std::string::size_type apos = e.mTargetId.find('('); 1409| 0| std::string::size_type bpos = e.mTargetId.find(')'); 1410| | 1411| | // If unknown way to specify weight -> ignore this animation 1412| 0| if (apos == std::string::npos || bpos == std::string::npos) { ------------------ | Branch (1412:25): [True: 0, False: 0] | Branch (1412:54): [True: 0, False: 0] ------------------ 1413| 0| continue; 1414| 0| } 1415| | 1416| | // weight target can be in format Weight_M_N, Weight_N, WeightN, or some other way 1417| | // we ignore the name and just assume the channels are in the right order 1418| 0| for (unsigned int i = 0; i < e.mTimeData->mValues.size(); i++) { ------------------ | Branch (1418:46): [True: 0, False: 0] ------------------ 1419| 0| insertMorphTimeValue(morphTimeValues, e.mTimeData->mValues[i], e.mValueData->mValues[i], morphAnimChannelIndex); 1420| 0| } 1421| | 1422| 0| ++morphAnimChannelIndex; 1423| 0| } 1424| | 1425| 0| morphAnim->mNumKeys = static_cast(morphTimeValues.size()); 1426| 0| morphAnim->mKeys = new aiMeshMorphKey[morphAnim->mNumKeys]; 1427| 0| for (unsigned int key = 0; key < morphAnim->mNumKeys; key++) { ------------------ | Branch (1427:44): [True: 0, False: 0] ------------------ 1428| 0| morphAnim->mKeys[key].mNumValuesAndWeights = static_cast(morphChannels.size()); 1429| 0| morphAnim->mKeys[key].mValues = new unsigned int[morphChannels.size()]; 1430| 0| morphAnim->mKeys[key].mWeights = new double[morphChannels.size()]; 1431| | 1432| 0| morphAnim->mKeys[key].mTime = morphTimeValues[key].mTime * kMillisecondsFromSeconds; 1433| 0| for (unsigned int valueIndex = 0; valueIndex < morphChannels.size(); ++valueIndex) { ------------------ | Branch (1433:55): [True: 0, False: 0] ------------------ 1434| 0| morphAnim->mKeys[key].mValues[valueIndex] = valueIndex; 1435| 0| morphAnim->mKeys[key].mWeights[valueIndex] = getWeightAtKey(morphTimeValues, key, valueIndex); 1436| 0| } 1437| 0| } 1438| | 1439| 0| morphAnims.push_back(morphAnim); 1440| 0| } 1441| 76| } 1442| 76| } 1443| | 1444| 13| if (!anims.empty() || !morphAnims.empty()) { ------------------ | Branch (1444:9): [True: 13, False: 0] | Branch (1444:27): [True: 0, False: 0] ------------------ 1445| 13| auto anim = new aiAnimation; 1446| 13| anim->mName.Set(pName); 1447| 13| anim->mNumChannels = static_cast(anims.size()); 1448| 13| if (anim->mNumChannels > 0) { ------------------ | Branch (1448:13): [True: 13, False: 0] ------------------ 1449| 13| anim->mChannels = new aiNodeAnim *[anims.size()]; 1450| 13| std::copy(anims.begin(), anims.end(), anim->mChannels); 1451| 13| } 1452| 13| anim->mNumMorphMeshChannels = static_cast(morphAnims.size()); 1453| 13| if (anim->mNumMorphMeshChannels > 0) { ------------------ | Branch (1453:13): [True: 0, False: 13] ------------------ 1454| 0| anim->mMorphMeshChannels = new aiMeshMorphAnim *[anim->mNumMorphMeshChannels]; 1455| 0| std::copy(morphAnims.begin(), morphAnims.end(), anim->mMorphMeshChannels); 1456| 0| } 1457| 13| anim->mDuration = 0.0f; 1458| 76| for (auto & a : anims) { ------------------ | Branch (1458:23): [True: 76, False: 13] ------------------ 1459| 76| anim->mDuration = std::max(anim->mDuration, a->mPositionKeys[a->mNumPositionKeys - 1].mTime); 1460| 76| anim->mDuration = std::max(anim->mDuration, a->mRotationKeys[a->mNumRotationKeys - 1].mTime); 1461| 76| anim->mDuration = std::max(anim->mDuration, a->mScalingKeys[a->mNumScalingKeys - 1].mTime); 1462| 76| } 1463| 13| for (auto & morphAnim : morphAnims) { ------------------ | Branch (1463:31): [True: 0, False: 13] ------------------ 1464| 0| anim->mDuration = std::max(anim->mDuration, morphAnim->mKeys[morphAnim->mNumKeys - 1].mTime); 1465| 0| } 1466| 13| anim->mTicksPerSecond = 1000.0; 1467| 13| mAnims.push_back(anim); 1468| 13| } 1469| 13|} _ZN6Assimp13ColladaLoader10AddTextureER10aiMaterialRKNS_13ColladaParserERKNS_7Collada6EffectERKNS6_7SamplerE13aiTextureTypej: 1478| 12| unsigned int idx) { 1479| | // first of all, basic file name 1480| 12| const aiString name = FindFilenameForEffectTexture(pParser, effect, sampler.mName); 1481| 12| mat.AddProperty(&name, _AI_MATKEY_TEXTURE_BASE, type, idx); 1482| | 1483| | // mapping mode 1484| 12| int map = aiTextureMapMode_Clamp; 1485| 12| if (sampler.mWrapU) { ------------------ | Branch (1485:9): [True: 12, False: 0] ------------------ 1486| 12| map = aiTextureMapMode_Wrap; 1487| 12| } 1488| 12| if (sampler.mWrapU && sampler.mMirrorU) { ------------------ | Branch (1488:9): [True: 12, False: 0] | Branch (1488:27): [True: 0, False: 12] ------------------ 1489| 0| map = aiTextureMapMode_Mirror; 1490| 0| } 1491| | 1492| 12| mat.AddProperty(&map, 1, _AI_MATKEY_MAPPINGMODE_U_BASE, type, idx); 1493| | 1494| 12| map = aiTextureMapMode_Clamp; 1495| 12| if (sampler.mWrapV) { ------------------ | Branch (1495:9): [True: 12, False: 0] ------------------ 1496| 12| map = aiTextureMapMode_Wrap; 1497| 12| } 1498| 12| if (sampler.mWrapV && sampler.mMirrorV) { ------------------ | Branch (1498:9): [True: 12, False: 0] | Branch (1498:27): [True: 0, False: 12] ------------------ 1499| 0| map = aiTextureMapMode_Mirror; 1500| 0| } 1501| | 1502| 12| mat.AddProperty(&map, 1, _AI_MATKEY_MAPPINGMODE_V_BASE, type, idx); 1503| | 1504| | // UV transformation 1505| 12| mat.AddProperty(&sampler.mTransform, 1, 1506| 12| _AI_MATKEY_UVTRANSFORM_BASE, type, idx); 1507| | 1508| | // Blend mode 1509| 12| mat.AddProperty((int *)&sampler.mOp, 1, 1510| 12| _AI_MATKEY_TEXBLEND_BASE, type, idx); 1511| | 1512| | // Blend factor 1513| 12| mat.AddProperty((ai_real *)&sampler.mWeighting, 1, 1514| 12| _AI_MATKEY_TEXBLEND_BASE, type, idx); 1515| | 1516| | // UV source index ... if we didn't resolve the mapping, it is actually just 1517| | // a guess but it works in most cases. We search for the frst occurrence of a 1518| | // number in the channel name. We assume it is the zero-based index into the 1519| | // UV channel array of all corresponding meshes. It could also be one-based 1520| | // for some exporters, but we won't care of it unless someone complains about. 1521| 12| if (sampler.mUVId != UINT_MAX) { ------------------ | Branch (1521:9): [True: 10, False: 2] ------------------ 1522| 10| map = sampler.mUVId; 1523| 10| } else { 1524| 2| map = -1; 1525| 16| for (auto it = sampler.mUVChannel.begin(); it != sampler.mUVChannel.end(); ++it) { ------------------ | Branch (1525:52): [True: 16, False: 0] ------------------ 1526| 16| if (IsNumeric(*it)) { ------------------ | Branch (1526:17): [True: 2, False: 14] ------------------ 1527| 2| map = strtoul10(&(*it)); 1528| 2| break; 1529| 2| } 1530| 16| } 1531| 2| if (-1 == map) { ------------------ | Branch (1531:13): [True: 0, False: 2] ------------------ 1532| 0| ASSIMP_LOG_WARN("Collada: unable to determine UV channel for texture"); 1533| 0| map = 0; 1534| 0| } 1535| 2| } 1536| | mat.AddProperty(&map, 1, _AI_MATKEY_UVWSRC_BASE, type, idx); 1537| 12|} _ZN6Assimp13ColladaLoader13FillMaterialsERKNS_13ColladaParserEP7aiScene: 1541| 16|void ColladaLoader::FillMaterials(const ColladaParser &pParser, aiScene * /*pScene*/) { 1542| 24| for (auto &elem : newMats) { ------------------ | Branch (1542:21): [True: 24, False: 16] ------------------ 1543| 24| auto &mat = (aiMaterial &)*elem.second; 1544| 24| Collada::Effect &effect = *elem.first; 1545| | 1546| | // resolve shading mode 1547| 24| int shadeMode; 1548| 24| if (effect.mFaceted) { ------------------ | Branch (1548:13): [True: 0, False: 24] ------------------ 1549| 0| shadeMode = aiShadingMode_Flat; 1550| 24| } else { 1551| 24| switch (effect.mShadeType) { 1552| 0| case Collada::Shade_Constant: ------------------ | Branch (1552:13): [True: 0, False: 24] ------------------ 1553| 0| shadeMode = aiShadingMode_NoShading; 1554| 0| break; 1555| 2| case Collada::Shade_Lambert: ------------------ | Branch (1555:13): [True: 2, False: 22] ------------------ 1556| 2| shadeMode = aiShadingMode_Gouraud; 1557| 2| break; 1558| 6| case Collada::Shade_Blinn: ------------------ | Branch (1558:13): [True: 6, False: 18] ------------------ 1559| 6| shadeMode = aiShadingMode_Blinn; 1560| 6| break; 1561| 16| case Collada::Shade_Phong: ------------------ | Branch (1561:13): [True: 16, False: 8] ------------------ 1562| 16| shadeMode = aiShadingMode_Phong; 1563| 16| break; 1564| | 1565| 0| default: ------------------ | Branch (1565:13): [True: 0, False: 24] ------------------ 1566| 0| ASSIMP_LOG_WARN("Collada: Unrecognized shading mode, using gouraud shading"); 1567| 0| shadeMode = aiShadingMode_Gouraud; 1568| 0| break; 1569| 24| } 1570| 24| } 1571| 24| mat.AddProperty(&shadeMode, 1, AI_MATKEY_SHADING_MODEL); 1572| | 1573| | // double-sided? 1574| 24| shadeMode = effect.mDoubleSided; 1575| 24| mat.AddProperty(&shadeMode, 1, AI_MATKEY_TWOSIDED); 1576| | 1577| | // wire-frame? 1578| 24| shadeMode = effect.mWireframe; 1579| 24| mat.AddProperty(&shadeMode, 1, AI_MATKEY_ENABLE_WIREFRAME); 1580| | 1581| | // add material colors 1582| 24| mat.AddProperty(&effect.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT); 1583| 24| mat.AddProperty(&effect.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE); 1584| 24| mat.AddProperty(&effect.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR); 1585| 24| mat.AddProperty(&effect.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE); 1586| 24| mat.AddProperty(&effect.mReflective, 1, AI_MATKEY_COLOR_REFLECTIVE); 1587| | 1588| | // scalar properties 1589| 24| mat.AddProperty(&effect.mShininess, 1, AI_MATKEY_SHININESS); 1590| 24| mat.AddProperty(&effect.mReflectivity, 1, AI_MATKEY_REFLECTIVITY); 1591| 24| mat.AddProperty(&effect.mRefractIndex, 1, AI_MATKEY_REFRACTI); 1592| | 1593| | // transparency, a very hard one. seemingly not all files are following the 1594| | // specification here (1.0 transparency => completely opaque)... 1595| | // therefore, we let the opportunity for the user to manually invert 1596| | // the transparency if necessary and we add preliminary support for RGB_ZERO mode 1597| 24| if (effect.mTransparency >= 0.f && effect.mTransparency <= 1.f) { ------------------ | Branch (1597:13): [True: 24, False: 0] | Branch (1597:44): [True: 24, False: 0] ------------------ 1598| | // handle RGB transparency completely, cf Collada specs 1.5.0 pages 249 and 304 1599| 24| if (effect.mRGBTransparency) { ------------------ | Branch (1599:17): [True: 0, False: 24] ------------------ 1600| | // use luminance as defined by ISO/CIE color standards (see ITU-R Recommendation BT.709-4) 1601| 0| effect.mTransparency *= (0.212671f * effect.mTransparent.r + 1602| 0| 0.715160f * effect.mTransparent.g + 1603| 0| 0.072169f * effect.mTransparent.b); 1604| | 1605| 0| effect.mTransparent.a = 1.f; 1606| | 1607| 0| mat.AddProperty(&effect.mTransparent, 1, AI_MATKEY_COLOR_TRANSPARENT); 1608| 24| } else { 1609| 24| effect.mTransparency *= effect.mTransparent.a; 1610| 24| } 1611| | 1612| 24| if (effect.mInvertTransparency) { ------------------ | Branch (1612:17): [True: 0, False: 24] ------------------ 1613| 0| effect.mTransparency = 1.f - effect.mTransparency; 1614| 0| } 1615| | 1616| | // Is the material finally transparent ? 1617| 24| if (effect.mHasTransparency || effect.mTransparency < 1.f) { ------------------ | Branch (1617:17): [True: 22, False: 2] | Branch (1617:44): [True: 0, False: 2] ------------------ 1618| 22| mat.AddProperty(&effect.mTransparency, 1, AI_MATKEY_OPACITY); 1619| 22| } 1620| 24| } 1621| | 1622| | // add textures, if given 1623| 24| if (!effect.mTexAmbient.mName.empty()) { ------------------ | Branch (1623:13): [True: 0, False: 24] ------------------ 1624| | // It is merely a light-map 1625| 0| AddTexture(mat, pParser, effect, effect.mTexAmbient, aiTextureType_LIGHTMAP); 1626| 0| } 1627| | 1628| 24| if (!effect.mTexEmissive.mName.empty()) ------------------ | Branch (1628:13): [True: 0, False: 24] ------------------ 1629| 0| AddTexture(mat, pParser, effect, effect.mTexEmissive, aiTextureType_EMISSIVE); 1630| | 1631| 24| if (!effect.mTexSpecular.mName.empty()) ------------------ | Branch (1631:13): [True: 0, False: 24] ------------------ 1632| 0| AddTexture(mat, pParser, effect, effect.mTexSpecular, aiTextureType_SPECULAR); 1633| | 1634| 24| if (!effect.mTexDiffuse.mName.empty()) ------------------ | Branch (1634:13): [True: 12, False: 12] ------------------ 1635| 12| AddTexture(mat, pParser, effect, effect.mTexDiffuse, aiTextureType_DIFFUSE); 1636| | 1637| 24| if (!effect.mTexBump.mName.empty()) ------------------ | Branch (1637:13): [True: 0, False: 24] ------------------ 1638| 0| AddTexture(mat, pParser, effect, effect.mTexBump, aiTextureType_NORMALS); 1639| | 1640| 24| if (!effect.mTexTransparent.mName.empty()) ------------------ | Branch (1640:13): [True: 0, False: 24] ------------------ 1641| 0| AddTexture(mat, pParser, effect, effect.mTexTransparent, aiTextureType_OPACITY); 1642| | 1643| 24| if (!effect.mTexReflective.mName.empty()) ------------------ | Branch (1643:13): [True: 0, False: 24] ------------------ 1644| 0| AddTexture(mat, pParser, effect, effect.mTexReflective, aiTextureType_REFLECTION); 1645| 24| } 1646| 16|} _ZN6Assimp13ColladaLoader14BuildMaterialsERNS_13ColladaParserEP7aiScene: 1650| 16|void ColladaLoader::BuildMaterials(ColladaParser &pParser, aiScene * /*pScene*/) { 1651| 16| newMats.reserve(pParser.mMaterialLibrary.size()); 1652| | 1653| 16| for (auto matIt = pParser.mMaterialLibrary.begin(); 1654| 40| matIt != pParser.mMaterialLibrary.end(); ++matIt) { ------------------ | Branch (1654:13): [True: 24, False: 16] ------------------ 1655| 24| const Material &material = matIt->second; 1656| | // a material is only a reference to an effect 1657| 24| auto effIt = pParser.mEffectLibrary.find(material.mEffect); 1658| 24| if (effIt == pParser.mEffectLibrary.end()) ------------------ | Branch (1658:13): [True: 0, False: 24] ------------------ 1659| 0| continue; 1660| 24| Effect &effect = effIt->second; 1661| | 1662| | // create material 1663| 24| auto *mat = new aiMaterial; 1664| 24| aiString name(material.mName.empty() ? matIt->first : material.mName); ------------------ | Branch (1664:23): [True: 0, False: 24] ------------------ 1665| 24| mat->AddProperty(&name, AI_MATKEY_NAME); 1666| | 1667| | // store the material 1668| 24| mMaterialIndexByName[matIt->first] = newMats.size(); 1669| 24| newMats.emplace_back(&effect, mat); 1670| 24| } 1671| | // ScenePreprocessor generates a default material automatically if none is there. 1672| | // All further code here in this loader works well without a valid material so 1673| | // we can safely let it to ScenePreprocessor. 1674| 16|} _ZN6Assimp13ColladaLoader28FindFilenameForEffectTextureERKNS_13ColladaParserERKNS_7Collada6EffectERKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEE: 1679| 12| const Effect &pEffect, const std::string &pName) { 1680| 12| aiString result; 1681| | 1682| | // recurse through the param references until we end up at an image 1683| 12| std::string name = pName; 1684| 32| while (true) { ------------------ | Branch (1684:12): [True: 32, Folded] ------------------ 1685| | // the given string is a param entry. Find it 1686| 32| auto it = pEffect.mParams.find(name); 1687| | // if not found, we're at the end of the recursion. The resulting string should be the image ID 1688| 32| if (it == pEffect.mParams.end()) ------------------ | Branch (1688:13): [True: 12, False: 20] ------------------ 1689| 12| break; 1690| | 1691| | // else recurse on 1692| 20| name = it->second.mReference; 1693| 20| } 1694| | 1695| | // find the image referred by this name in the image library of the scene 1696| 12| auto imIt = pParser.mImageLibrary.find(name); 1697| 12| if (imIt == pParser.mImageLibrary.end()) { ------------------ | Branch (1697:9): [True: 0, False: 12] ------------------ 1698| 0| ASSIMP_LOG_WARN("Collada: Unable to resolve effect texture entry \"", pName, "\", ended up at ID \"", name, "\"."); 1699| | 1700| | //set default texture file name 1701| 0| result.Set(name + ".jpg"); 1702| 0| ColladaParser::UriDecodePath(result); 1703| 0| return result; 1704| 0| } 1705| | 1706| | // if this is an embedded texture image setup an aiTexture for it 1707| 12| if (!imIt->second.mImageData.empty()) { ------------------ | Branch (1707:9): [True: 2, False: 10] ------------------ 1708| 2| auto *tex = new aiTexture(); 1709| | 1710| | // Store embedded texture name reference 1711| 2| tex->mFilename.Set(imIt->second.mFileName.c_str()); 1712| 2| result.Set(imIt->second.mFileName); 1713| | 1714| | // setup format hint 1715| 2| if (imIt->second.mEmbeddedFormat.length() >= HINTMAXTEXTURELEN) { ------------------ | Branch (1715:13): [True: 0, False: 2] ------------------ 1716| 0| ASSIMP_LOG_WARN("Collada: texture format hint is too long, truncating to 3 characters"); 1717| 0| } 1718| 2| strncpy(tex->achFormatHint, imIt->second.mEmbeddedFormat.c_str(), 3); 1719| | 1720| | // and copy texture data 1721| 2| tex->mHeight = 0; 1722| 2| tex->mWidth = static_cast(imIt->second.mImageData.size()); 1723| 2| tex->pcData = (aiTexel *)new char[tex->mWidth]; 1724| 2| memcpy(tex->pcData, &imIt->second.mImageData[0], tex->mWidth); 1725| | 1726| | // and add this texture to the list 1727| 2| mTextures.push_back(tex); 1728| 2| return result; 1729| 2| } 1730| | 1731| 10| if (imIt->second.mFileName.empty()) { ------------------ | Branch (1731:9): [True: 0, False: 10] ------------------ 1732| 0| throw DeadlyImportError("Collada: Invalid texture, no data or file reference given"); 1733| 0| } 1734| | 1735| 10| result.Set(imIt->second.mFileName); 1736| | 1737| 10| return result; 1738| 10|} _ZNK6Assimp13ColladaLoader10ReadStringERKNS_7Collada8AccessorERKNS1_4DataEm: 1742| 4|const std::string &ColladaLoader::ReadString(const Accessor &pAccessor, const Data &pData, size_t pIndex) const { 1743| 4| size_t pos = pAccessor.mStride * pIndex + pAccessor.mOffset; 1744| 4| ai_assert(pos < pData.mStrings.size()); ------------------ | | 67| 4|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 4, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 1745| 4| return pData.mStrings[pos]; 1746| 4|} _ZNK6Assimp13ColladaLoader12CollectNodesEPK6aiNodeRNSt3__16vectorIS3_NS4_9allocatorIS3_EEEE: 1750| 225|void ColladaLoader::CollectNodes(const aiNode *pNode, std::vector &poNodes) const { 1751| 225| poNodes.push_back(pNode); 1752| 437| for (size_t a = 0; a < pNode->mNumChildren; ++a) { ------------------ | Branch (1752:24): [True: 212, False: 225] ------------------ 1753| 212| CollectNodes(pNode->mChildren[a], poNodes); 1754| 212| } 1755| 225|} _ZNK6Assimp13ColladaLoader8FindNodeEPKNS_7Collada4NodeERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 1759| 8.84k|const Node *ColladaLoader::FindNode(const Node *pNode, const std::string &pName) const { 1760| 8.84k| if (pNode->mName == pName || pNode->mID == pName) ------------------ | Branch (1760:9): [True: 153, False: 8.69k] | Branch (1760:34): [True: 72, False: 8.62k] ------------------ 1761| 225| return pNode; 1762| | 1763| 8.62k| for (auto a : pNode->mChildren) { ------------------ | Branch (1763:17): [True: 8.62k, False: 4.13k] ------------------ 1764| 8.62k| const Collada::Node *node = FindNode(a, pName); 1765| 8.62k| if (node) { ------------------ | Branch (1765:13): [True: 4.48k, False: 4.13k] ------------------ 1766| 4.48k| return node; 1767| 4.48k| } 1768| 8.62k| } 1769| | 1770| 4.13k| return nullptr; 1771| 8.62k|} _ZNK6Assimp13ColladaLoader13FindNodeBySIDEPKNS_7Collada4NodeERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 1775| 18|const Node *ColladaLoader::FindNodeBySID(const Node *pNode, const std::string &pSID) const { 1776| 18| if (nullptr == pNode) { ------------------ | Branch (1776:9): [True: 0, False: 18] ------------------ 1777| 0| return nullptr; 1778| 0| } 1779| | 1780| 18| if (pNode->mSID == pSID) { ------------------ | Branch (1780:9): [True: 4, False: 14] ------------------ 1781| 4| return pNode; 1782| 4| } 1783| | 1784| 14| for (auto a : pNode->mChildren) { ------------------ | Branch (1784:17): [True: 14, False: 0] ------------------ 1785| 14| const Collada::Node *node = FindNodeBySID(a, pSID); 1786| 14| if (node) { ------------------ | Branch (1786:13): [True: 14, False: 0] ------------------ 1787| 14| return node; 1788| 14| } 1789| 14| } 1790| | 1791| 0| return nullptr; 1792| 14|} _ZN6Assimp13ColladaLoader15FindNameForNodeEPKNS_7Collada4NodeE: 1797| 200|std::string ColladaLoader::FindNameForNode(const Node *pNode) { 1798| | // If explicitly requested, just use the collada name. 1799| 200| if (useColladaName) { ------------------ | Branch (1799:9): [True: 0, False: 200] ------------------ 1800| 0| if (!pNode->mName.empty()) { ------------------ | Branch (1800:13): [True: 0, False: 0] ------------------ 1801| 0| return pNode->mName; 1802| 0| } else { 1803| 0| return format() << "$ColladaAutoName$_" << mNodeNameCounter++; 1804| 0| } 1805| 200| } else { 1806| | // Now setup the name of the assimp node. The collada name might not be 1807| | // unique, so we use the collada ID. 1808| 200| if (!pNode->mID.empty()) ------------------ | Branch (1808:13): [True: 200, False: 0] ------------------ 1809| 200| return pNode->mID; 1810| 0| else if (!pNode->mSID.empty()) ------------------ | Branch (1810:18): [True: 0, False: 0] ------------------ 1811| 0| return pNode->mSID; 1812| 0| else { 1813| | // No need to worry. Unnamed nodes are no problem at all, except 1814| | // if cameras or lights need to be assigned to them. 1815| 0| return format() << "$ColladaAutoName$_" << mNodeNameCounter++; 1816| 0| } 1817| 200| } 1818| 200|} ColladaLoader.cpp:_ZN6AssimpL34ApplyVertexToEffectSemanticMappingERNS_7Collada7SamplerERKNS0_20SemanticMappingTableE: 310| 78|static void ApplyVertexToEffectSemanticMapping(Sampler &sampler, const SemanticMappingTable &table) { 311| 78| const auto it = table.mMap.find(sampler.mUVChannel); 312| 78| if (it == table.mMap.end()) { ------------------ | Branch (312:9): [True: 68, False: 10] ------------------ 313| 68| return; 314| 68| } 315| | 316| 10| if (it->second.mType != IT_Texcoord) { ------------------ | Branch (316:9): [True: 10, False: 0] ------------------ 317| 10| ASSIMP_LOG_ERROR("Collada: Unexpected effect input mapping"); 318| 10| } 319| | 320| 10| sampler.mUVId = it->second.mSet; 321| 10|} ColladaLoader.cpp:_ZN6AssimpL9ReadFloatERKNS_7Collada8AccessorERKNS0_4DataEmm: 94| 17.3k|static ai_real ReadFloat(const Accessor &pAccessor, const Data &pData, size_t pIndex, size_t pOffset) { 95| 17.3k| const size_t pos = pAccessor.mStride * pIndex + pAccessor.mOffset + pOffset; 96| 17.3k| ai_assert(pos < pData.mValues.size()); ------------------ | | 67| 17.3k|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 17.3k, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 97| 17.3k| return pData.mValues[pos]; 98| 17.3k|} ColladaLoader.cpp:_ZZN6Assimp13ColladaLoader18BuildMeshesForNodeERKNS_13ColladaParserEPKNS_7Collada4NodeEP6aiNodeENK17UIntTypeConverterclERKm: 558| 90| unsigned int operator()(const size_t &v) const { 559| 90| return static_cast(v); 560| 90| } _ZN6Assimp16ColladaMeshIndexC2ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEmS9_: 63| 90| mMeshID(pMeshID), mSubMesh(pSubMesh), mMaterial(pMaterial) { 64| 90| ai_assert(!pMeshID.empty()); ------------------ | | 67| 90|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 90, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 65| 90| } _ZNK6Assimp16ColladaMeshIndexltERKS0_: 67| 1.38k| bool operator<(const ColladaMeshIndex &p) const { 68| 1.38k| if (mMeshID == p.mMeshID) { ------------------ | Branch (68:13): [True: 33, False: 1.35k] ------------------ 69| 33| if (mSubMesh == p.mSubMesh) ------------------ | Branch (69:17): [True: 0, False: 33] ------------------ 70| 0| return mMaterial < p.mMaterial; 71| 33| else 72| 33| return mSubMesh < p.mSubMesh; 73| 1.35k| } else { 74| 1.35k| return mMeshID < p.mMeshID; 75| 1.35k| } 76| 1.38k| } _ZN6Assimp13ColladaLoaderD2Ev: 91| 624| ~ColladaLoader() override = default; _ZN6Assimp13ColladaParserC2EPNS_8IOSystemERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEE: 415| 31| mFileName(pFile), 416| 31| mRootNode(nullptr), 417| 31| mUnitSize(1.0f), 418| 31| mUpDirection(UP_Y), 419| 31| mFormat(FV_1_5_n) { 420| 31| if (nullptr == pIOHandler) { ------------------ | Branch (420:9): [True: 0, False: 31] ------------------ 421| 0| throw DeadlyImportError("IOSystem is nullptr."); 422| 0| } 423| | 424| 31| std::unique_ptr daeFile; 425| 31| std::unique_ptr zip_archive; 426| | 427| | // Determine type 428| 31| const std::string extension = BaseImporter::GetExtension(pFile); 429| 31| if (extension != "dae") { ------------------ | Branch (429:9): [True: 31, False: 0] ------------------ 430| 31| zip_archive = std::make_unique(pIOHandler, pFile); 431| 31| } 432| | 433| 31| if (zip_archive && zip_archive->isOpen()) { ------------------ | Branch (433:9): [True: 31, False: 0] | Branch (433:24): [True: 3, False: 28] ------------------ 434| 3| std::string dae_filename = ReadZaeManifest(*zip_archive); 435| | 436| 3| if (dae_filename.empty()) { ------------------ | Branch (436:13): [True: 0, False: 3] ------------------ 437| 0| throw DeadlyImportError("Invalid ZAE"); 438| 0| } 439| | 440| 3| daeFile.reset(zip_archive->Open(dae_filename.c_str())); 441| 3| if (daeFile == nullptr) { ------------------ | Branch (441:13): [True: 1, False: 2] ------------------ 442| 1| throw DeadlyImportError("Invalid ZAE manifest: '", dae_filename, "' is missing"); 443| 1| } 444| 28| } else { 445| | // attempt to open the file directly 446| 28| daeFile.reset(pIOHandler->Open(pFile)); 447| 28| if (daeFile == nullptr) { ------------------ | Branch (447:13): [True: 0, False: 28] ------------------ 448| 0| throw DeadlyImportError("Failed to open file '", pFile, "'."); 449| 0| } 450| 28| } 451| | 452| | // generate a XML reader for it 453| 30| if (!mXmlParser.parse(daeFile.get())) { ------------------ | Branch (453:9): [True: 0, False: 30] ------------------ 454| 0| throw DeadlyImportError("Unable to read file, malformed XML"); 455| 0| } 456| | // start reading 457| 30| const XmlNode node = mXmlParser.getRootNode(); 458| 30| XmlNode colladaNode = node.child("COLLADA"); 459| 30| if (colladaNode.empty()) { ------------------ | Branch (459:9): [True: 0, False: 30] ------------------ 460| 0| return; 461| 0| } 462| | 463| | // Read content and embedded textures 464| 30| ReadContents(colladaNode); 465| 30| if (zip_archive && zip_archive->isOpen()) { ------------------ | Branch (465:9): [True: 16, False: 14] | Branch (465:24): [True: 2, False: 14] ------------------ 466| 2| ReadEmbeddedTextures(*zip_archive); 467| 2| } 468| 30|} _ZN6Assimp13ColladaParserD2Ev: 472| 16|ColladaParser::~ColladaParser() { 473| 16| for (auto &it : mNodeLibrary) { ------------------ | Branch (473:19): [True: 16, False: 16] ------------------ 474| 16| delete it.second; 475| 16| } 476| 85| for (auto &it : mMeshLibrary) { ------------------ | Branch (476:19): [True: 85, False: 16] ------------------ 477| 85| delete it.second; 478| 85| } 479| 16|} _ZN6Assimp13ColladaParser15ReadZaeManifestERNS_18ZipArchiveIOSystemE: 483| 13|std::string ColladaParser::ReadZaeManifest(ZipArchiveIOSystem &zip_archive) { 484| | // Open the manifest 485| 13| std::unique_ptr manifestfile(zip_archive.Open("manifest.xml")); 486| 13| if (manifestfile == nullptr) { ------------------ | Branch (486:9): [True: 9, False: 4] ------------------ 487| | // No manifest, hope there is only one .DAE inside 488| 9| std::vector file_list; 489| 9| zip_archive.getFileListExtension(file_list, "dae"); 490| | 491| 9| if (file_list.empty()) { ------------------ | Branch (491:13): [True: 7, False: 2] ------------------ 492| 7| return {}; 493| 7| } 494| | 495| 2| return file_list.front(); 496| 9| } 497| 4| XmlParser manifestParser; 498| 4| if (!manifestParser.parse(manifestfile.get())) { ------------------ | Branch (498:9): [True: 0, False: 4] ------------------ 499| 0| return {}; 500| 0| } 501| | 502| 4| XmlNode root = manifestParser.getRootNode(); 503| 4| const std::string &name = root.name(); 504| 4| if (name != "dae_root") { ------------------ | Branch (504:9): [True: 4, False: 0] ------------------ 505| 4| root = *manifestParser.findNode("dae_root"); 506| 4| if (nullptr == root) { ------------------ | Branch (506:13): [True: 0, False: 4] ------------------ 507| 0| return {}; 508| 0| } 509| 4| std::string v; 510| 4| XmlParser::getValueAsString(root, v); 511| 4| aiString ai_str(v); 512| 4| UriDecodePath(ai_str); 513| 4| return std::string(ai_str.C_Str()); 514| 4| } 515| | 516| 0| return {}; 517| 4|} _ZN6Assimp13ColladaParser13UriDecodePathER8aiString: 521| 22|void ColladaParser::UriDecodePath(aiString &ss) { 522| | // TODO: collada spec, p 22. Handle URI correctly. 523| | // For the moment we're just stripping the file:// away to make it work. 524| | // Windows doesn't seem to be able to find stuff like 525| | // 'file://..\LWO\LWO2\MappingModes\earthSpherical.jpg' 526| 22| if (0 == strncmp(ss.data, "file://", 7)) { ------------------ | Branch (526:9): [True: 1, False: 21] ------------------ 527| 1| ss.length -= 7; 528| 1| memmove(ss.data, ss.data + 7, ss.length); 529| 1| ss.data[ss.length] = '\0'; 530| 1| } 531| | 532| | // Maxon Cinema Collada Export writes "file:///C:\andsoon" with three slashes... 533| | // I need to filter it without destroying linux paths starting with "/somewhere" 534| 22| if (ss.data[0] == '/' && isalpha((unsigned char)ss.data[1]) && ss.data[2] == ':') { ------------------ | Branch (534:9): [True: 0, False: 22] | Branch (534:30): [True: 0, False: 0] | Branch (534:68): [True: 0, False: 0] ------------------ 535| 0| --ss.length; 536| 0| ::memmove(ss.data, ss.data + 1, ss.length); 537| 0| ss.data[ss.length] = 0; 538| 0| } 539| | 540| | // find and convert all %xy special chars 541| 22| char *out = ss.data; 542| 549| for (const char *it = ss.data; it != ss.data + ss.length; /**/) { ------------------ | Branch (542:36): [True: 527, False: 22] ------------------ 543| 527| if (*it == '%' && (it + 3) < ss.data + ss.length) { ------------------ | Branch (543:13): [True: 5, False: 522] | Branch (543:27): [True: 5, False: 0] ------------------ 544| | // separate the number to avoid dragging in chars from behind into the parsing 545| 5| char mychar[3] = { it[1], it[2], 0 }; 546| 5| size_t nbr = strtoul16(mychar); 547| 5| it += 3; 548| 5| *out++ = static_cast(nbr & 0xFF); 549| 522| } else { 550| 522| *out++ = *it++; 551| 522| } 552| 527| } 553| | 554| | // adjust length and terminator of the shortened string 555| 22| *out = 0; 556| 22| ai_assert(out > ss.data); ------------------ | | 67| 22|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 22, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 557| 22| ss.length = static_cast(out - ss.data); 558| 22|} _ZN6Assimp13ColladaParser12ReadContentsERN4pugi8xml_nodeE: 562| 30|void ColladaParser::ReadContents(XmlNode &node) { 563| 30| if (const std::string name = node.name(); name == "COLLADA") { ------------------ | Branch (563:47): [True: 30, False: 0] ------------------ 564| 30| std::string version; 565| 30| if (XmlParser::getStdStrAttribute(node, "version", version)) { ------------------ | Branch (565:13): [True: 30, False: 0] ------------------ 566| 30| aiString v; 567| 30| v.Set(version); 568| 30| mAssetMetaData.emplace(AI_METADATA_SOURCE_FORMAT_VERSION, v); 569| 30| if (!::strncmp(version.c_str(), "1.5", 3)) { ------------------ | Branch (569:17): [True: 0, False: 30] ------------------ 570| 0| mFormat = FV_1_5_n; 571| 0| ASSIMP_LOG_DEBUG("Collada schema version is 1.5.n"); 572| 30| } else if (!::strncmp(version.c_str(), "1.4", 3)) { ------------------ | Branch (572:24): [True: 30, False: 0] ------------------ 573| 30| mFormat = FV_1_4_n; 574| 30| ASSIMP_LOG_DEBUG("Collada schema version is 1.4.n"); 575| 30| } else if (!::strncmp(version.c_str(), "1.3", 3)) { ------------------ | Branch (575:24): [True: 0, False: 0] ------------------ 576| 0| mFormat = FV_1_3_n; 577| | ASSIMP_LOG_DEBUG("Collada schema version is 1.3.n"); 578| 0| } 579| 30| } 580| 30| ReadStructure(node); 581| 30| } 582| 30|} _ZN6Assimp13ColladaParser13ReadStructureERN4pugi8xml_nodeE: 586| 30|void ColladaParser::ReadStructure(XmlNode &node) { 587| 194| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (587:31): [True: 194, False: 30] ------------------ 588| 194| if (const std::string ¤tName = currentNode.name(); currentName == "asset") { ------------------ | Branch (588:66): [True: 30, False: 164] ------------------ 589| 30| ReadAssetInfo(currentNode); 590| 164| } else if (currentName == "library_animations") { ------------------ | Branch (590:20): [True: 4, False: 160] ------------------ 591| 4| ReadAnimationLibrary(currentNode); 592| 160| } else if (currentName == "library_animation_clips") { ------------------ | Branch (592:20): [True: 2, False: 158] ------------------ 593| 2| ReadAnimationClipLibrary(currentNode); 594| 158| } else if (currentName == "library_controllers") { ------------------ | Branch (594:20): [True: 3, False: 155] ------------------ 595| 3| ReadControllerLibrary(currentNode); 596| 155| } else if (currentName == "library_images") { ------------------ | Branch (596:20): [True: 20, False: 135] ------------------ 597| 20| ReadImageLibrary(currentNode); 598| 135| } else if (currentName == "library_materials") { ------------------ | Branch (598:20): [True: 26, False: 109] ------------------ 599| 26| ReadMaterialLibrary(currentNode); 600| 109| } else if (currentName == "library_effects") { ------------------ | Branch (600:20): [True: 26, False: 83] ------------------ 601| 26| ReadEffectLibrary(currentNode); 602| 83| } else if (currentName == "library_geometries") { ------------------ | Branch (602:20): [True: 29, False: 54] ------------------ 603| 29| ReadGeometryLibrary(currentNode); 604| 54| } else if (currentName == "library_visual_scenes") { ------------------ | Branch (604:20): [True: 18, False: 36] ------------------ 605| 18| ReadSceneLibrary(currentNode); 606| 36| } else if (currentName == "library_lights") { ------------------ | Branch (606:20): [True: 10, False: 26] ------------------ 607| 10| ReadLightLibrary(currentNode); 608| 26| } else if (currentName == "library_cameras") { ------------------ | Branch (608:20): [True: 9, False: 17] ------------------ 609| 9| ReadCameraLibrary(currentNode); 610| 17| } else if (currentName == "library_nodes") { ------------------ | Branch (610:20): [True: 0, False: 17] ------------------ 611| 0| ReadSceneNode(currentNode, nullptr); /* some hacking to reuse this piece of code */ 612| 17| } else if (currentName == "scene") { ------------------ | Branch (612:20): [True: 17, False: 0] ------------------ 613| 17| ReadScene(currentNode); 614| 17| } 615| 194| } 616| | 617| 30| PostProcessRootAnimations(); 618| 30| PostProcessControllers(); 619| 30|} _ZN6Assimp13ColladaParser13ReadAssetInfoERN4pugi8xml_nodeE: 623| 30|void ColladaParser::ReadAssetInfo(XmlNode &node) { 624| 30| if (node.empty()) { ------------------ | Branch (624:9): [True: 0, False: 30] ------------------ 625| 0| return; 626| 0| } 627| | 628| 224| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (628:31): [True: 224, False: 30] ------------------ 629| 224| if (const std::string ¤tName = currentNode.name(); currentName == "unit") { ------------------ | Branch (629:66): [True: 30, False: 194] ------------------ 630| 30| mUnitSize = 1.f; 631| 30| std::string tUnitSizeString; 632| 30| if (XmlParser::getStdStrAttribute(currentNode, "meter", tUnitSizeString)) { ------------------ | Branch (632:17): [True: 28, False: 2] ------------------ 633| 28| try { 634| 28| fast_atoreal_move(tUnitSizeString.data(), mUnitSize); 635| 28| } catch (const DeadlyImportError& die) { 636| 0| std::string warning("Collada: Failed to parse meter parameter to real number. Exception:\n"); 637| 0| warning.append(die.what()); 638| 0| ASSIMP_LOG_WARN(warning.data()); 639| 0| } 640| 28| } 641| 194| } else if (currentName == "up_axis") { ------------------ | Branch (641:20): [True: 30, False: 164] ------------------ 642| 30| std::string v; 643| 30| if (!XmlParser::getValueAsString(currentNode, v)) { ------------------ | Branch (643:17): [True: 0, False: 30] ------------------ 644| 0| continue; 645| 0| } 646| 30| if (v == "X_UP") { ------------------ | Branch (646:17): [True: 0, False: 30] ------------------ 647| 0| mUpDirection = UP_X; 648| 30| } else if (v == "Z_UP") { ------------------ | Branch (648:24): [True: 19, False: 11] ------------------ 649| 19| mUpDirection = UP_Z; 650| 19| } else { 651| 11| mUpDirection = UP_Y; 652| 11| } 653| 164| } else if (currentName == "contributor") { ------------------ | Branch (653:20): [True: 30, False: 134] ------------------ 654| 98| for (XmlNode currentChildNode : currentNode.children()) { ------------------ | Branch (654:43): [True: 98, False: 30] ------------------ 655| 98| ReadMetaDataItem(currentChildNode, mAssetMetaData); 656| 98| } 657| 134| } else { 658| 134| ReadMetaDataItem(currentNode, mAssetMetaData); 659| 134| } 660| 224| } 661| 30|} _ZN6Assimp13ColladaParser24ReadAnimationClipLibraryERN4pugi8xml_nodeE: 665| 2|void ColladaParser::ReadAnimationClipLibrary(XmlNode &node) { 666| 2| if (node.empty()) { ------------------ | Branch (666:9): [True: 0, False: 2] ------------------ 667| 0| return; 668| 0| } 669| | 670| 2| std::string animName; 671| 2| if (!XmlParser::getStdStrAttribute(node, "name", animName)) { ------------------ | Branch (671:9): [True: 2, False: 0] ------------------ 672| 2| if (!XmlParser::getStdStrAttribute(node, "id", animName)) { ------------------ | Branch (672:13): [True: 2, False: 0] ------------------ 673| 2| animName = std::string("animation_") + ai_to_string(mAnimationClipLibrary.size()); 674| 2| } 675| 2| } 676| | 677| 2| std::pair> clip; 678| 2| clip.first = animName; 679| | 680| 4| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (680:31): [True: 4, False: 2] ------------------ 681| 4| const std::string ¤tName = currentNode.name(); 682| 4| if (currentName == "instance_animation") { ------------------ | Branch (682:13): [True: 0, False: 4] ------------------ 683| 0| std::string url; 684| 0| readUrlAttribute(currentNode, url); 685| 0| clip.second.push_back(url); 686| 0| } 687| | 688| 4| if (clip.second.size() > 0) { ------------------ | Branch (688:13): [True: 0, False: 4] ------------------ 689| 0| mAnimationClipLibrary.push_back(clip); 690| 0| } 691| 4| } 692| 2|} _ZN6Assimp13ColladaParser22PostProcessControllersEv: 696| 16|void ColladaParser::PostProcessControllers() { 697| 16| for (auto &it : mControllerLibrary) { ------------------ | Branch (697:19): [True: 1, False: 16] ------------------ 698| 1| std::string meshId = it.second.mMeshId; 699| 1| if (meshId.empty()) { ------------------ | Branch (699:13): [True: 0, False: 1] ------------------ 700| 0| continue; 701| 0| } 702| | 703| 1| auto findItr = mControllerLibrary.find(meshId); 704| 1| while (findItr != mControllerLibrary.end()) { ------------------ | Branch (704:16): [True: 0, False: 1] ------------------ 705| 0| meshId = findItr->second.mMeshId; 706| 0| findItr = mControllerLibrary.find(meshId); 707| 0| } 708| | 709| 1| it.second.mMeshId = meshId; 710| 1| } 711| 16|} _ZN6Assimp13ColladaParser25PostProcessRootAnimationsEv: 715| 16|void ColladaParser::PostProcessRootAnimations() { 716| 16| if (mAnimationClipLibrary.empty()) { ------------------ | Branch (716:9): [True: 16, False: 0] ------------------ 717| 16| mAnims.CombineSingleChannelAnimations(); 718| 16| return; 719| 16| } 720| | 721| 0| Animation temp; 722| 0| for (auto &it : mAnimationClipLibrary) { ------------------ | Branch (722:19): [True: 0, False: 0] ------------------ 723| 0| std::string clipName = it.first; 724| | 725| 0| auto *clip = new Animation(); 726| 0| clip->mName = clipName; 727| | 728| 0| temp.mSubAnims.push_back(clip); 729| | 730| 0| for (const std::string &animationID : it.second) { ------------------ | Branch (730:45): [True: 0, False: 0] ------------------ 731| 0| auto animation = mAnimationLibrary.find(animationID); 732| | 733| 0| if (animation != mAnimationLibrary.end()) { ------------------ | Branch (733:17): [True: 0, False: 0] ------------------ 734| 0| Animation *pSourceAnimation = animation->second; 735| 0| pSourceAnimation->CollectChannelsRecursively(clip->mChannels); 736| 0| } 737| 0| } 738| 0| } 739| | 740| 0| mAnims = temp; 741| | 742| | // Ensure no double deletes. 743| 0| temp.mSubAnims.clear(); 744| 0|} _ZN6Assimp13ColladaParser20ReadAnimationLibraryERN4pugi8xml_nodeE: 748| 4|void ColladaParser::ReadAnimationLibrary(XmlNode &node) { 749| 4| if (node.empty()) { ------------------ | Branch (749:9): [True: 0, False: 4] ------------------ 750| 0| return; 751| 0| } 752| | 753| 526| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (753:31): [True: 526, False: 4] ------------------ 754| 526| const std::string ¤tName = currentNode.name(); 755| 526| if (currentName == "animation") { ------------------ | Branch (755:13): [True: 526, False: 0] ------------------ 756| 526| ReadAnimation(currentNode, &mAnims); 757| 526| } 758| 526| } 759| 4|} _ZN6Assimp13ColladaParser13ReadAnimationERN4pugi8xml_nodeEPNS_7Collada9AnimationE: 763| 526|void ColladaParser::ReadAnimation(XmlNode &node, Collada::Animation *pParent) { 764| 526| if (node.empty()) { ------------------ | Branch (764:9): [True: 0, False: 526] ------------------ 765| 0| return; 766| 0| } 767| | 768| | // an element may be a container for grouping sub-elements or an animation channel 769| | // this is the channel collection by ID, in case it has channels 770| 526| using ChannelMap = std::map; 771| 526| ChannelMap channels; 772| | // this is the anim container in case we're a container 773| 526| Animation *anim = nullptr; 774| | 775| | // optional name given as an attribute 776| 526| std::string animName; 777| 526| if (!XmlParser::getStdStrAttribute(node, "name", animName)) { ------------------ | Branch (777:9): [True: 398, False: 128] ------------------ 778| 398| animName = "animation"; 779| 398| } 780| | 781| 526| std::string animID; 782| 526| pugi::xml_attribute idAttr = node.attribute("id"); 783| 526| if (idAttr) { ------------------ | Branch (783:9): [True: 142, False: 384] ------------------ 784| 142| animID = idAttr.as_string(); 785| 142| } 786| | 787| 1.98k| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (787:31): [True: 1.98k, False: 526] ------------------ 788| 1.98k| const std::string ¤tName = currentNode.name(); 789| 1.98k| if (currentName == "animation") { ------------------ | Branch (789:13): [True: 0, False: 1.98k] ------------------ 790| 0| if (!anim) { ------------------ | Branch (790:17): [True: 0, False: 0] ------------------ 791| 0| anim = new Animation; 792| 0| anim->mName = animName; 793| 0| pParent->mSubAnims.push_back(anim); 794| 0| } 795| | 796| | // recurse into the sub-element 797| 0| ReadAnimation(currentNode, anim); 798| 1.98k| } else if (currentName == "source") { ------------------ | Branch (798:20): [True: 1.19k, False: 794] ------------------ 799| 1.19k| ReadSource(currentNode); 800| 1.19k| } else if (currentName == "sampler") { ------------------ | Branch (800:20): [True: 397, False: 397] ------------------ 801| 397| std::string id; 802| 397| if (XmlParser::getStdStrAttribute(currentNode, "id", id)) { ------------------ | Branch (802:17): [True: 397, False: 0] ------------------ 803| | // have it read into a channel 804| 397| auto newChannel = channels.insert(std::make_pair(id, AnimationChannel())).first; 805| 397| ReadAnimationSampler(currentNode, newChannel->second); 806| 397| } 807| 397| } else if (currentName == "channel") { ------------------ | Branch (807:20): [True: 397, False: 0] ------------------ 808| 397| std::string source_name, target; 809| 397| XmlParser::getStdStrAttribute(currentNode, "source", source_name); 810| 397| XmlParser::getStdStrAttribute(currentNode, "target", target); 811| 397| if (source_name[0] == '#') { ------------------ | Branch (811:17): [True: 397, False: 0] ------------------ 812| 397| source_name = source_name.substr(1, source_name.size() - 1); 813| 397| } 814| 397| auto cit = channels.find(source_name); 815| 397| if (cit != channels.end()) { ------------------ | Branch (815:17): [True: 397, False: 0] ------------------ 816| 397| cit->second.mTarget = target; 817| 397| } 818| 397| } 819| 1.98k| } 820| | 821| | // it turned out to have channels - add them 822| 526| if (!channels.empty()) { ------------------ | Branch (822:9): [True: 397, False: 129] ------------------ 823| 397| if (nullptr == anim) { ------------------ | Branch (823:13): [True: 397, False: 0] ------------------ 824| 397| anim = new Animation; 825| 397| anim->mName = animName; 826| 397| pParent->mSubAnims.push_back(anim); 827| 397| } 828| | 829| 397| for (const auto &channel : channels) { ------------------ | Branch (829:34): [True: 397, False: 397] ------------------ 830| 397| anim->mChannels.push_back(channel.second); 831| 397| } 832| | 833| 397| if (idAttr) { ------------------ | Branch (833:13): [True: 13, False: 384] ------------------ 834| 13| mAnimationLibrary[animID] = anim; 835| 13| } 836| 397| } 837| 526|} _ZN6Assimp13ColladaParser21ReadControllerLibraryERN4pugi8xml_nodeE: 841| 3|void ColladaParser::ReadControllerLibrary(XmlNode &node) { 842| 3| if (node.empty()) { ------------------ | Branch (842:9): [True: 0, False: 3] ------------------ 843| 0| return; 844| 0| } 845| | 846| 3| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (846:31): [True: 2, False: 3] ------------------ 847| 2| const std::string ¤tName = currentNode.name(); 848| 2| if (currentName != "controller") { ------------------ | Branch (848:13): [True: 0, False: 2] ------------------ 849| 0| continue; 850| 0| } 851| 2| if (std::string id; XmlParser::getStdStrAttribute(currentNode, "id", id)) { ------------------ | Branch (851:29): [True: 2, False: 0] ------------------ 852| 2| mControllerLibrary[id] = Controller(); 853| 2| ReadController(currentNode, mControllerLibrary[id]); 854| 2| } 855| 2| } 856| 3|} _ZN6Assimp13ColladaParser14ReadControllerERN4pugi8xml_nodeERNS_7Collada10ControllerE: 860| 2|void ColladaParser::ReadController(XmlNode &node, Collada::Controller &controller) { 861| | // initial values 862| 2| controller.mType = Skin; 863| 2| controller.mMethod = Normalized; 864| | 865| 2| XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); 866| 2| XmlNode currentNode; 867| 52| while (xmlIt.getNext(currentNode)) { ------------------ | Branch (867:12): [True: 50, False: 2] ------------------ 868| 50| if (const std::string ¤tName = currentNode.name(); currentName == "morph") { ------------------ | Branch (868:66): [True: 0, False: 50] ------------------ 869| 0| controller.mType = Morph; 870| 0| std::string id = currentNode.attribute("source").as_string(); 871| 0| controller.mMeshId = id.substr(1, id.size() - 1); 872| 0| if (const int methodIndex = currentNode.attribute("method").as_int(); methodIndex > 0) { ------------------ | Branch (872:83): [True: 0, False: 0] ------------------ 873| 0| std::string method; 874| 0| XmlParser::getValueAsString(currentNode, method); 875| | 876| 0| if (method == "RELATIVE") { ------------------ | Branch (876:21): [True: 0, False: 0] ------------------ 877| 0| controller.mMethod = Relative; 878| 0| } 879| 0| } 880| 50| } else if (currentName == "skin") { ------------------ | Branch (880:20): [True: 2, False: 48] ------------------ 881| 2| if (std::string id; XmlParser::getStdStrAttribute(currentNode, "source", id)) { ------------------ | Branch (881:33): [True: 2, False: 0] ------------------ 882| 2| controller.mMeshId = id.substr(1, id.size() - 1); 883| 2| } 884| 48| } else if (currentName == "bind_shape_matrix") { ------------------ | Branch (884:20): [True: 2, False: 46] ------------------ 885| 2| std::string v; 886| 2| XmlParser::getValueAsString(currentNode, v); 887| 2| const char *content = v.c_str(); 888| 2| const char *end = content + v.size(); 889| 32| for (auto & a : controller.mBindShapeMatrix) { ------------------ | Branch (889:27): [True: 32, False: 2] ------------------ 890| 32| SkipSpacesAndLineEnd(&content, end); 891| | // read a number 892| 32| content = fast_atoreal_move(content, a); 893| | // skip whitespace after it 894| 32| SkipSpacesAndLineEnd(&content, end); 895| 32| } 896| 46| } else if (currentName == "source") { ------------------ | Branch (896:20): [True: 6, False: 40] ------------------ 897| 6| ReadSource(currentNode); 898| 40| } else if (currentName == "joints") { ------------------ | Branch (898:20): [True: 2, False: 38] ------------------ 899| 2| ReadControllerJoints(currentNode, controller); 900| 38| } else if (currentName == "vertex_weights") { ------------------ | Branch (900:20): [True: 2, False: 36] ------------------ 901| 2| ReadControllerWeights(currentNode, controller); 902| 36| } else if (currentName == "targets") { ------------------ | Branch (902:20): [True: 0, False: 36] ------------------ 903| 0| for (XmlNode currentChildNode = node.first_child(); currentNode; currentNode = currentNode.next_sibling()) { ------------------ | Branch (903:65): [True: 0, False: 0] ------------------ 904| 0| const std::string ¤tChildName = currentChildNode.name(); 905| 0| if (currentChildName == "input") { ------------------ | Branch (905:21): [True: 0, False: 0] ------------------ 906| 0| const char *semantics = currentChildNode.attribute("semantic").as_string(); 907| 0| const char *source = currentChildNode.attribute("source").as_string(); 908| 0| if (strcmp(semantics, "MORPH_TARGET") == 0) { ------------------ | Branch (908:25): [True: 0, False: 0] ------------------ 909| 0| controller.mMorphTarget = source + 1; 910| 0| } else if (strcmp(semantics, "MORPH_WEIGHT") == 0) { ------------------ | Branch (910:32): [True: 0, False: 0] ------------------ 911| 0| controller.mMorphWeight = source + 1; 912| 0| } 913| 0| } 914| 0| } 915| 0| } 916| 50| } 917| 2|} _ZN6Assimp13ColladaParser16ReadImageLibraryERKN4pugi8xml_nodeE: 921| 20|void ColladaParser::ReadImageLibrary(const XmlNode &node) { 922| 20| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (922:31): [True: 18, False: 20] ------------------ 923| 18| const std::string ¤tName = currentNode.name(); 924| 18| if (currentName == "image") { ------------------ | Branch (924:13): [True: 18, False: 0] ------------------ 925| 18| if (std::basic_string id; XmlParser::getStdStrAttribute(currentNode, "id", id)) { ------------------ | Branch (925:45): [True: 18, False: 0] ------------------ 926| 18| mImageLibrary[id] = Image(); 927| | // read on from there 928| 18| ReadImage(currentNode, mImageLibrary[id]); 929| 18| } 930| 18| } 931| 18| } 932| 20|} _ZNK6Assimp13ColladaParser9ReadImageERKN4pugi8xml_nodeERNS_7Collada5ImageE: 936| 18|void ColladaParser::ReadImage(const XmlNode &node, Collada::Image &pImage) const { 937| 18| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (937:31): [True: 18, False: 18] ------------------ 938| 18| const std::string currentName = currentNode.name(); 939| 18| if (currentName == "image") { ------------------ | Branch (939:13): [True: 0, False: 18] ------------------ 940| | // Ignore 941| 0| continue; 942| 18| } else if (currentName == "init_from") { ------------------ | Branch (942:20): [True: 18, False: 0] ------------------ 943| 18| if (mFormat == FV_1_4_n) { ------------------ | Branch (943:17): [True: 18, False: 0] ------------------ 944| | // FIX: C4D exporter writes empty tags 945| 18| if (!currentNode.empty()) { ------------------ | Branch (945:21): [True: 18, False: 0] ------------------ 946| | // element content is filename - hopefully 947| 18| const char *sz = currentNode.text().as_string(); 948| 18| if (nullptr != sz) { ------------------ | Branch (948:25): [True: 18, False: 0] ------------------ 949| 18| aiString filepath(sz); 950| 18| UriDecodePath(filepath); 951| 18| pImage.mFileName = filepath.C_Str(); 952| 18| } 953| 18| } 954| 18| if (!pImage.mFileName.length()) { ------------------ | Branch (954:21): [True: 0, False: 18] ------------------ 955| 0| pImage.mFileName = "unknown_texture"; 956| 0| } 957| 18| } else if (mFormat == FV_1_5_n) { ------------------ | Branch (957:24): [True: 0, False: 0] ------------------ 958| 0| std::string value; 959| 0| XmlNode refChild = currentNode.child("ref"); 960| 0| XmlNode hexChild = currentNode.child("hex"); 961| 0| if (refChild) { ------------------ | Branch (961:21): [True: 0, False: 0] ------------------ 962| | // element content is filename - hopefully 963| 0| if (XmlParser::getValueAsString(refChild, value)) { ------------------ | Branch (963:25): [True: 0, False: 0] ------------------ 964| 0| aiString filepath(value); 965| 0| UriDecodePath(filepath); 966| 0| pImage.mFileName = filepath.C_Str(); 967| 0| } 968| 0| } else if (hexChild && !pImage.mFileName.length()) { ------------------ | Branch (968:28): [True: 0, False: 0] | Branch (968:40): [True: 0, False: 0] ------------------ 969| | // embedded image. get format 970| 0| pImage.mEmbeddedFormat = hexChild.attribute("format").as_string(); 971| 0| if (pImage.mEmbeddedFormat.empty()) { ------------------ | Branch (971:25): [True: 0, False: 0] ------------------ 972| 0| ASSIMP_LOG_WARN("Collada: Unknown image file format"); 973| 0| } 974| | 975| 0| XmlParser::getValueAsString(hexChild, value); 976| 0| const char *data = value.c_str(); 977| | // hexadecimal-encoded binary octets. First of all, find the 978| | // required buffer size to reserve enough storage. 979| 0| const char *cur = data; 980| 0| while (!IsSpaceOrNewLine(*cur)) { ------------------ | Branch (980:28): [True: 0, False: 0] ------------------ 981| 0| ++cur; 982| 0| } 983| | 984| 0| const unsigned int size = (unsigned int)(cur - data) * 2; 985| 0| pImage.mImageData.resize(size); 986| 0| for (unsigned int i = 0; i < size; ++i) { ------------------ | Branch (986:46): [True: 0, False: 0] ------------------ 987| 0| pImage.mImageData[i] = HexOctetToDecimal(data + (i << 1)); 988| 0| } 989| 0| } 990| 0| } 991| 18| } 992| 18| } 993| 18|} _ZN6Assimp13ColladaParser19ReadMaterialLibraryERN4pugi8xml_nodeE: 997| 26|void ColladaParser::ReadMaterialLibrary(XmlNode &node) { 998| 26| std::map names; 999| 36| for (const XmlNode ¤tNode : node.children()) { ------------------ | Branch (999:37): [True: 36, False: 26] ------------------ 1000| 36| std::string id = currentNode.attribute("id").as_string(); 1001| 36| std::string name = currentNode.attribute("name").as_string(); 1002| 36| mMaterialLibrary[id] = Material(); 1003| | 1004| 36| if (!name.empty()) { ------------------ | Branch (1004:13): [True: 36, False: 0] ------------------ 1005| 36| auto it = names.find(name); 1006| 36| if (it != names.end()) { ------------------ | Branch (1006:17): [True: 0, False: 36] ------------------ 1007| 0| std::ostringstream strStream; 1008| 0| strStream << ++it->second; 1009| 0| name.append(" " + strStream.str()); 1010| 36| } else { 1011| 36| names[name] = 0; 1012| 36| } 1013| | 1014| 36| mMaterialLibrary[id].mName = name; 1015| 36| } 1016| | 1017| 36| ReadMaterial(currentNode, mMaterialLibrary[id]); 1018| 36| } 1019| 26|} _ZN6Assimp13ColladaParser16ReadLightLibraryERN4pugi8xml_nodeE: 1023| 10|void ColladaParser::ReadLightLibrary(XmlNode &node) { 1024| 15| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (1024:31): [True: 15, False: 10] ------------------ 1025| 15| const std::string ¤tName = currentNode.name(); 1026| 15| if (currentName == "light") { ------------------ | Branch (1026:13): [True: 15, False: 0] ------------------ 1027| 15| std::string id; 1028| 15| if (XmlParser::getStdStrAttribute(currentNode, "id", id)) { ------------------ | Branch (1028:17): [True: 15, False: 0] ------------------ 1029| 15| ReadLight(currentNode, mLightLibrary[id] = Light()); 1030| 15| } 1031| 15| } 1032| 15| } 1033| 10|} _ZN6Assimp13ColladaParser17ReadCameraLibraryERN4pugi8xml_nodeE: 1037| 9|void ColladaParser::ReadCameraLibrary(XmlNode &node) { 1038| 10| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (1038:31): [True: 10, False: 9] ------------------ 1039| 10| const std::string ¤tName = currentNode.name(); 1040| 10| if (currentName == "camera") { ------------------ | Branch (1040:13): [True: 10, False: 0] ------------------ 1041| 10| std::string id; 1042| 10| if (!XmlParser::getStdStrAttribute(currentNode, "id", id)) { ------------------ | Branch (1042:17): [True: 0, False: 10] ------------------ 1043| 0| continue; 1044| 0| } 1045| | 1046| | // create an entry and store it in the library under its ID 1047| 10| Camera &cam = mCameraLibrary[id]; 1048| 10| std::string name; 1049| 10| if (!XmlParser::getStdStrAttribute(currentNode, "name", name)) { ------------------ | Branch (1049:17): [True: 0, False: 10] ------------------ 1050| 0| continue; 1051| 0| } 1052| 10| if (!name.empty()) { ------------------ | Branch (1052:17): [True: 10, False: 0] ------------------ 1053| 10| cam.mName = name; 1054| 10| } 1055| 10| ReadCamera(currentNode, cam); 1056| 10| } 1057| 10| } 1058| 9|} _ZN6Assimp13ColladaParser17ReadEffectLibraryERN4pugi8xml_nodeE: 1062| 26|void ColladaParser::ReadEffectLibrary(XmlNode &node) { 1063| 26| if (node.empty()) { ------------------ | Branch (1063:9): [True: 0, False: 26] ------------------ 1064| 0| return; 1065| 0| } 1066| | 1067| 36| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (1067:31): [True: 36, False: 26] ------------------ 1068| 36| const std::string ¤tName = currentNode.name(); 1069| 36| if (currentName == "effect") { ------------------ | Branch (1069:13): [True: 36, False: 0] ------------------ 1070| | // read ID. Do I have to repeat my ranting about "optional" attributes? 1071| 36| std::string id; 1072| 36| XmlParser::getStdStrAttribute(currentNode, "id", id); 1073| | 1074| | // create an entry and store it in the library under its ID 1075| 36| mEffectLibrary[id] = Effect(); 1076| | 1077| | // read on from there 1078| 36| ReadEffect(currentNode, mEffectLibrary[id]); 1079| 36| } 1080| 36| } 1081| 26|} _ZN6Assimp13ColladaParser10ReadEffectERN4pugi8xml_nodeERNS_7Collada6EffectE: 1085| 36|void ColladaParser::ReadEffect(XmlNode &node, Collada::Effect &pEffect) { 1086| 36| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (1086:31): [True: 36, False: 36] ------------------ 1087| 36| const std::string ¤tName = currentNode.name(); 1088| 36| if (currentName == "profile_COMMON") { ------------------ | Branch (1088:13): [True: 36, False: 0] ------------------ 1089| 36| ReadEffectProfileCommon(currentNode, pEffect); 1090| 36| } 1091| 36| } 1092| 36|} _ZN6Assimp13ColladaParser23ReadEffectProfileCommonERN4pugi8xml_nodeERNS_7Collada6EffectE: 1096| 36|void ColladaParser::ReadEffectProfileCommon(XmlNode &node, Collada::Effect &pEffect) { 1097| 36| XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); 1098| 36| XmlNode currentNode; 1099| 841| while (xmlIt.getNext(currentNode)) { ------------------ | Branch (1099:12): [True: 805, False: 36] ------------------ 1100| 805| const std::string currentName = currentNode.name(); 1101| 805| if (currentName == "newparam") { ------------------ | Branch (1101:13): [True: 20, False: 785] ------------------ 1102| | // save ID 1103| 20| std::string sid = currentNode.attribute("sid").as_string(); 1104| 20| pEffect.mParams[sid] = EffectParam(); 1105| 20| ReadEffectParam(currentNode, pEffect.mParams[sid]); 1106| 785| } else if (currentName == "technique" || currentName == "extra") { ------------------ | Branch (1106:20): [True: 48, False: 737] | Branch (1106:50): [True: 10, False: 727] ------------------ 1107| | // just syntactic sugar 1108| 727| } else if (mFormat == FV_1_4_n && currentName == "image") { ------------------ | Branch (1108:20): [True: 727, False: 0] | Branch (1108:43): [True: 0, False: 727] ------------------ 1109| | // read ID. Another entry which is "optional" by design but obligatory in reality 1110| 0| std::string id = currentNode.attribute("id").as_string(); 1111| | 1112| | // create an entry and store it in the library under its ID 1113| 0| mImageLibrary[id] = Image(); 1114| | 1115| | // read on from there 1116| 0| ReadImage(currentNode, mImageLibrary[id]); 1117| 727| } else if (currentName == "phong") ------------------ | Branch (1117:20): [True: 22, False: 705] ------------------ 1118| 22| pEffect.mShadeType = Shade_Phong; 1119| 705| else if (currentName == "constant") ------------------ | Branch (1119:18): [True: 0, False: 705] ------------------ 1120| 0| pEffect.mShadeType = Shade_Constant; 1121| 705| else if (currentName == "lambert") ------------------ | Branch (1121:18): [True: 6, False: 699] ------------------ 1122| 6| pEffect.mShadeType = Shade_Lambert; 1123| 699| else if (currentName == "blinn") ------------------ | Branch (1123:18): [True: 8, False: 691] ------------------ 1124| 8| pEffect.mShadeType = Shade_Blinn; 1125| | 1126| | /* Color + texture properties */ 1127| 691| else if (currentName == "emission") ------------------ | Branch (1127:18): [True: 47, False: 644] ------------------ 1128| 47| ReadEffectColor(currentNode, pEffect.mEmissive, pEffect.mTexEmissive); 1129| 644| else if (currentName == "ambient") ------------------ | Branch (1129:18): [True: 30, False: 614] ------------------ 1130| 30| ReadEffectColor(currentNode, pEffect.mAmbient, pEffect.mTexAmbient); 1131| 614| else if (currentName == "diffuse") ------------------ | Branch (1131:18): [True: 36, False: 578] ------------------ 1132| 36| ReadEffectColor(currentNode, pEffect.mDiffuse, pEffect.mTexDiffuse); 1133| 578| else if (currentName == "specular") ------------------ | Branch (1133:18): [True: 34, False: 544] ------------------ 1134| 34| ReadEffectColor(currentNode, pEffect.mSpecular, pEffect.mTexSpecular); 1135| 544| else if (currentName == "reflective") { ------------------ | Branch (1135:18): [True: 30, False: 514] ------------------ 1136| 30| ReadEffectColor(currentNode, pEffect.mReflective, pEffect.mTexReflective); 1137| 514| } else if (currentName == "transparent") { ------------------ | Branch (1137:20): [True: 28, False: 486] ------------------ 1138| 28| pEffect.mHasTransparency = true; 1139| 28| const char *opaque = currentNode.attribute("opaque").as_string(); 1140| | //const char *opaque = mReader->getAttributeValueSafe("opaque"); 1141| | 1142| 28| if (::strcmp(opaque, "RGB_ZERO") == 0 || ::strcmp(opaque, "RGB_ONE") == 0) { ------------------ | Branch (1142:17): [True: 0, False: 28] | Branch (1142:54): [True: 0, False: 28] ------------------ 1143| 0| pEffect.mRGBTransparency = true; 1144| 0| } 1145| | 1146| | // In RGB_ZERO mode, the transparency is interpreted in reverse, go figure... 1147| 28| if (::strcmp(opaque, "RGB_ZERO") == 0 || ::strcmp(opaque, "A_ZERO") == 0) { ------------------ | Branch (1147:17): [True: 0, False: 28] | Branch (1147:54): [True: 0, False: 28] ------------------ 1148| 0| pEffect.mInvertTransparency = true; 1149| 0| } 1150| | 1151| 28| ReadEffectColor(currentNode, pEffect.mTransparent, pEffect.mTexTransparent); 1152| 486| } else if (currentName == "shininess") ------------------ | Branch (1152:20): [True: 30, False: 456] ------------------ 1153| 30| ReadEffectFloat(currentNode, pEffect.mShininess); 1154| 456| else if (currentName == "reflectivity") ------------------ | Branch (1154:18): [True: 28, False: 428] ------------------ 1155| 28| ReadEffectFloat(currentNode, pEffect.mReflectivity); 1156| | 1157| | /* Single scalar properties */ 1158| 428| else if (currentName == "transparency") ------------------ | Branch (1158:18): [True: 28, False: 400] ------------------ 1159| 28| ReadEffectFloat(currentNode, pEffect.mTransparency); 1160| 400| else if (currentName == "index_of_refraction") ------------------ | Branch (1160:18): [True: 13, False: 387] ------------------ 1161| 13| ReadEffectFloat(currentNode, pEffect.mRefractIndex); 1162| | 1163| | // GOOGLEEARTH/OKINO extensions 1164| | // ------------------------------------------------------- 1165| 387| else if (currentName == "double_sided") ------------------ | Branch (1165:18): [True: 2, False: 385] ------------------ 1166| 2| XmlParser::getValueAsBool(currentNode, pEffect.mDoubleSided); 1167| | 1168| | // FCOLLADA extensions 1169| | // ------------------------------------------------------- 1170| 385| else if (currentName == "bump") { ------------------ | Branch (1170:18): [True: 0, False: 385] ------------------ 1171| 0| aiColor4D dummy; 1172| 0| ReadEffectColor(currentNode, dummy, pEffect.mTexBump); 1173| 0| } 1174| | 1175| | // MAX3D extensions 1176| | // ------------------------------------------------------- 1177| 385| else if (currentName == "wireframe") { ------------------ | Branch (1177:18): [True: 0, False: 385] ------------------ 1178| 0| XmlParser::getValueAsBool(currentNode, pEffect.mWireframe); 1179| 385| } else if (currentName == "faceted") { ------------------ | Branch (1179:20): [True: 0, False: 385] ------------------ 1180| 0| XmlParser::getValueAsBool(currentNode, pEffect.mFaceted); 1181| 0| } 1182| 805| } 1183| 36|} _ZN6Assimp13ColladaParser21ReadSamplerPropertiesERN4pugi8xml_nodeERNS_7Collada7SamplerE: 1187| 8|void ColladaParser::ReadSamplerProperties(XmlNode &node, Sampler &out) { 1188| 8| if (node.empty()) { ------------------ | Branch (1188:9): [True: 0, False: 8] ------------------ 1189| 0| return; 1190| 0| } 1191| | 1192| 8| XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); 1193| 8| XmlNode currentNode; 1194| 32| while (xmlIt.getNext(currentNode)) { ------------------ | Branch (1194:12): [True: 24, False: 8] ------------------ 1195| 24| const std::string ¤tName = currentNode.name(); 1196| | // MAYA extensions 1197| | // ------------------------------------------------------- 1198| 24| if (currentName == "wrapU") { ------------------ | Branch (1198:13): [True: 8, False: 16] ------------------ 1199| 8| XmlParser::getValueAsBool(currentNode, out.mWrapU); 1200| 16| } else if (currentName == "wrapV") { ------------------ | Branch (1200:20): [True: 8, False: 8] ------------------ 1201| 8| XmlParser::getValueAsBool(currentNode, out.mWrapV); 1202| 8| } else if (currentName == "mirrorU") { ------------------ | Branch (1202:20): [True: 0, False: 8] ------------------ 1203| 0| XmlParser::getValueAsBool(currentNode, out.mMirrorU); 1204| 8| } else if (currentName == "mirrorV") { ------------------ | Branch (1204:20): [True: 0, False: 8] ------------------ 1205| 0| XmlParser::getValueAsBool(currentNode, out.mMirrorV); 1206| 8| } else if (currentName == "repeatU") { ------------------ | Branch (1206:20): [True: 0, False: 8] ------------------ 1207| 0| XmlParser::getValueAsReal(currentNode, out.mTransform.mScaling.x); 1208| 8| } else if (currentName == "repeatV") { ------------------ | Branch (1208:20): [True: 0, False: 8] ------------------ 1209| 0| XmlParser::getValueAsReal(currentNode, out.mTransform.mScaling.y); 1210| 8| } else if (currentName == "offsetU") { ------------------ | Branch (1210:20): [True: 0, False: 8] ------------------ 1211| 0| XmlParser::getValueAsReal(currentNode, out.mTransform.mTranslation.x); 1212| 8| } else if (currentName == "offsetV") { ------------------ | Branch (1212:20): [True: 0, False: 8] ------------------ 1213| 0| XmlParser::getValueAsReal(currentNode, out.mTransform.mTranslation.y); 1214| 8| } else if (currentName == "rotateUV") { ------------------ | Branch (1214:20): [True: 0, False: 8] ------------------ 1215| 0| XmlParser::getValueAsReal(currentNode, out.mTransform.mRotation); 1216| 8| } else if (currentName == "blend_mode") { ------------------ | Branch (1216:20): [True: 8, False: 0] ------------------ 1217| 8| std::string v; 1218| 8| XmlParser::getValueAsString(currentNode, v); 1219| 8| const char *sz = v.c_str(); 1220| | // http://www.feelingsoftware.com/content/view/55/72/lang,en/ 1221| | // NONE, OVER, IN, OUT, ADD, SUBTRACT, MULTIPLY, DIFFERENCE, LIGHTEN, DARKEN, SATURATE, DESATURATE and ILLUMINATE 1222| 8| if (0 == ASSIMP_strincmp(sz, "ADD", 3)) ------------------ | Branch (1222:17): [True: 8, False: 0] ------------------ 1223| 8| out.mOp = aiTextureOp_Add; 1224| 0| else if (0 == ASSIMP_strincmp(sz, "SUBTRACT", 8)) ------------------ | Branch (1224:22): [True: 0, False: 0] ------------------ 1225| 0| out.mOp = aiTextureOp_Subtract; 1226| 0| else if (0 == ASSIMP_strincmp(sz, "MULTIPLY", 8)) ------------------ | Branch (1226:22): [True: 0, False: 0] ------------------ 1227| 0| out.mOp = aiTextureOp_Multiply; 1228| 0| else { 1229| 0| ASSIMP_LOG_WARN("Collada: Unsupported MAYA texture blend mode"); 1230| 0| } 1231| 8| } 1232| | // OKINO extensions 1233| | // ------------------------------------------------------- 1234| 0| else if (currentName == "weighting") { ------------------ | Branch (1234:18): [True: 0, False: 0] ------------------ 1235| 0| XmlParser::getValueAsReal(currentNode, out.mWeighting); 1236| 0| } else if (currentName == "mix_with_previous_layer") { ------------------ | Branch (1236:20): [True: 0, False: 0] ------------------ 1237| 0| XmlParser::getValueAsReal(currentNode, out.mMixWithPrevious); 1238| 0| } 1239| | // MAX3D extensions 1240| | // ------------------------------------------------------- 1241| 0| else if (currentName == "amount") { ------------------ | Branch (1241:18): [True: 0, False: 0] ------------------ 1242| 0| XmlParser::getValueAsReal(currentNode, out.mWeighting); 1243| 0| } 1244| 24| } 1245| 8|} _ZN6Assimp13ColladaParser15ReadEffectColorERN4pugi8xml_nodeER9aiColor4tIfERNS_7Collada7SamplerE: 1249| 205|void ColladaParser::ReadEffectColor(XmlNode &node, aiColor4D &pColor, Sampler &pSampler) { 1250| 205| if (node.empty()) { ------------------ | Branch (1250:9): [True: 0, False: 205] ------------------ 1251| 0| return; 1252| 0| } 1253| | 1254| 205| XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); 1255| 205| XmlNode currentNode; 1256| 517| while (xmlIt.getNext(currentNode)) { ------------------ | Branch (1256:12): [True: 312, False: 205] ------------------ 1257| 312| const std::string ¤tName = currentNode.name(); 1258| 312| if (currentName == "color") { ------------------ | Branch (1258:13): [True: 197, False: 115] ------------------ 1259| | // text content contains 4 floats 1260| 197| std::string v; 1261| 197| XmlParser::getValueAsString(currentNode, v); 1262| 197| const char *content = v.c_str(); 1263| 197| const char *end = v.c_str() + v.size() + 1; 1264| | 1265| 197| content = fast_atoreal_move(content, pColor.r); 1266| 197| SkipSpacesAndLineEnd(&content, end); 1267| | 1268| 197| content = fast_atoreal_move(content, pColor.g); 1269| 197| SkipSpacesAndLineEnd(&content, end); 1270| | 1271| 197| content = fast_atoreal_move(content, pColor.b); 1272| 197| SkipSpacesAndLineEnd(&content, end); 1273| | 1274| 197| content = fast_atoreal_move(content, pColor.a); 1275| 197| SkipSpacesAndLineEnd(&content, end); 1276| 197| } else if (currentName == "texture") { ------------------ | Branch (1276:20): [True: 18, False: 97] ------------------ 1277| | // get name of source texture/sampler 1278| 18| XmlParser::getStdStrAttribute(currentNode, "texture", pSampler.mName); 1279| | 1280| | // get name of UV source channel. Specification demands it to be there, but some exporters 1281| | // don't write it. It will be the default UV channel in case it's missing. 1282| 18| XmlParser::getStdStrAttribute(currentNode, "texcoord", pSampler.mUVChannel); 1283| | 1284| | // as we've read texture, the color needs to be 1,1,1,1 1285| 18| pColor = aiColor4D(1.f, 1.f, 1.f, 1.f); 1286| 97| } else if (currentName == "technique") { ------------------ | Branch (1286:20): [True: 8, False: 89] ------------------ 1287| 8| std::string profile; 1288| 8| XmlParser::getStdStrAttribute(currentNode, "profile", profile); 1289| | 1290| | // Some extensions are quite useful ... ReadSamplerProperties processes 1291| | // several extensions in MAYA, OKINO and MAX3D profiles. 1292| 8| if (!::strcmp(profile.c_str(), "MAYA") || !::strcmp(profile.c_str(), "MAX3D") || !::strcmp(profile.c_str(), "OKINO")) { ------------------ | Branch (1292:17): [True: 8, False: 0] | Branch (1292:55): [True: 0, False: 0] | Branch (1292:94): [True: 0, False: 0] ------------------ 1293| | // get more information on this sampler 1294| 8| ReadSamplerProperties(currentNode, pSampler); 1295| 8| } 1296| 8| } 1297| 312| } 1298| 205|} _ZN6Assimp13ColladaParser15ReadEffectFloatERN4pugi8xml_nodeERf: 1302| 99|void ColladaParser::ReadEffectFloat(XmlNode &node, ai_real &pReal) { 1303| 99| pReal = 0.f; 1304| 99| XmlNode floatNode = node.child("float"); 1305| 99| if (floatNode.empty()) { ------------------ | Branch (1305:9): [True: 0, False: 99] ------------------ 1306| 0| return; 1307| 0| } 1308| 99| XmlParser::getValueAsReal(floatNode, pReal); 1309| 99|} _ZN6Assimp13ColladaParser15ReadEffectParamERN4pugi8xml_nodeERNS_7Collada11EffectParamE: 1313| 20|void ColladaParser::ReadEffectParam(XmlNode &node, Collada::EffectParam &pParam) { 1314| 20| if (node.empty()) { ------------------ | Branch (1314:9): [True: 0, False: 20] ------------------ 1315| 0| return; 1316| 0| } 1317| | 1318| 20| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (1318:31): [True: 20, False: 20] ------------------ 1319| 20| const std::string ¤tName = currentNode.name(); 1320| 20| if (currentName == "surface") { ------------------ | Branch (1320:13): [True: 10, False: 10] ------------------ 1321| | // image ID given inside tags 1322| 10| XmlNode initNode = currentNode.child("init_from"); 1323| 10| if (initNode) { ------------------ | Branch (1323:17): [True: 10, False: 0] ------------------ 1324| 10| std::string v; 1325| 10| XmlParser::getValueAsString(initNode, v); 1326| 10| pParam.mType = Param_Surface; 1327| 10| pParam.mReference = v.c_str(); 1328| 10| } 1329| 10| } else if (currentName == "sampler2D" && (FV_1_4_n == mFormat || FV_1_3_n == mFormat)) { ------------------ | Branch (1329:20): [True: 10, False: 0] | Branch (1329:51): [True: 10, False: 0] | Branch (1329:74): [True: 0, False: 0] ------------------ 1330| | // surface ID is given inside tags 1331| 10| XmlNode source = currentNode.child("source"); 1332| 10| if (source) { ------------------ | Branch (1332:17): [True: 10, False: 0] ------------------ 1333| 10| std::string v; 1334| 10| XmlParser::getValueAsString(source, v); 1335| 10| pParam.mType = Param_Sampler; 1336| 10| pParam.mReference = v.c_str(); 1337| 10| } 1338| 10| } else if (currentName == "sampler2D") { ------------------ | Branch (1338:20): [True: 0, False: 0] ------------------ 1339| | // surface ID is given inside tags 1340| 0| XmlNode instance_image = currentNode.child("instance_image"); 1341| 0| if (instance_image) { ------------------ | Branch (1341:17): [True: 0, False: 0] ------------------ 1342| 0| std::string url; 1343| 0| XmlParser::getStdStrAttribute(instance_image, "url", url); 1344| 0| if (url[0] != '#') { ------------------ | Branch (1344:21): [True: 0, False: 0] ------------------ 1345| 0| throw DeadlyImportError("Unsupported URL format in instance_image"); 1346| 0| } 1347| 0| pParam.mType = Param_Sampler; 1348| 0| pParam.mReference = url.c_str() + 1; 1349| 0| } 1350| 0| } 1351| 20| } 1352| 20|} _ZN6Assimp13ColladaParser19ReadGeometryLibraryERN4pugi8xml_nodeE: 1356| 29|void ColladaParser::ReadGeometryLibrary(XmlNode &node) { 1357| 29| if (node.empty()) { ------------------ | Branch (1357:9): [True: 0, False: 29] ------------------ 1358| 0| return; 1359| 0| } 1360| 165| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (1360:31): [True: 165, False: 29] ------------------ 1361| 165| const std::string ¤tName = currentNode.name(); 1362| 165| if (currentName == "geometry") { ------------------ | Branch (1362:13): [True: 165, False: 0] ------------------ 1363| | // read ID. Another entry which is "optional" by design but obligatory in reality 1364| | 1365| 165| std::string id; 1366| 165| XmlParser::getStdStrAttribute(currentNode, "id", id); 1367| | // create a mesh and store it in the library under its (resolved) ID 1368| | // Skip and warn if ID is not unique 1369| 165| if (mMeshLibrary.find(id) == mMeshLibrary.cend()) { ------------------ | Branch (1369:17): [True: 165, False: 0] ------------------ 1370| 165| std::unique_ptr mesh(new Mesh(id)); 1371| | 1372| 165| XmlParser::getStdStrAttribute(currentNode, "name", mesh->mName); 1373| | 1374| | // read on from there 1375| 165| ReadGeometry(currentNode, *mesh); 1376| | // Read successfully, add to library 1377| 165| mMeshLibrary.insert({ id, mesh.release() }); 1378| 165| } 1379| 165| } 1380| 165| } 1381| 29|} _ZN6Assimp13ColladaParser12ReadGeometryERN4pugi8xml_nodeERNS_7Collada4MeshE: 1385| 165|void ColladaParser::ReadGeometry(XmlNode &node, Collada::Mesh &pMesh) { 1386| 165| if (node.empty()) { ------------------ | Branch (1386:9): [True: 0, False: 165] ------------------ 1387| 0| return; 1388| 0| } 1389| | 1390| 165| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (1390:31): [True: 165, False: 165] ------------------ 1391| 165| const std::string ¤tName = currentNode.name(); 1392| 165| if (currentName == "mesh") { ------------------ | Branch (1392:13): [True: 165, False: 0] ------------------ 1393| 165| ReadMesh(currentNode, pMesh); 1394| 165| } 1395| 165| } 1396| 165|} _ZN6Assimp13ColladaParser8ReadMeshERN4pugi8xml_nodeERNS_7Collada4MeshE: 1400| 165|void ColladaParser::ReadMesh(XmlNode &node, Mesh &pMesh) { 1401| 165| if (node.empty()) { ------------------ | Branch (1401:9): [True: 0, False: 165] ------------------ 1402| 0| return; 1403| 0| } 1404| | 1405| 165| XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); 1406| 165| XmlNode currentNode; 1407| 12.4k| while (xmlIt.getNext(currentNode)) { ------------------ | Branch (1407:12): [True: 12.2k, False: 165] ------------------ 1408| 12.2k| const std::string ¤tName = currentNode.name(); 1409| 12.2k| if (currentName == "source") { ------------------ | Branch (1409:13): [True: 486, False: 11.7k] ------------------ 1410| 486| ReadSource(currentNode); 1411| 11.7k| } else if (currentName == "vertices") { ------------------ | Branch (1411:20): [True: 159, False: 11.6k] ------------------ 1412| 159| ReadVertexData(currentNode, pMesh); 1413| 11.6k| } else if (currentName == "triangles" || currentName == "lines" || currentName == "linestrips" || ------------------ | Branch (1413:20): [True: 14, False: 11.6k] | Branch (1413:50): [True: 0, False: 11.6k] | Branch (1413:76): [True: 0, False: 11.6k] ------------------ 1414| 11.6k| currentName == "polygons" || currentName == "polylist" || currentName == "trifans" || ------------------ | Branch (1414:20): [True: 11, False: 11.6k] | Branch (1414:49): [True: 138, False: 11.4k] | Branch (1414:78): [True: 0, False: 11.4k] ------------------ 1415| 11.4k| currentName == "tristrips") { ------------------ | Branch (1415:20): [True: 0, False: 11.4k] ------------------ 1416| 163| ReadIndexData(currentNode, pMesh); 1417| 163| } 1418| 12.2k| } 1419| 165|} _ZN6Assimp13ColladaParser10ReadSourceERN4pugi8xml_nodeE: 1423| 1.68k|void ColladaParser::ReadSource(XmlNode &node) { 1424| 1.68k| if (node.empty()) { ------------------ | Branch (1424:9): [True: 0, False: 1.68k] ------------------ 1425| 0| return; 1426| 0| } 1427| | 1428| 1.68k| std::string sourceID; 1429| 1.68k| XmlParser::getStdStrAttribute(node, "id", sourceID); 1430| 1.68k| XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); 1431| 1.68k| XmlNode currentNode; 1432| 9.21k| while (xmlIt.getNext(currentNode)) { ------------------ | Branch (1432:12): [True: 7.52k, False: 1.68k] ------------------ 1433| 7.52k| const std::string ¤tName = currentNode.name(); 1434| 7.52k| if (currentName == "float_array" || currentName == "IDREF_array" || currentName == "Name_array") { ------------------ | Branch (1434:13): [True: 1.28k, False: 6.24k] | Branch (1434:45): [True: 0, False: 6.24k] | Branch (1434:77): [True: 399, False: 5.84k] ------------------ 1435| 1.68k| ReadDataArray(currentNode); 1436| 5.84k| } else if (currentName == "technique_common") { ------------------ | Branch (1436:20): [True: 1.67k, False: 4.16k] ------------------ 1437| 1.67k| XmlNode technique = currentNode.child("accessor"); 1438| 1.67k| if (!technique.empty()) { ------------------ | Branch (1438:17): [True: 1.67k, False: 0] ------------------ 1439| 1.67k| ReadAccessor(technique, sourceID); 1440| 1.67k| } 1441| 1.67k| } 1442| 7.52k| } 1443| 1.68k|} _ZN6Assimp13ColladaParser13ReadDataArrayERN4pugi8xml_nodeE: 1447| 1.68k|void ColladaParser::ReadDataArray(XmlNode &node) { 1448| 1.68k| std::string name = node.name(); 1449| 1.68k| bool isStringArray = (name == "IDREF_array" || name == "Name_array"); ------------------ | Branch (1449:27): [True: 0, False: 1.68k] | Branch (1449:52): [True: 399, False: 1.28k] ------------------ 1450| | 1451| | // read attributes 1452| 1.68k| std::string id; 1453| 1.68k| XmlParser::getStdStrAttribute(node, "id", id); 1454| 1.68k| unsigned int count = 0; 1455| 1.68k| XmlParser::getUIntAttribute(node, "count", count); 1456| 1.68k| std::string v; 1457| 1.68k| XmlParser::getValueAsString(node, v); 1458| 1.68k| v = ai_trim(v); 1459| 1.68k| const char *content = v.c_str(); 1460| 1.68k| const char *end = content + v.size(); 1461| | 1462| | // read values and store inside an array in the data library 1463| 1.68k| mDataLibrary[id] = Data(); 1464| 1.68k| Data &data = mDataLibrary[id]; 1465| 1.68k| data.mIsStringArray = isStringArray; 1466| | 1467| | // some exporters write empty data arrays, but we need to conserve them anyways because others might reference them 1468| 1.68k| if (content) { ------------------ | Branch (1468:9): [True: 1.68k, False: 0] ------------------ 1469| 1.68k| if (isStringArray) { ------------------ | Branch (1469:13): [True: 399, False: 1.28k] ------------------ 1470| 399| data.mStrings.reserve(count); 1471| 399| std::string s; 1472| | 1473| 1.40k| for (unsigned int a = 0; a < count; a++) { ------------------ | Branch (1473:38): [True: 1.00k, False: 399] ------------------ 1474| 1.00k| if (*content == 0) { ------------------ | Branch (1474:21): [True: 0, False: 1.00k] ------------------ 1475| 0| throw DeadlyImportError("Expected more values while reading IDREF_array contents."); 1476| 0| } 1477| | 1478| 1.00k| s.clear(); 1479| 7.16k| while (!IsSpaceOrNewLine(*content)) { ------------------ | Branch (1479:24): [True: 6.15k, False: 1.00k] ------------------ 1480| 6.15k| s += *content; 1481| 6.15k| content++; 1482| 6.15k| } 1483| 1.00k| data.mStrings.push_back(s); 1484| | 1485| 1.00k| SkipSpacesAndLineEnd(&content, end); 1486| 1.00k| } 1487| 1.28k| } else { 1488| 1.28k| data.mValues.reserve(count); 1489| | 1490| 378k| for (unsigned int a = 0; a < count; a++) { ------------------ | Branch (1490:38): [True: 377k, False: 1.28k] ------------------ 1491| 377k| if (*content == 0) { ------------------ | Branch (1491:21): [True: 2, False: 377k] ------------------ 1492| 2| throw DeadlyImportError("Expected more values while reading float_array contents."); 1493| 2| } 1494| | 1495| | // read a number 1496| 377k| ai_real value; 1497| 377k| content = fast_atoreal_move(content, value); 1498| 377k| data.mValues.push_back(value); 1499| | // skip whitespace after it 1500| 377k| SkipSpacesAndLineEnd(&content, end); 1501| 377k| } 1502| 1.28k| } 1503| 1.68k| } 1504| 1.68k|} _ZN6Assimp13ColladaParser12ReadAccessorERN4pugi8xml_nodeERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 1508| 1.67k|void ColladaParser::ReadAccessor(XmlNode &node, const std::string &pID) { 1509| | // read accessor attributes 1510| 1.67k| std::string source; 1511| 1.67k| XmlParser::getStdStrAttribute(node, "source", source); 1512| 1.67k| if (source[0] != '#') { ------------------ | Branch (1512:9): [True: 0, False: 1.67k] ------------------ 1513| 0| throw DeadlyImportError("Unknown reference format in url \"", source, "\" in source attribute of element."); 1514| 0| } 1515| 1.67k| int count = 0; 1516| 1.67k| XmlParser::getIntAttribute(node, "count", count); 1517| | 1518| 1.67k| unsigned int offset = 0; 1519| 1.67k| if (XmlParser::hasAttribute(node, "offset")) { ------------------ | Branch (1519:9): [True: 28, False: 1.65k] ------------------ 1520| 28| XmlParser::getUIntAttribute(node, "offset", offset); 1521| 28| } 1522| 1.67k| unsigned int stride = 1; 1523| 1.67k| if (XmlParser::hasAttribute(node, "stride")) { ------------------ | Branch (1523:9): [True: 1.67k, False: 0] ------------------ 1524| 1.67k| XmlParser::getUIntAttribute(node, "stride", stride); 1525| 1.67k| } 1526| | // store in the library under the given ID 1527| 1.67k| mAccessorLibrary[pID] = Accessor(); 1528| 1.67k| Accessor &acc = mAccessorLibrary[pID]; 1529| 1.67k| acc.mCount = count; 1530| 1.67k| acc.mOffset = offset; 1531| 1.67k| acc.mStride = stride; 1532| 1.67k| acc.mSource = source.c_str() + 1; // ignore the leading '#' 1533| 1.67k| acc.mSize = 0; // gets incremented with every param 1534| | 1535| 1.67k| XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); 1536| 1.67k| XmlNode currentNode; 1537| 4.16k| while (xmlIt.getNext(currentNode)) { ------------------ | Branch (1537:12): [True: 2.48k, False: 1.67k] ------------------ 1538| 2.48k| const std::string ¤tName = currentNode.name(); 1539| 2.48k| if (currentName == "param") { ------------------ | Branch (1539:13): [True: 2.48k, False: 0] ------------------ 1540| | // read data param 1541| 2.48k| std::string name; 1542| 2.48k| if (XmlParser::hasAttribute(currentNode, "name")) { ------------------ | Branch (1542:17): [True: 1.33k, False: 1.15k] ------------------ 1543| 1.33k| XmlParser::getStdStrAttribute(currentNode, "name", name); 1544| | 1545| | // analyse for common type components and store it's sub-offset in the corresponding field 1546| | 1547| | // Cartesian coordinates 1548| 1.33k| if (name == "X") ------------------ | Branch (1548:21): [True: 327, False: 1.00k] ------------------ 1549| 327| acc.mSubOffset[0] = acc.mParams.size(); 1550| 1.00k| else if (name == "Y") ------------------ | Branch (1550:26): [True: 327, False: 679] ------------------ 1551| 327| acc.mSubOffset[1] = acc.mParams.size(); 1552| 679| else if (name == "Z") ------------------ | Branch (1552:26): [True: 327, False: 352] ------------------ 1553| 327| acc.mSubOffset[2] = acc.mParams.size(); 1554| | 1555| | /* RGBA colors */ 1556| 352| else if (name == "R") ------------------ | Branch (1556:26): [True: 0, False: 352] ------------------ 1557| 0| acc.mSubOffset[0] = acc.mParams.size(); 1558| 352| else if (name == "G") ------------------ | Branch (1558:26): [True: 0, False: 352] ------------------ 1559| 0| acc.mSubOffset[1] = acc.mParams.size(); 1560| 352| else if (name == "B") ------------------ | Branch (1560:26): [True: 0, False: 352] ------------------ 1561| 0| acc.mSubOffset[2] = acc.mParams.size(); 1562| 352| else if (name == "A") ------------------ | Branch (1562:26): [True: 0, False: 352] ------------------ 1563| 0| acc.mSubOffset[3] = acc.mParams.size(); 1564| | 1565| | /* UVWQ (STPQ) texture coordinates */ 1566| 352| else if (name == "S") ------------------ | Branch (1566:26): [True: 153, False: 199] ------------------ 1567| 153| acc.mSubOffset[0] = acc.mParams.size(); 1568| 199| else if (name == "T") ------------------ | Branch (1568:26): [True: 153, False: 46] ------------------ 1569| 153| acc.mSubOffset[1] = acc.mParams.size(); 1570| 46| else if (name == "P") ------------------ | Branch (1570:26): [True: 0, False: 46] ------------------ 1571| 0| acc.mSubOffset[2] = acc.mParams.size(); 1572| | /* Generic extra data, interpreted as UV data, too*/ 1573| 46| else if (name == "U") ------------------ | Branch (1573:26): [True: 0, False: 46] ------------------ 1574| 0| acc.mSubOffset[0] = acc.mParams.size(); 1575| 46| else if (name == "V") ------------------ | Branch (1575:26): [True: 0, False: 46] ------------------ 1576| 0| acc.mSubOffset[1] = acc.mParams.size(); 1577| 1.33k| } 1578| 2.48k| if (XmlParser::hasAttribute(currentNode, "type")) { ------------------ | Branch (1578:17): [True: 2.48k, False: 0] ------------------ 1579| | // read data type 1580| | // TODO: (thom) I don't have a spec here at work. Check if there are other multi-value types 1581| | // which should be tested for here. 1582| 2.48k| std::string type; 1583| | 1584| 2.48k| XmlParser::getStdStrAttribute(currentNode, "type", type); 1585| 2.48k| if (type == "float4x4") ------------------ | Branch (1585:21): [True: 15, False: 2.47k] ------------------ 1586| 15| acc.mSize += 16; 1587| 2.47k| else 1588| 2.47k| acc.mSize += 1; 1589| 2.48k| } 1590| | 1591| 2.48k| acc.mParams.push_back(name); 1592| 2.48k| } 1593| 2.48k| } 1594| 1.67k|} _ZN6Assimp13ColladaParser14ReadVertexDataERN4pugi8xml_nodeERNS_7Collada4MeshE: 1598| 159|void ColladaParser::ReadVertexData(XmlNode &node, Mesh &pMesh) { 1599| | // extract the ID of the element. Not that we care, but to catch strange referencing schemes we should warn about 1600| 159| XmlParser::getStdStrAttribute(node, "id", pMesh.mVertexID); 1601| 423| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (1601:31): [True: 423, False: 158] ------------------ 1602| 423| const std::string ¤tName = currentNode.name(); 1603| 423| if (currentName == "input") { ------------------ | Branch (1603:13): [True: 422, False: 1] ------------------ 1604| 422| ReadInputChannel(currentNode, pMesh.mPerVertexData); 1605| 422| } else { 1606| 1| throw DeadlyImportError("Unexpected sub element <", currentName, "> in tag "); 1607| 1| } 1608| 423| } 1609| 159|} _ZN6Assimp13ColladaParser13ReadIndexDataERN4pugi8xml_nodeERNS_7Collada4MeshE: 1613| 163|void ColladaParser::ReadIndexData(XmlNode &node, Mesh &pMesh) { 1614| 163| std::vector vcount; 1615| 163| std::vector perIndexData; 1616| | 1617| 163| unsigned int numPrimitives = 0; 1618| 163| XmlParser::getUIntAttribute(node, "count", numPrimitives); 1619| | // read primitive count from the attribute 1620| | //int attrCount = GetAttribute("count"); 1621| | //size_t numPrimitives = (size_t)mReader->getAttributeValueAsInt(attrCount); 1622| | // some mesh types (e.g. tristrips) don't specify primitive count upfront, 1623| | // so we need to sum up the actual number of primitives while we read the

-tags 1624| 163| size_t actualPrimitives = 0; 1625| 163| SubMesh subgroup; 1626| 163| if (XmlParser::hasAttribute(node, "material")) { ------------------ | Branch (1626:9): [True: 33, False: 130] ------------------ 1627| 33| XmlParser::getStdStrAttribute(node, "material", subgroup.mMaterial); 1628| 33| } 1629| | 1630| | // distinguish between polys and triangles 1631| 163| std::string elementName = node.name(); 1632| 163| PrimitiveType primType = Prim_Invalid; 1633| 163| if (elementName == "lines") ------------------ | Branch (1633:9): [True: 0, False: 163] ------------------ 1634| 0| primType = Prim_Lines; 1635| 163| else if (elementName == "linestrips") ------------------ | Branch (1635:14): [True: 0, False: 163] ------------------ 1636| 0| primType = Prim_LineStrip; 1637| 163| else if (elementName == "polygons") ------------------ | Branch (1637:14): [True: 11, False: 152] ------------------ 1638| 11| primType = Prim_Polygon; 1639| 152| else if (elementName == "polylist") ------------------ | Branch (1639:14): [True: 138, False: 14] ------------------ 1640| 138| primType = Prim_Polylist; 1641| 14| else if (elementName == "triangles") ------------------ | Branch (1641:14): [True: 14, False: 0] ------------------ 1642| 14| primType = Prim_Triangles; 1643| 0| else if (elementName == "trifans") ------------------ | Branch (1643:14): [True: 0, False: 0] ------------------ 1644| 0| primType = Prim_TriFans; 1645| 0| else if (elementName == "tristrips") ------------------ | Branch (1645:14): [True: 0, False: 0] ------------------ 1646| 0| primType = Prim_TriStrips; 1647| | 1648| 163| ai_assert(primType != Prim_Invalid); ------------------ | | 67| 163|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 163, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 1649| | 1650| | // also a number of elements, but in addition a

primitive collection and probably index counts for all primitives 1651| 163| XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); 1652| 163| XmlNode currentNode; 1653| 8.50k| while (xmlIt.getNext(currentNode)) { ------------------ | Branch (1653:12): [True: 8.34k, False: 163] ------------------ 1654| 8.34k| const std::string ¤tName = currentNode.name(); 1655| 8.34k| if (currentName == "input") { ------------------ | Branch (1655:13): [True: 225, False: 8.11k] ------------------ 1656| 225| ReadInputChannel(currentNode, perIndexData); 1657| 8.11k| } else if (currentName == "vcount") { ------------------ | Branch (1657:20): [True: 138, False: 7.98k] ------------------ 1658| 138| if (!currentNode.empty()) { ------------------ | Branch (1658:17): [True: 138, False: 0] ------------------ 1659| 138| if (numPrimitives) // It is possible to define a mesh without any primitives ------------------ | Branch (1659:21): [True: 138, False: 0] ------------------ 1660| 138| { 1661| | // case - specifies the number of indices for each polygon 1662| 138| std::string v; 1663| 138| XmlParser::getValueAsString(currentNode, v); 1664| 138| const char *content = v.c_str(); 1665| 138| const char *end = content + v.size(); 1666| | 1667| 138| vcount.reserve(numPrimitives); 1668| 138| SkipSpacesAndLineEnd(&content, end); 1669| 14.5k| for (unsigned int a = 0; a < numPrimitives; a++) { ------------------ | Branch (1669:46): [True: 14.3k, False: 138] ------------------ 1670| 14.3k| if (*content == 0) { ------------------ | Branch (1670:29): [True: 0, False: 14.3k] ------------------ 1671| 0| throw DeadlyImportError("Expected more values while reading contents."); 1672| 0| } 1673| | // read a number 1674| 14.3k| vcount.push_back((size_t)strtoul10(content, &content)); 1675| | // skip whitespace after it 1676| 14.3k| SkipSpacesAndLineEnd(&content, end); 1677| 14.3k| } 1678| 138| } 1679| 138| } 1680| 7.98k| } else if (currentName == "p") { ------------------ | Branch (1680:20): [True: 7.98k, False: 0] ------------------ 1681| 7.98k| if (!currentNode.empty()) { ------------------ | Branch (1681:17): [True: 7.98k, False: 0] ------------------ 1682| | // now here the actual fun starts - these are the indices to construct the mesh data from 1683| 7.98k| actualPrimitives += ReadPrimitives(currentNode, pMesh, perIndexData, numPrimitives, vcount, primType); 1684| 7.98k| } 1685| 7.98k| } else if (currentName == "extra") { ------------------ | Branch (1685:20): [True: 0, False: 0] ------------------ 1686| | // skip 1687| 0| } else if (currentName == "ph") { ------------------ | Branch (1687:20): [True: 0, False: 0] ------------------ 1688| | // skip 1689| 0| } else { 1690| 0| throw DeadlyImportError("Unexpected sub element <", currentName, "> in tag <", elementName, ">"); 1691| 0| } 1692| 8.34k| } 1693| | 1694| 163|#ifdef ASSIMP_BUILD_DEBUG 1695| 163| if (primType != Prim_TriFans && primType != Prim_TriStrips && primType != Prim_LineStrip && ------------------ | Branch (1695:9): [True: 158, False: 5] | Branch (1695:37): [True: 158, False: 0] | Branch (1695:67): [True: 158, False: 0] ------------------ 1696| 158| primType != Prim_Lines) { // this is ONLY to workaround a bug in SketchUp 15.3.331 where it writes the wrong 'count' when it writes out the 'lines'. ------------------ | Branch (1696:13): [True: 158, False: 0] ------------------ 1697| 158| ai_assert(actualPrimitives == numPrimitives); ------------------ | | 67| 158|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 158, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 1698| 158| } 1699| 163|#endif 1700| | 1701| | // only when we're done reading all

tags (and thus know the final vertex count) can we commit the submesh 1702| 163| subgroup.mNumFaces = actualPrimitives; 1703| 163| pMesh.mSubMeshes.push_back(subgroup); 1704| 163|} _ZN6Assimp13ColladaParser16ReadInputChannelERN4pugi8xml_nodeERNSt3__16vectorINS_7Collada12InputChannelENS4_9allocatorIS7_EEEE: 1708| 647|void ColladaParser::ReadInputChannel(XmlNode &node, std::vector &poChannels) { 1709| 647| InputChannel channel; 1710| | 1711| | // read semantic 1712| 647| std::string semantic; 1713| 647| XmlParser::getStdStrAttribute(node, "semantic", semantic); 1714| 647| channel.mType = GetTypeForSemantic(semantic); 1715| | 1716| | // read source 1717| 647| std::string source; 1718| 647| XmlParser::getStdStrAttribute(node, "source", source); 1719| 647| if (source[0] != '#') { ------------------ | Branch (1719:9): [True: 0, False: 647] ------------------ 1720| 0| throw DeadlyImportError("Unknown reference format in url \"", source, "\" in source attribute of element."); 1721| 0| } 1722| 647| channel.mAccessor = source.c_str() + 1; // skipping the leading #, hopefully the remaining text is the accessor ID only 1723| | 1724| | // read index offset, if per-index 1725| 647| if (XmlParser::hasAttribute(node, "offset")) { ------------------ | Branch (1725:9): [True: 225, False: 422] ------------------ 1726| 225| XmlParser::getUIntAttribute(node, "offset", (unsigned int &)channel.mOffset); 1727| 225| } 1728| | 1729| | // read set if texture coordinates 1730| 647| if (channel.mType == IT_Texcoord || channel.mType == IT_Color) { ------------------ | Branch (1730:9): [True: 157, False: 490] | Branch (1730:41): [True: 2, False: 488] ------------------ 1731| 159| unsigned int attrSet = 0; 1732| 159| if (XmlParser::getUIntAttribute(node, "set", attrSet)) ------------------ | Branch (1732:13): [True: 22, False: 137] ------------------ 1733| 22| channel.mIndex = attrSet; 1734| 159| } 1735| | 1736| | // store, if valid type 1737| 647| if (channel.mType != IT_Invalid) ------------------ | Branch (1737:9): [True: 647, False: 0] ------------------ 1738| 647| poChannels.push_back(channel); 1739| 647|} _ZN6Assimp13ColladaParser14ReadPrimitivesERN4pugi8xml_nodeERNS_7Collada4MeshERNSt3__16vectorINS4_12InputChannelENS7_9allocatorIS9_EEEEmRKNS8_ImNSA_ImEEEENS4_13PrimitiveTypeE: 1744| 7.98k| size_t pNumPrimitives, const std::vector &pVCount, PrimitiveType pPrimType) { 1745| | // determine number of indices coming per vertex 1746| | // find the offset index for all per-vertex channels 1747| 7.98k| size_t numOffsets = 1; 1748| 7.98k| size_t perVertexOffset = SIZE_MAX; // invalid value 1749| 22.7k| for (const InputChannel &channel : pPerIndexChannels) { ------------------ | Branch (1749:38): [True: 22.7k, False: 7.98k] ------------------ 1750| 22.7k| numOffsets = std::max(numOffsets, channel.mOffset + 1); 1751| 22.7k| if (channel.mType == IT_Vertex) ------------------ | Branch (1751:13): [True: 7.98k, False: 14.7k] ------------------ 1752| 7.98k| perVertexOffset = channel.mOffset; 1753| 22.7k| } 1754| | 1755| | // determine the expected number of indices 1756| 7.98k| size_t expectedPointCount = 0; 1757| 7.98k| switch (pPrimType) { 1758| 138| case Prim_Polylist: { ------------------ | Branch (1758:5): [True: 138, False: 7.84k] ------------------ 1759| 138| for (size_t i : pVCount) ------------------ | Branch (1759:23): [True: 14.3k, False: 138] ------------------ 1760| 14.3k| expectedPointCount += i; 1761| 138| break; 1762| 0| } 1763| 0| case Prim_Lines: ------------------ | Branch (1763:5): [True: 0, False: 7.98k] ------------------ 1764| 0| expectedPointCount = 2 * pNumPrimitives; 1765| 0| break; 1766| 14| case Prim_Triangles: ------------------ | Branch (1766:5): [True: 14, False: 7.96k] ------------------ 1767| 14| expectedPointCount = 3 * pNumPrimitives; 1768| 14| break; 1769| 7.82k| default: ------------------ | Branch (1769:5): [True: 7.82k, False: 152] ------------------ 1770| 7.82k| break; 1771| 7.98k| } 1772| | 1773| | // and read all indices into a temporary array 1774| 7.98k| std::vector indices; 1775| 7.98k| if (expectedPointCount > 0) { ------------------ | Branch (1775:9): [True: 152, False: 7.82k] ------------------ 1776| 152| indices.reserve(expectedPointCount * numOffsets); 1777| 152| } 1778| | 1779| | // It is possible to not contain any indices 1780| 7.98k| if (pNumPrimitives > 0) { ------------------ | Branch (1780:9): [True: 7.98k, False: 0] ------------------ 1781| 7.98k| std::string v; 1782| 7.98k| XmlParser::getValueAsString(node, v); 1783| 7.98k| const char *content = v.c_str(); 1784| 7.98k| const char *end = content + v.size(); 1785| | 1786| 7.98k| SkipSpacesAndLineEnd(&content, end); 1787| 301k| while (*content != 0) { ------------------ | Branch (1787:16): [True: 293k, False: 7.98k] ------------------ 1788| | // read a value. 1789| | // Hack: (thom) Some exporters put negative indices sometimes. We just try to carry on anyways. 1790| 293k| int value = std::max(0, strtol10(content, &content)); 1791| 293k| indices.push_back(size_t(value)); 1792| | // skip whitespace after it 1793| 293k| SkipSpacesAndLineEnd(&content, end); 1794| 293k| } 1795| 7.98k| } 1796| | 1797| | // complain if the index count doesn't fit 1798| 7.98k| if (expectedPointCount > 0 && indices.size() != expectedPointCount * numOffsets) { ------------------ | Branch (1798:9): [True: 152, False: 7.82k] | Branch (1798:35): [True: 1, False: 151] ------------------ 1799| 1| if (pPrimType == Prim_Lines) { ------------------ | Branch (1799:13): [True: 0, False: 1] ------------------ 1800| | // HACK: We just fix this number since SketchUp 15.3.331 writes the wrong 'count' for 'lines' 1801| 0| ReportWarning("Expected different index count in

element, %zu instead of %zu.", indices.size(), expectedPointCount * numOffsets); 1802| 0| pNumPrimitives = (indices.size() / numOffsets) / 2; 1803| 1| } else { 1804| 1| throw DeadlyImportError("Expected different index count in

element."); 1805| 1| } 1806| 7.98k| } else if (expectedPointCount == 0 && (indices.size() % numOffsets) != 0) { ------------------ | Branch (1806:16): [True: 7.82k, False: 151] | Branch (1806:43): [True: 0, False: 7.82k] ------------------ 1807| 0| throw DeadlyImportError("Expected different index count in

element."); 1808| 0| } 1809| | 1810| | // find the data for all sources 1811| 16.2k| for (auto it = pMesh.mPerVertexData.begin(); it != pMesh.mPerVertexData.end(); ++it) { ------------------ | Branch (1811:50): [True: 8.24k, False: 7.97k] ------------------ 1812| 8.24k| InputChannel &input = *it; 1813| 8.24k| if (input.mResolved) { ------------------ | Branch (1813:13): [True: 7.82k, False: 421] ------------------ 1814| 7.82k| continue; 1815| 7.82k| } 1816| | 1817| | // find accessor 1818| 421| input.mResolved = &ResolveLibraryReference(mAccessorLibrary, input.mAccessor); 1819| | // resolve accessor's data pointer as well, if necessary 1820| 421| const Accessor *acc = input.mResolved; 1821| 421| if (!acc->mData) { ------------------ | Branch (1821:13): [True: 415, False: 6] ------------------ 1822| 415| acc->mData = &ResolveLibraryReference(mDataLibrary, acc->mSource); 1823| 415| const size_t dataSize = acc->mOffset + acc->mCount * acc->mStride; 1824| 415| if (dataSize > acc->mData->mValues.size()) { ------------------ | Branch (1824:17): [True: 2, False: 413] ------------------ 1825| 2| throw DeadlyImportError("Not enough data for accessor"); 1826| 2| } 1827| 415| } 1828| 421| } 1829| | // and the same for the per-index channels 1830| 30.7k| for (auto it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it) { ------------------ | Branch (1830:47): [True: 22.7k, False: 7.97k] ------------------ 1831| 22.7k| InputChannel &input = *it; 1832| 22.7k| if (input.mResolved) { ------------------ | Branch (1832:13): [True: 14.6k, False: 8.02k] ------------------ 1833| 14.6k| continue; 1834| 14.6k| } 1835| | 1836| | // ignore vertex pointer, it doesn't refer to an accessor 1837| 8.02k| if (input.mType == IT_Vertex) { ------------------ | Branch (1837:13): [True: 7.97k, False: 52] ------------------ 1838| | // warn if the vertex channel does not refer to the element in the same mesh 1839| 7.97k| if (input.mAccessor != pMesh.mVertexID) { ------------------ | Branch (1839:17): [True: 0, False: 7.97k] ------------------ 1840| 0| throw DeadlyImportError("Unsupported vertex referencing scheme."); 1841| 0| } 1842| 7.97k| continue; 1843| 7.97k| } 1844| | 1845| | // find accessor 1846| 52| input.mResolved = &ResolveLibraryReference(mAccessorLibrary, input.mAccessor); 1847| | // resolve accessor's data pointer as well, if necessary 1848| 52| const Accessor *acc = input.mResolved; 1849| 52| if (!acc->mData) { ------------------ | Branch (1849:13): [True: 42, False: 10] ------------------ 1850| 42| acc->mData = &ResolveLibraryReference(mDataLibrary, acc->mSource); 1851| 42| const size_t dataSize = acc->mOffset + acc->mCount * acc->mStride; 1852| 42| if (dataSize > acc->mData->mValues.size()) { ------------------ | Branch (1852:17): [True: 0, False: 42] ------------------ 1853| 0| throw DeadlyImportError("Not enough data for accessor"); 1854| 0| } 1855| 42| } 1856| 52| } 1857| | 1858| | // For continued primitives, the given count does not come all in one

, but only one primitive per

1859| 7.97k| size_t numPrimitives = pNumPrimitives; 1860| 7.97k| if (pPrimType == Prim_TriFans || pPrimType == Prim_Polygon) { ------------------ | Branch (1860:9): [True: 2, False: 7.97k] | Branch (1860:38): [True: 7.82k, False: 148] ------------------ 1861| 7.82k| numPrimitives = 1; 1862| 7.82k| } 1863| | 1864| | // For continued primitives, the given count is actually the number of

's inside the parent tag 1865| 7.97k| if (pPrimType == Prim_TriStrips) { ------------------ | Branch (1865:9): [True: 0, False: 7.97k] ------------------ 1866| 0| size_t numberOfVertices = indices.size() / numOffsets; 1867| 0| numPrimitives = numberOfVertices - 2; 1868| 0| } 1869| 7.97k| if (pPrimType == Prim_LineStrip) { ------------------ | Branch (1869:9): [True: 0, False: 7.97k] ------------------ 1870| 0| size_t numberOfVertices = indices.size() / numOffsets; 1871| 0| numPrimitives = numberOfVertices - 1; 1872| 0| } 1873| | 1874| 7.97k| pMesh.mFaceSize.reserve(numPrimitives); 1875| 7.97k| pMesh.mFacePosIndices.reserve(indices.size() / numOffsets); 1876| | 1877| 7.97k| size_t polylistStartVertex = 0; 1878| 43.2k| for (size_t currentPrimitive = 0; currentPrimitive < numPrimitives; currentPrimitive++) { ------------------ | Branch (1878:39): [True: 35.3k, False: 7.97k] ------------------ 1879| | // determine number of points for this primitive 1880| 35.3k| size_t numPoints = 0; 1881| 35.3k| switch (pPrimType) { 1882| 0| case Prim_Lines: ------------------ | Branch (1882:9): [True: 0, False: 35.3k] ------------------ 1883| 0| numPoints = 2; 1884| 0| for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++) ------------------ | Branch (1884:44): [True: 0, False: 0] ------------------ 1885| 0| CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); 1886| 0| break; 1887| 0| case Prim_LineStrip: ------------------ | Branch (1887:9): [True: 0, False: 35.3k] ------------------ 1888| 0| numPoints = 2; 1889| 0| for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++) ------------------ | Branch (1889:44): [True: 0, False: 0] ------------------ 1890| 0| CopyVertex(currentVertex, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); 1891| 0| break; 1892| 13.1k| case Prim_Triangles: ------------------ | Branch (1892:9): [True: 13.1k, False: 22.1k] ------------------ 1893| 13.1k| numPoints = 3; 1894| 52.6k| for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++) ------------------ | Branch (1894:44): [True: 39.4k, False: 13.1k] ------------------ 1895| 39.4k| CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); 1896| 13.1k| break; 1897| 0| case Prim_TriStrips: ------------------ | Branch (1897:9): [True: 0, False: 35.3k] ------------------ 1898| 0| numPoints = 3; 1899| 0| ReadPrimTriStrips(numOffsets, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); 1900| 0| break; 1901| 14.3k| case Prim_Polylist: ------------------ | Branch (1901:9): [True: 14.3k, False: 20.9k] ------------------ 1902| 14.3k| numPoints = pVCount[currentPrimitive]; 1903| 64.6k| for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++) ------------------ | Branch (1903:44): [True: 50.3k, False: 14.3k] ------------------ 1904| 50.3k| CopyVertex(polylistStartVertex + currentVertex, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, 0, indices); 1905| 14.3k| polylistStartVertex += numPoints; 1906| 14.3k| break; 1907| 0| case Prim_TriFans: ------------------ | Branch (1907:9): [True: 0, False: 35.3k] ------------------ 1908| 7.82k| case Prim_Polygon: ------------------ | Branch (1908:9): [True: 7.82k, False: 27.4k] ------------------ 1909| 7.82k| numPoints = indices.size() / numOffsets; 1910| 31.3k| for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++) ------------------ | Branch (1910:44): [True: 23.5k, False: 7.82k] ------------------ 1911| 23.5k| CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); 1912| 7.82k| break; 1913| 0| default: ------------------ | Branch (1913:9): [True: 0, False: 35.3k] ------------------ 1914| | // LineStrip is not supported due to expected index unmangling 1915| 0| throw DeadlyImportError("Unsupported primitive type."); 1916| 35.3k| } 1917| | 1918| | // store the face size to later reconstruct the face from 1919| 35.3k| pMesh.mFaceSize.push_back(numPoints); 1920| 35.3k| } 1921| | 1922| | // if I ever get my hands on that guy who invented this steaming pile of indirection... 1923| 7.97k| return numPrimitives; 1924| 7.97k|} _ZN6Assimp13ColladaParser10CopyVertexEmmmmRNS_7Collada4MeshERNSt3__16vectorINS1_12InputChannelENS4_9allocatorIS6_EEEEmRKNS5_ImNS7_ImEEEE: 1930| 113k| std::vector &pPerIndexChannels, size_t currentPrimitive, const std::vector &indices) { 1931| | // calculate the base offset of the vertex whose attributes we ant to copy 1932| 113k| const auto baseOffset = currentPrimitive * numOffsets * numPoints + currentVertex * numOffsets; 1933| | 1934| | // don't overrun the boundaries of the index list 1935| 113k| ai_assert((baseOffset + numOffsets - 1) < indices.size()); ------------------ | | 67| 113k|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:41): [True: 113k, False: 0] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 1936| | 1937| | // extract per-vertex channels using the global per-vertex offset 1938| 236k| for (auto it = pMesh.mPerVertexData.begin(); it != pMesh.mPerVertexData.end(); ++it) { ------------------ | Branch (1938:50): [True: 123k, False: 113k] ------------------ 1939| 123k| ExtractDataObjectFromChannel(*it, indices[baseOffset + perVertexOffset], pMesh); 1940| 123k| } 1941| | // and extract per-index channels using there specified offset 1942| 400k| for (auto it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it) { ------------------ | Branch (1942:47): [True: 286k, False: 113k] ------------------ 1943| 286k| ExtractDataObjectFromChannel(*it, indices[baseOffset + it->mOffset], pMesh); 1944| 286k| } 1945| | 1946| | // store the vertex-data index for later assignment of bone vertex weights 1947| 113k| if (const auto indexOffset = baseOffset + perVertexOffset; indexOffset >= indices.size()) { ------------------ | Branch (1947:64): [True: 0, False: 113k] ------------------ 1948| 0| throw DeadlyImportError("index offset out of range"); 1949| 0| } 1950| 113k| pMesh.mFacePosIndices.push_back(indices[baseOffset + perVertexOffset]); 1951| 113k|} _ZN6Assimp13ColladaParser28ExtractDataObjectFromChannelERKNS_7Collada12InputChannelEmRNS1_4MeshE: 1969| 410k|void ColladaParser::ExtractDataObjectFromChannel(const InputChannel &pInput, size_t pLocalIndex, Mesh &pMesh) { 1970| | // ignore vertex referrer - we handle them that separate 1971| 410k| if (pInput.mType == IT_Vertex) { ------------------ | Branch (1971:9): [True: 113k, False: 296k] ------------------ 1972| 113k| return; 1973| 113k| } 1974| | 1975| 296k| const Accessor &acc = *pInput.mResolved; 1976| 296k| if (pLocalIndex >= acc.mCount) { ------------------ | Branch (1976:9): [True: 0, False: 296k] ------------------ 1977| 0| throw DeadlyImportError("Invalid data index (", pLocalIndex, "/", acc.mCount, ") in primitive specification"); 1978| 0| } 1979| | 1980| | // get a pointer to the start of the data object referred to by the accessor and the local index 1981| 296k| const ai_real *dataObject = &(acc.mData->mValues[0]) + acc.mOffset + pLocalIndex * acc.mStride; 1982| | 1983| | // assemble according to the accessors component sub-offset list. We don't care, yet, 1984| | // what kind of object exactly we're extracting here 1985| 296k| ai_real obj[4]; 1986| 1.48M| for (size_t c = 0; c < 4; ++c) { ------------------ | Branch (1986:24): [True: 1.18M, False: 296k] ------------------ 1987| 1.18M| obj[c] = dataObject[acc.mSubOffset[c]]; 1988| 1.18M| } 1989| | 1990| | // now we reinterpret it according to the type we're reading here 1991| 296k| switch (pInput.mType) { 1992| 113k| case IT_Position: // ignore all position streams except 0 - there can be only one position ------------------ | Branch (1992:5): [True: 113k, False: 183k] ------------------ 1993| 113k| if (pInput.mIndex == 0) { ------------------ | Branch (1993:13): [True: 113k, False: 0] ------------------ 1994| 113k| pMesh.mPositions.emplace_back(obj[0], obj[1], obj[2]); 1995| 113k| } else { 1996| 0| ASSIMP_LOG_ERROR("Collada: just one vertex position stream supported"); 1997| 0| } 1998| 113k| break; 1999| 113k| case IT_Normal: ------------------ | Branch (1999:5): [True: 113k, False: 183k] ------------------ 2000| | // pad to current vertex count if necessary 2001| 113k| if (pMesh.mNormals.size() < pMesh.mPositions.size() - 1) ------------------ | Branch (2001:13): [True: 0, False: 113k] ------------------ 2002| 0| pMesh.mNormals.insert(pMesh.mNormals.end(), pMesh.mPositions.size() - pMesh.mNormals.size() - 1, aiVector3D(0, 1, 0)); 2003| | 2004| | // ignore all normal streams except 0 - there can be only one normal 2005| 113k| if (pInput.mIndex == 0) { ------------------ | Branch (2005:13): [True: 113k, False: 0] ------------------ 2006| 113k| pMesh.mNormals.emplace_back(obj[0], obj[1], obj[2]); 2007| 113k| } else { 2008| 0| ASSIMP_LOG_ERROR("Collada: just one vertex normal stream supported"); 2009| 0| } 2010| 113k| break; 2011| 0| case IT_Tangent: ------------------ | Branch (2011:5): [True: 0, False: 296k] ------------------ 2012| | // pad to current vertex count if necessary 2013| 0| if (pMesh.mTangents.size() < pMesh.mPositions.size() - 1) ------------------ | Branch (2013:13): [True: 0, False: 0] ------------------ 2014| 0| pMesh.mTangents.insert(pMesh.mTangents.end(), pMesh.mPositions.size() - pMesh.mTangents.size() - 1, aiVector3D(1, 0, 0)); 2015| | 2016| | // ignore all tangent streams except 0 - there can be only one tangent 2017| 0| if (pInput.mIndex == 0) { ------------------ | Branch (2017:13): [True: 0, False: 0] ------------------ 2018| 0| pMesh.mTangents.emplace_back(obj[0], obj[1], obj[2]); 2019| 0| } else { 2020| 0| ASSIMP_LOG_ERROR("Collada: just one vertex tangent stream supported"); 2021| 0| } 2022| 0| break; 2023| 0| case IT_Bitangent: ------------------ | Branch (2023:5): [True: 0, False: 296k] ------------------ 2024| | // pad to current vertex count if necessary 2025| 0| if (pMesh.mBitangents.size() < pMesh.mPositions.size() - 1) { ------------------ | Branch (2025:13): [True: 0, False: 0] ------------------ 2026| 0| pMesh.mBitangents.insert(pMesh.mBitangents.end(), pMesh.mPositions.size() - pMesh.mBitangents.size() - 1, aiVector3D(0, 0, 1)); 2027| 0| } 2028| | 2029| | // ignore all bitangent streams except 0 - there can be only one bitangent 2030| 0| if (pInput.mIndex == 0) { ------------------ | Branch (2030:13): [True: 0, False: 0] ------------------ 2031| 0| pMesh.mBitangents.emplace_back(obj[0], obj[1], obj[2]); 2032| 0| } else { 2033| 0| ASSIMP_LOG_ERROR("Collada: just one vertex bitangent stream supported"); 2034| 0| } 2035| 0| break; 2036| 70.0k| case IT_Texcoord: ------------------ | Branch (2036:5): [True: 70.0k, False: 226k] ------------------ 2037| | // up to 4 texture coord sets are fine, ignore the others 2038| 70.0k| if (pInput.mIndex < AI_MAX_NUMBER_OF_TEXTURECOORDS) { ------------------ | Branch (2038:13): [True: 70.0k, False: 0] ------------------ 2039| | // pad to current vertex count if necessary 2040| 70.0k| if (pMesh.mTexCoords[pInput.mIndex].size() < pMesh.mPositions.size() - 1) ------------------ | Branch (2040:17): [True: 0, False: 70.0k] ------------------ 2041| 0| pMesh.mTexCoords[pInput.mIndex].insert(pMesh.mTexCoords[pInput.mIndex].end(), 2042| 0| pMesh.mPositions.size() - pMesh.mTexCoords[pInput.mIndex].size() - 1, aiVector3D(0, 0, 0)); 2043| | 2044| 70.0k| pMesh.mTexCoords[pInput.mIndex].emplace_back(obj[0], obj[1], obj[2]); 2045| 70.0k| if (0 != acc.mSubOffset[2] || 0 != acc.mSubOffset[3]) { ------------------ | Branch (2045:17): [True: 0, False: 70.0k] | Branch (2045:43): [True: 0, False: 70.0k] ------------------ 2046| 0| pMesh.mNumUVComponents[pInput.mIndex] = 3; 2047| 0| } 2048| 70.0k| } else { 2049| 0| ASSIMP_LOG_ERROR("Collada: too many texture coordinate sets. Skipping."); 2050| 0| } 2051| 70.0k| break; 2052| 208| case IT_Color: ------------------ | Branch (2052:5): [True: 208, False: 296k] ------------------ 2053| | // up to 4 color sets are fine, ignore the others 2054| 208| if (pInput.mIndex < AI_MAX_NUMBER_OF_COLOR_SETS) { ------------------ | Branch (2054:13): [True: 208, False: 0] ------------------ 2055| | // pad to current vertex count if necessary 2056| 208| if (pMesh.mColors[pInput.mIndex].size() < pMesh.mPositions.size() - 1) ------------------ | Branch (2056:17): [True: 0, False: 208] ------------------ 2057| 0| pMesh.mColors[pInput.mIndex].insert(pMesh.mColors[pInput.mIndex].end(), 2058| 0| pMesh.mPositions.size() - pMesh.mColors[pInput.mIndex].size() - 1, aiColor4D(0, 0, 0, 1)); 2059| | 2060| 208| aiColor4D result(0, 0, 0, 1); 2061| 832| for (size_t i = 0; i < pInput.mResolved->mSize; ++i) { ------------------ | Branch (2061:32): [True: 624, False: 208] ------------------ 2062| 624| result[static_cast(i)] = obj[pInput.mResolved->mSubOffset[i]]; 2063| 624| } 2064| 208| pMesh.mColors[pInput.mIndex].push_back(result); 2065| 208| } else { 2066| 0| ASSIMP_LOG_ERROR("Collada: too many vertex color sets. Skipping."); 2067| 0| } 2068| | 2069| 208| break; 2070| 0| default: ------------------ | Branch (2070:5): [True: 0, False: 296k] ------------------ 2071| | // IT_Invalid and IT_Vertex 2072| 0| ai_assert(false && "shouldn't ever get here"); ------------------ | | 67| 0|# define ai_assert(expression) (void)((!!(expression)) || (Assimp::aiAssertViolation(#expression, __FILE__, __LINE__), 0)) | | ------------------ | | | Branch (67:45): [Folded, False: 0] | | | Branch (67:45): [True: 0, Folded] | | | Branch (67:61): [True: 0, False: 0] | | ------------------ ------------------ 2073| 296k| } 2074| 296k|} _ZN6Assimp13ColladaParser16ReadSceneLibraryERN4pugi8xml_nodeE: 2078| 18|void ColladaParser::ReadSceneLibrary(XmlNode &node) { 2079| 18| if (node.empty()) { ------------------ | Branch (2079:9): [True: 0, False: 18] ------------------ 2080| 0| return; 2081| 0| } 2082| | 2083| 18| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (2083:31): [True: 18, False: 18] ------------------ 2084| 18| const std::string ¤tName = currentNode.name(); 2085| 18| if (currentName == "visual_scene") { ------------------ | Branch (2085:13): [True: 18, False: 0] ------------------ 2086| | // read ID. Is optional according to the spec, but how on earth should a scene_instance refer to it then? 2087| 18| std::string id; 2088| 18| XmlParser::getStdStrAttribute(currentNode, "id", id); 2089| | 2090| | // read name if given. 2091| 18| std::string attrName = "Scene"; 2092| 18| if (XmlParser::hasAttribute(currentNode, "name")) { ------------------ | Branch (2092:17): [True: 17, False: 1] ------------------ 2093| 17| XmlParser::getStdStrAttribute(currentNode, "name", attrName); 2094| 17| } 2095| | 2096| | // create a node and store it in the library under its ID 2097| 18| Node *sceneNode = new Node; 2098| 18| sceneNode->mID = id; 2099| 18| sceneNode->mName = attrName; 2100| 18| mNodeLibrary[sceneNode->mID] = sceneNode; 2101| | 2102| 18| ReadSceneNode(currentNode, sceneNode); 2103| 18| } 2104| 18| } 2105| 18|} _ZN6Assimp13ColladaParser13ReadSceneNodeERN4pugi8xml_nodeEPNS_7Collada4NodeE: 2109| 333|void ColladaParser::ReadSceneNode(XmlNode &node, Node *pNode) { 2110| | // quit immediately on elements 2111| 333| if (node.empty()) { ------------------ | Branch (2111:9): [True: 0, False: 333] ------------------ 2112| 0| return; 2113| 0| } 2114| | 2115| 1.41k| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (2115:31): [True: 1.41k, False: 333] ------------------ 2116| 1.41k| const std::string ¤tName = currentNode.name(); 2117| 1.41k| if (currentName == "node") { ------------------ | Branch (2117:13): [True: 315, False: 1.10k] ------------------ 2118| 315| Node *child = new Node; 2119| 315| if (XmlParser::hasAttribute(currentNode, "id")) { ------------------ | Branch (2119:17): [True: 315, False: 0] ------------------ 2120| 315| XmlParser::getStdStrAttribute(currentNode, "id", child->mID); 2121| 315| } 2122| 315| if (XmlParser::hasAttribute(currentNode, "sid")) { ------------------ | Branch (2122:17): [True: 138, False: 177] ------------------ 2123| 138| XmlParser::getStdStrAttribute(currentNode, "sid", child->mSID); 2124| 138| } 2125| 315| if (XmlParser::hasAttribute(currentNode, "name")) { ------------------ | Branch (2125:17): [True: 315, False: 0] ------------------ 2126| 315| XmlParser::getStdStrAttribute(currentNode, "name", child->mName); 2127| 315| } 2128| 315| if (pNode) { ------------------ | Branch (2128:17): [True: 315, False: 0] ------------------ 2129| 315| pNode->mChildren.push_back(child); 2130| 315| child->mParent = pNode; 2131| 315| } else { 2132| | // no parent node given, probably called from element. 2133| | // create new node in node library 2134| 0| mNodeLibrary[child->mID] = child; 2135| 0| } 2136| | 2137| | // read on recursively from there 2138| 315| ReadSceneNode(currentNode, child); 2139| 315| continue; 2140| 1.10k| } else if (!pNode) { ------------------ | Branch (2140:20): [True: 0, False: 1.10k] ------------------ 2141| | // For any further stuff we need a valid node to work on 2142| 0| continue; 2143| 0| } 2144| 1.10k| if (currentName == "lookat") { ------------------ | Branch (2144:13): [True: 0, False: 1.10k] ------------------ 2145| 0| ReadNodeTransformation(currentNode, pNode, TF_LOOKAT); 2146| 1.10k| } else if (currentName == "matrix") { ------------------ | Branch (2146:20): [True: 19, False: 1.08k] ------------------ 2147| 19| ReadNodeTransformation(currentNode, pNode, TF_MATRIX); 2148| 1.08k| } else if (currentName == "rotate") { ------------------ | Branch (2148:20): [True: 618, False: 467] ------------------ 2149| 618| ReadNodeTransformation(currentNode, pNode, TF_ROTATE); 2150| 618| } else if (currentName == "scale") { ------------------ | Branch (2150:20): [True: 5, False: 462] ------------------ 2151| 5| ReadNodeTransformation(currentNode, pNode, TF_SCALE); 2152| 462| } else if (currentName == "skew") { ------------------ | Branch (2152:20): [True: 0, False: 462] ------------------ 2153| 0| ReadNodeTransformation(currentNode, pNode, TF_SKEW); 2154| 462| } else if (currentName == "translate") { ------------------ | Branch (2154:20): [True: 157, False: 305] ------------------ 2155| 157| ReadNodeTransformation(currentNode, pNode, TF_TRANSLATE); 2156| 305| } else if (currentName == "render" && pNode->mParent == nullptr && 0 == pNode->mPrimaryCamera.length()) { ------------------ | Branch (2156:20): [True: 0, False: 305] | Branch (2156:47): [True: 0, False: 0] | Branch (2156:76): [True: 0, False: 0] ------------------ 2157| | // ... scene evaluation or, in other words, postprocessing pipeline, 2158| | // or, again in other words, a turing-complete description how to 2159| | // render a Collada scene. The only thing that is interesting for 2160| | // us is the primary camera. 2161| 0| if (XmlParser::hasAttribute(currentNode, "camera_node")) { ------------------ | Branch (2161:17): [True: 0, False: 0] ------------------ 2162| 0| std::string s; 2163| 0| XmlParser::getStdStrAttribute(currentNode, "camera_node", s); 2164| 0| if (s[0] != '#') { ------------------ | Branch (2164:21): [True: 0, False: 0] ------------------ 2165| 0| ASSIMP_LOG_ERROR("Collada: Unresolved reference format of camera"); 2166| 0| } else { 2167| 0| pNode->mPrimaryCamera = s.c_str() + 1; 2168| 0| } 2169| 0| } 2170| 305| } else if (currentName == "instance_node") { ------------------ | Branch (2170:20): [True: 0, False: 305] ------------------ 2171| | // find the node in the library 2172| 0| if (XmlParser::hasAttribute(currentNode, "url")) { ------------------ | Branch (2172:17): [True: 0, False: 0] ------------------ 2173| 0| std::string s; 2174| 0| XmlParser::getStdStrAttribute(currentNode, "url", s); 2175| 0| if (s[0] != '#') { ------------------ | Branch (2175:21): [True: 0, False: 0] ------------------ 2176| 0| ASSIMP_LOG_ERROR("Collada: Unresolved reference format of node"); 2177| 0| } else { 2178| 0| pNode->mNodeInstances.emplace_back(); 2179| 0| pNode->mNodeInstances.back().mNode = s.c_str() + 1; 2180| 0| } 2181| 0| } 2182| 305| } else if (currentName == "instance_geometry" || currentName == "instance_controller") { ------------------ | Branch (2182:20): [True: 148, False: 157] | Branch (2182:58): [True: 2, False: 155] ------------------ 2183| | // Reference to a mesh or controller, with possible material associations 2184| 150| ReadNodeGeometry(currentNode, pNode); 2185| 155| } else if (currentName == "instance_light") { ------------------ | Branch (2185:20): [True: 15, False: 140] ------------------ 2186| | // Reference to a light, name given in 'url' attribute 2187| 15| if (XmlParser::hasAttribute(currentNode, "url")) { ------------------ | Branch (2187:17): [True: 15, False: 0] ------------------ 2188| 15| std::string url; 2189| 15| XmlParser::getStdStrAttribute(currentNode, "url", url); 2190| 15| if (url[0] != '#') { ------------------ | Branch (2190:21): [True: 0, False: 15] ------------------ 2191| 0| throw DeadlyImportError("Unknown reference format in element"); 2192| 0| } 2193| | 2194| 15| pNode->mLights.emplace_back(); 2195| 15| pNode->mLights.back().mLight = url.c_str() + 1; 2196| 15| } 2197| 140| } else if (currentName == "instance_camera") { ------------------ | Branch (2197:20): [True: 10, False: 130] ------------------ 2198| | // Reference to a camera, name given in 'url' attribute 2199| 10| if (XmlParser::hasAttribute(currentNode, "url")) { ------------------ | Branch (2199:17): [True: 10, False: 0] ------------------ 2200| 10| std::string url; 2201| 10| XmlParser::getStdStrAttribute(currentNode, "url", url); 2202| 10| if (url[0] != '#') { ------------------ | Branch (2202:21): [True: 0, False: 10] ------------------ 2203| 0| throw DeadlyImportError("Unknown reference format in element"); 2204| 0| } 2205| 10| pNode->mCameras.emplace_back(); 2206| 10| pNode->mCameras.back().mCamera = url.c_str() + 1; 2207| 10| } 2208| 10| } 2209| 1.10k| } 2210| 333|} _ZN6Assimp13ColladaParser30ReadMaterialVertexInputBindingERN4pugi8xml_nodeERNS_7Collada20SemanticMappingTableE: 2215| 29|void ColladaParser::ReadMaterialVertexInputBinding(XmlNode &node, Collada::SemanticMappingTable &tbl) { 2216| 29| std::string name = node.name(); 2217| 29| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (2217:31): [True: 14, False: 29] ------------------ 2218| 14| const std::string ¤tName = currentNode.name(); 2219| 14| if (currentName == "bind_vertex_input") { ------------------ | Branch (2219:13): [True: 14, False: 0] ------------------ 2220| 14| Collada::InputSemanticMapEntry vn; 2221| | 2222| | // effect semantic 2223| 14| if (XmlParser::hasAttribute(currentNode, "semantic")) { ------------------ | Branch (2223:17): [True: 14, False: 0] ------------------ 2224| 14| std::string s; 2225| 14| XmlParser::getStdStrAttribute(currentNode, "semantic", s); 2226| 14| XmlParser::getUIntAttribute(currentNode, "input_semantic", (unsigned int &)vn.mType); 2227| 14| } 2228| 14| std::string s; 2229| 14| XmlParser::getStdStrAttribute(currentNode, "semantic", s); 2230| | 2231| | // input semantic 2232| 14| XmlParser::getUIntAttribute(currentNode, "input_semantic", (unsigned int &)vn.mType); 2233| | 2234| | // index of input set 2235| 14| if (XmlParser::hasAttribute(currentNode, "input_set")) { ------------------ | Branch (2235:17): [True: 14, False: 0] ------------------ 2236| 14| XmlParser::getUIntAttribute(currentNode, "input_set", vn.mSet); 2237| 14| } 2238| | 2239| 14| tbl.mMap[s] = vn; 2240| 14| } else if (currentName == "bind") { ------------------ | Branch (2240:20): [True: 0, False: 0] ------------------ 2241| | ASSIMP_LOG_WARN("Collada: Found unsupported element"); 2242| 0| } 2243| 14| } 2244| 29|} _ZN6Assimp13ColladaParser20ReadEmbeddedTexturesERNS_18ZipArchiveIOSystemE: 2246| 2|void ColladaParser::ReadEmbeddedTextures(ZipArchiveIOSystem &zip_archive) { 2247| | // Attempt to load any undefined Collada::Image in ImageLibrary 2248| 2| for (auto &it : mImageLibrary) { ------------------ | Branch (2248:19): [True: 2, False: 2] ------------------ 2249| 2| if (Image &image = it.second; image.mImageData.empty()) { ------------------ | Branch (2249:39): [True: 2, False: 0] ------------------ 2250| 2| std::unique_ptr image_file(zip_archive.Open(image.mFileName.c_str())); 2251| 2| if (image_file) { ------------------ | Branch (2251:17): [True: 2, False: 0] ------------------ 2252| 2| image.mImageData.resize(image_file->FileSize()); 2253| 2| image_file->Read(image.mImageData.data(), image_file->FileSize(), 1); 2254| 2| image.mEmbeddedFormat = BaseImporter::GetExtension(image.mFileName); 2255| 2| if (image.mEmbeddedFormat == "jpeg") { ------------------ | Branch (2255:21): [True: 0, False: 2] ------------------ 2256| 0| image.mEmbeddedFormat = "jpg"; 2257| 0| } 2258| 2| } 2259| 2| } 2260| 2| } 2261| 2|} _ZN6Assimp13ColladaParser16ReadNodeGeometryERN4pugi8xml_nodeEPNS_7Collada4NodeE: 2265| 150|void ColladaParser::ReadNodeGeometry(XmlNode &node, Node *pNode) { 2266| | // referred mesh is given as an attribute of the element 2267| 150| std::string url; 2268| 150| XmlParser::getStdStrAttribute(node, "url", url); 2269| 150| if (url[0] != '#') { ------------------ | Branch (2269:9): [True: 0, False: 150] ------------------ 2270| 0| throw DeadlyImportError("Unknown reference format"); 2271| 0| } 2272| | 2273| 150| Collada::MeshInstance instance; 2274| 150| instance.mMeshOrController = url.c_str() + 1; // skipping the leading # 2275| | 2276| 173| for (XmlNode currentNode = node.first_child(); currentNode; currentNode = currentNode.next_sibling()) { ------------------ | Branch (2276:52): [True: 23, False: 150] ------------------ 2277| 23| const std::string ¤tName = currentNode.name(); 2278| 23| if (currentName == "bind_material") { ------------------ | Branch (2278:13): [True: 21, False: 2] ------------------ 2279| 21| XmlNode techNode = currentNode.child("technique_common"); 2280| 21| if (techNode) { ------------------ | Branch (2280:17): [True: 21, False: 0] ------------------ 2281| 50| for (XmlNode instanceMatNode = techNode.child("instance_material"); instanceMatNode; instanceMatNode = instanceMatNode.next_sibling()) ------------------ | Branch (2281:85): [True: 29, False: 21] ------------------ 2282| 29| { 2283| 29| const std::string &instance_name = instanceMatNode.name(); 2284| 29| if (instance_name == "instance_material") ------------------ | Branch (2284:25): [True: 29, False: 0] ------------------ 2285| 29| { 2286| | // read ID of the geometry subgroup and the target material 2287| 29| std::string group; 2288| 29| XmlParser::getStdStrAttribute(instanceMatNode, "symbol", group); 2289| 29| XmlParser::getStdStrAttribute(instanceMatNode, "target", url); 2290| 29| const char *urlMat = url.c_str(); 2291| 29| Collada::SemanticMappingTable s; 2292| 29| if (urlMat[0] == '#') ------------------ | Branch (2292:29): [True: 29, False: 0] ------------------ 2293| 29| urlMat++; 2294| | 2295| 29| s.mMatName = urlMat; 2296| 29| ReadMaterialVertexInputBinding(instanceMatNode, s); 2297| | // store the association 2298| 29| instance.mMaterials[group] = s; 2299| 29| } 2300| 29| } 2301| 21| } 2302| 21| } 2303| 23| } 2304| | 2305| | // store it 2306| 150| pNode->mMeshes.push_back(instance); 2307| 150|} _ZN6Assimp13ColladaParser9ReadSceneERN4pugi8xml_nodeE: 2311| 17|void ColladaParser::ReadScene(XmlNode &node) { 2312| 17| if (node.empty()) { ------------------ | Branch (2312:9): [True: 0, False: 17] ------------------ 2313| 0| return; 2314| 0| } 2315| | 2316| 17| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (2316:31): [True: 17, False: 16] ------------------ 2317| 17| const std::string ¤tName = currentNode.name(); 2318| 17| if (currentName == "instance_visual_scene") { ------------------ | Branch (2318:13): [True: 17, False: 0] ------------------ 2319| | // should be the first and only occurrence 2320| 17| if (mRootNode) { ------------------ | Branch (2320:17): [True: 0, False: 17] ------------------ 2321| 0| throw DeadlyImportError("Invalid scene containing multiple root nodes in element"); 2322| 0| } 2323| | 2324| | // read the url of the scene to instance. Should be of format "#some_name" 2325| 17| std::string url; 2326| 17| XmlParser::getStdStrAttribute(currentNode, "url", url); 2327| 17| if (url[0] != '#') { ------------------ | Branch (2327:17): [True: 0, False: 17] ------------------ 2328| 0| throw DeadlyImportError("Unknown reference format in element"); 2329| 0| } 2330| | 2331| | // find the referred scene, skip the leading # 2332| 17| auto sit = mNodeLibrary.find(url.c_str() + 1); 2333| 17| if (sit == mNodeLibrary.end()) { ------------------ | Branch (2333:17): [True: 1, False: 16] ------------------ 2334| 1| throw DeadlyImportError("Unable to resolve visual_scene reference \"", std::string(std::move(url)), "\" in element."); 2335| 1| } 2336| 16| mRootNode = sit->second; 2337| 16| } 2338| 17| } 2339| 17|} _ZNK6Assimp13ColladaParser24CalculateResultTransformERKNSt3__16vectorINS_7Collada9TransformENS1_9allocatorIS4_EEEE: 2343| 732|aiMatrix4x4 ColladaParser::CalculateResultTransform(const std::vector &pTransforms) const { 2344| 732| aiMatrix4x4 res; 2345| | 2346| 2.38k| for (std::vector::const_iterator it = pTransforms.begin(); it != pTransforms.end(); ++it) { ------------------ | Branch (2346:75): [True: 1.64k, False: 732] ------------------ 2347| 1.64k| const Transform &tf = *it; 2348| 1.64k| switch (tf.mType) { 2349| 0| case TF_LOOKAT: { ------------------ | Branch (2349:9): [True: 0, False: 1.64k] ------------------ 2350| 0| aiVector3D pos(tf.f[0], tf.f[1], tf.f[2]); 2351| 0| aiVector3D dstPos(tf.f[3], tf.f[4], tf.f[5]); 2352| 0| aiVector3D up = aiVector3D(tf.f[6], tf.f[7], tf.f[8]).Normalize(); 2353| 0| aiVector3D dir = aiVector3D(dstPos - pos).Normalize(); 2354| 0| aiVector3D right = (dir ^ up).Normalize(); 2355| | 2356| 0| res *= aiMatrix4x4( 2357| 0| right.x, up.x, -dir.x, pos.x, 2358| 0| right.y, up.y, -dir.y, pos.y, 2359| 0| right.z, up.z, -dir.z, pos.z, 2360| 0| 0, 0, 0, 1); 2361| 0| break; 2362| 0| } 2363| 1.32k| case TF_ROTATE: { ------------------ | Branch (2363:9): [True: 1.32k, False: 326] ------------------ 2364| 1.32k| aiMatrix4x4 rot; 2365| 1.32k| ai_real angle = tf.f[3] * ai_real(AI_MATH_PI) / ai_real(180.0); 2366| 1.32k| aiVector3D axis(tf.f[0], tf.f[1], tf.f[2]); 2367| 1.32k| aiMatrix4x4::Rotation(angle, axis, rot); 2368| 1.32k| res *= rot; 2369| 1.32k| break; 2370| 0| } 2371| 93| case TF_TRANSLATE: { ------------------ | Branch (2371:9): [True: 93, False: 1.55k] ------------------ 2372| 93| aiMatrix4x4 trans; 2373| 93| aiMatrix4x4::Translation(aiVector3D(tf.f[0], tf.f[1], tf.f[2]), trans); 2374| 93| res *= trans; 2375| 93| break; 2376| 0| } 2377| 5| case TF_SCALE: { ------------------ | Branch (2377:9): [True: 5, False: 1.64k] ------------------ 2378| 5| aiMatrix4x4 scale(tf.f[0], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[1], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[2], 0.0f, 2379| 5| 0.0f, 0.0f, 0.0f, 1.0f); 2380| 5| res *= scale; 2381| 5| break; 2382| 0| } 2383| 0| case TF_SKEW: ------------------ | Branch (2383:9): [True: 0, False: 1.64k] ------------------ 2384| | // TODO: (thom) 2385| 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] | | ------------------ ------------------ 2386| 0| break; 2387| 228| case TF_MATRIX: { ------------------ | Branch (2387:9): [True: 228, False: 1.42k] ------------------ 2388| 228| aiMatrix4x4 mat(tf.f[0], tf.f[1], tf.f[2], tf.f[3], tf.f[4], tf.f[5], tf.f[6], tf.f[7], 2389| 228| tf.f[8], tf.f[9], tf.f[10], tf.f[11], tf.f[12], tf.f[13], tf.f[14], tf.f[15]); 2390| 228| res *= mat; 2391| 228| break; 2392| 0| } 2393| 0| default: ------------------ | Branch (2393:9): [True: 0, False: 1.64k] ------------------ 2394| 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] | | ------------------ ------------------ 2395| 0| break; 2396| 1.64k| } 2397| 1.64k| } 2398| | 2399| 732| return res; 2400| 732|} _ZN6Assimp13ColladaParser18GetTypeForSemanticERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 2404| 647|InputType ColladaParser::GetTypeForSemantic(const std::string &semantic) { 2405| 647| if (semantic.empty()) { ------------------ | Branch (2405:9): [True: 0, False: 647] ------------------ 2406| 0| ASSIMP_LOG_WARN("Vertex input type is empty."); 2407| 0| return IT_Invalid; 2408| 0| } 2409| | 2410| 647| if (semantic == "POSITION") ------------------ | Branch (2410:9): [True: 158, False: 489] ------------------ 2411| 158| return IT_Position; 2412| 489| else if (semantic == "TEXCOORD") ------------------ | Branch (2412:14): [True: 157, False: 332] ------------------ 2413| 157| return IT_Texcoord; 2414| 332| else if (semantic == "NORMAL") ------------------ | Branch (2414:14): [True: 167, False: 165] ------------------ 2415| 167| return IT_Normal; 2416| 165| else if (semantic == "COLOR") ------------------ | Branch (2416:14): [True: 2, False: 163] ------------------ 2417| 2| return IT_Color; 2418| 163| else if (semantic == "VERTEX") ------------------ | Branch (2418:14): [True: 163, False: 0] ------------------ 2419| 163| return IT_Vertex; 2420| 0| else if (semantic == "BINORMAL" || semantic == "TEXBINORMAL") ------------------ | Branch (2420:14): [True: 0, False: 0] | Branch (2420:40): [True: 0, False: 0] ------------------ 2421| 0| return IT_Bitangent; 2422| 0| else if (semantic == "TANGENT" || semantic == "TEXTANGENT") ------------------ | Branch (2422:14): [True: 0, False: 0] | Branch (2422:39): [True: 0, False: 0] ------------------ 2423| 0| return IT_Tangent; 2424| | 2425| 647| ASSIMP_LOG_WARN("Unknown vertex input type \"", semantic, "\". Ignoring."); 2426| 0| return IT_Invalid; 2427| 647|} ColladaParser.cpp:_ZL16ReadMetaDataItemRN4pugi8xml_nodeERNSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE8aiStringNS2_4lessIS9_EENS7_INS2_4pairIKS9_SA_EEEEEE: 141| 232|static void ReadMetaDataItem(XmlNode &node, ColladaParser::StringMetaData &metadata) { 142| 232| const MetaKeyPairVector &key_renaming = GetColladaAssimpMetaKeysCamelCase(); 143| 232| const std::string name = node.name(); 144| 232| if (name.empty()) { ------------------ | Branch (144:9): [True: 0, False: 232] ------------------ 145| 0| return; 146| 0| } 147| | 148| 232| std::string v; 149| 232| if (!XmlParser::getValueAsString(node, v)) { ------------------ | Branch (149:9): [True: 0, False: 232] ------------------ 150| 0| return; 151| 0| } 152| | 153| 232| v = ai_trim(v); 154| 232| aiString aistr; 155| 232| aistr.Set(v); 156| | 157| 232| std::string camel_key_str(name); 158| 232| ToCamelCase(camel_key_str); 159| | 160| 232| size_t found_index; 161| 232| if (FindCommonKey(camel_key_str, key_renaming, found_index)) { ------------------ | Branch (161:9): [True: 41, False: 191] ------------------ 162| 41| metadata.emplace(key_renaming[found_index].second, aistr); 163| 191| } else { 164| 191| metadata.emplace(camel_key_str, aistr); 165| 191| } 166| 232|} ColladaParser.cpp:_ZL13FindCommonKeyRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEERKNS_6vectorINS_4pairIS5_S5_EENS3_ISA_EEEERm: 80| 232|static bool FindCommonKey(const std::string &collada_key, const MetaKeyPairVector &key_renaming, size_t &found_index) { 81| 625| for (size_t i = 0; i < key_renaming.size(); ++i) { ------------------ | Branch (81:24): [True: 434, False: 191] ------------------ 82| 434| if (key_renaming[i].first == collada_key) { ------------------ | Branch (82:13): [True: 41, False: 393] ------------------ 83| 41| found_index = i; 84| 41| return true; 85| 41| } 86| 434| } 87| 191| found_index = std::numeric_limits::max(); 88| | 89| 191| return false; 90| 232|} ColladaParser.cpp:_ZL16readUrlAttributeRN4pugi8xml_nodeERNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 93| 36|static void readUrlAttribute(XmlNode &node, std::string &url) { 94| 36| url.clear(); 95| 36| if (!XmlParser::getStdStrAttribute(node, "url", url)) { ------------------ | Branch (95:9): [True: 0, False: 36] ------------------ 96| 0| return; 97| 0| } 98| 36| if (url[0] != '#') { ------------------ | Branch (98:9): [True: 0, False: 36] ------------------ 99| 0| throw DeadlyImportError("Unknown reference format"); 100| 0| } 101| 36| url = url.c_str() + 1; 102| 36|} ColladaParser.cpp:_ZL20ReadAnimationSamplerRKN4pugi8xml_nodeERN6Assimp7Collada16AnimationChannelE: 170| 397|static void ReadAnimationSampler(const XmlNode &node, AnimationChannel &pChannel) { 171| 1.19k| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (171:31): [True: 1.19k, False: 397] ------------------ 172| 1.19k| const std::string ¤tName = currentNode.name(); 173| 1.19k| if (currentName == "input") { ------------------ | Branch (173:13): [True: 1.19k, False: 0] ------------------ 174| 1.19k| if (XmlParser::hasAttribute(currentNode, "semantic")) { ------------------ | Branch (174:17): [True: 1.19k, False: 0] ------------------ 175| 1.19k| std::string semantic, sourceAttr; 176| 1.19k| XmlParser::getStdStrAttribute(currentNode, "semantic", semantic); 177| 1.19k| if (XmlParser::hasAttribute(currentNode, "source")) { ------------------ | Branch (177:21): [True: 1.19k, False: 0] ------------------ 178| 1.19k| XmlParser::getStdStrAttribute(currentNode, "source", sourceAttr); 179| 1.19k| const char *source = sourceAttr.c_str(); 180| 1.19k| if (source[0] != '#') { ------------------ | Branch (180:25): [True: 0, False: 1.19k] ------------------ 181| 0| throw DeadlyImportError("Unsupported URL format"); 182| 0| } 183| 1.19k| source++; 184| | 185| 1.19k| if (semantic == "INPUT") { ------------------ | Branch (185:25): [True: 397, False: 794] ------------------ 186| 397| pChannel.mSourceTimes = source; 187| 794| } else if (semantic == "OUTPUT") { ------------------ | Branch (187:32): [True: 397, False: 397] ------------------ 188| 397| pChannel.mSourceValues = source; 189| 397| } else if (semantic == "IN_TANGENT") { ------------------ | Branch (189:32): [True: 0, False: 397] ------------------ 190| 0| pChannel.mInTanValues = source; 191| 397| } else if (semantic == "OUT_TANGENT") { ------------------ | Branch (191:32): [True: 0, False: 397] ------------------ 192| 0| pChannel.mOutTanValues = source; 193| 397| } else if (semantic == "INTERPOLATION") { ------------------ | Branch (193:32): [True: 397, False: 0] ------------------ 194| 397| pChannel.mInterpolationValues = source; 195| 397| } 196| 1.19k| } 197| 1.19k| } 198| 1.19k| } 199| 1.19k| } 200| 397|} ColladaParser.cpp:_ZL20ReadControllerJointsRKN4pugi8xml_nodeERN6Assimp7Collada10ControllerE: 204| 2|static void ReadControllerJoints(const XmlNode &node, Controller &pController) { 205| 4| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (205:31): [True: 4, False: 2] ------------------ 206| 4| const std::string ¤tName = currentNode.name(); 207| 4| if (currentName == "input") { ------------------ | Branch (207:13): [True: 4, False: 0] ------------------ 208| 4| const char *attrSemantic = currentNode.attribute("semantic").as_string(); 209| 4| const char *attrSource = currentNode.attribute("source").as_string(); 210| 4| if (attrSource[0] != '#') { ------------------ | Branch (210:17): [True: 0, False: 4] ------------------ 211| 0| throw DeadlyImportError("Unsupported URL format in \"", attrSource, "\" in source attribute of data element"); 212| 0| } 213| 4| ++attrSource; 214| | // parse source URL to corresponding source 215| 4| if (strcmp(attrSemantic, "JOINT") == 0) { ------------------ | Branch (215:17): [True: 2, False: 2] ------------------ 216| 2| pController.mJointNameSource = attrSource; 217| 2| } else if (strcmp(attrSemantic, "INV_BIND_MATRIX") == 0) { ------------------ | Branch (217:24): [True: 2, False: 0] ------------------ 218| 2| pController.mJointOffsetMatrixSource = attrSource; 219| 2| } else { 220| 0| throw DeadlyImportError("Unknown semantic \"", attrSemantic, "\" in data element"); 221| 0| } 222| 4| } 223| 4| } 224| 2|} ColladaParser.cpp:_ZL21ReadControllerWeightsRN4pugi8xml_nodeERN6Assimp7Collada10ControllerE: 294| 2|static void ReadControllerWeights(XmlNode &node, Controller &pController) { 295| | // Read vertex count from attributes and resize the array accordingly 296| 2| int vertexCount = 0; 297| 2| XmlParser::getIntAttribute(node, "count", vertexCount); 298| 2| pController.mWeightCounts.resize(vertexCount); 299| | 300| 8| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (300:31): [True: 8, False: 2] ------------------ 301| 8| const std::string ¤tName = currentNode.name(); 302| 8| if (currentName == "input") { ------------------ | Branch (302:13): [True: 4, False: 4] ------------------ 303| 4| ReadControllerWeightsInput(currentNode, pController); 304| 4| } else if (currentName == "vcount" && vertexCount > 0) { ------------------ | Branch (304:20): [True: 2, False: 2] | Branch (304:47): [True: 2, False: 0] ------------------ 305| 2| ReadControllerWeightsVCount(currentNode, pController); 306| 2| } else if (currentName == "v" && vertexCount > 0) { ------------------ | Branch (306:20): [True: 2, False: 0] | Branch (306:42): [True: 2, False: 0] ------------------ 307| 2| ReadControllerWeightsJoint2verts(currentNode, pController); 308| 2| } 309| 8| } 310| 2|} ColladaParser.cpp:_ZL26ReadControllerWeightsInputRKN4pugi8xml_nodeERN6Assimp7Collada10ControllerE: 227| 4|static void ReadControllerWeightsInput(const XmlNode ¤tNode, Controller &pController) { 228| 4| InputChannel channel; 229| | 230| 4| const char *attrSemantic = currentNode.attribute("semantic").as_string(); 231| 4| const char *attrSource = currentNode.attribute("source").as_string(); 232| 4| channel.mOffset = currentNode.attribute("offset").as_int(); 233| | 234| | // local URLS always start with a '#'. We don't support global URLs 235| 4| if (attrSource[0] != '#') { ------------------ | Branch (235:9): [True: 0, False: 4] ------------------ 236| 0| throw DeadlyImportError("Unsupported URL format in \"", attrSource, "\" in source attribute of data element"); 237| 0| } 238| 4| channel.mAccessor = attrSource + 1; 239| | 240| | // parse source URL to corresponding source 241| 4| if (strcmp(attrSemantic, "JOINT") == 0) { ------------------ | Branch (241:9): [True: 2, False: 2] ------------------ 242| 2| pController.mWeightInputJoints = channel; 243| 2| } else if (strcmp(attrSemantic, "WEIGHT") == 0) { ------------------ | Branch (243:16): [True: 2, False: 0] ------------------ 244| 2| pController.mWeightInputWeights = channel; 245| 2| } else { 246| 0| throw DeadlyImportError("Unknown semantic \"", attrSemantic, "\" in data element"); 247| 0| } 248| 4|} ColladaParser.cpp:_ZL27ReadControllerWeightsVCountRKN4pugi8xml_nodeERN6Assimp7Collada10ControllerE: 251| 2|static void ReadControllerWeightsVCount(const XmlNode ¤tNode, Controller &pController) { 252| 2| const std::string stdText = currentNode.text().as_string(); 253| 2| const char *text = stdText.c_str(); 254| 2| const char *end = text + stdText.size(); 255| 2| size_t numWeights = 0; 256| 146| for (auto it = pController.mWeightCounts.begin(); it != pController.mWeightCounts.end(); ++it) { ------------------ | Branch (256:55): [True: 144, False: 2] ------------------ 257| 144| if (*text == 0) { ------------------ | Branch (257:13): [True: 0, False: 144] ------------------ 258| 0| throw DeadlyImportError("Out of data while reading "); 259| 0| } 260| | 261| 144| *it = strtoul10(text, &text); 262| 144| numWeights += *it; 263| 144| SkipSpacesAndLineEnd(&text, end); 264| 144| } 265| | // reserve weight count 266| 2| pController.mWeights.resize(numWeights); 267| 2|} ColladaParser.cpp:_ZL32ReadControllerWeightsJoint2vertsRN4pugi8xml_nodeERN6Assimp7Collada10ControllerE: 270| 2|static void ReadControllerWeightsJoint2verts(XmlNode ¤tNode, Controller &pController) { 271| | // read JointIndex - WeightIndex pairs 272| 2| std::string stdText; 273| 2| XmlParser::getValueAsString(currentNode, stdText); 274| 2| const char *text = stdText.c_str(); 275| 2| const char *end = text + stdText.size(); 276| 222| for (auto it = pController.mWeights.begin(); it != pController.mWeights.end(); ++it) { ------------------ | Branch (276:50): [True: 220, False: 2] ------------------ 277| 220| if (text == nullptr) { ------------------ | Branch (277:13): [True: 0, False: 220] ------------------ 278| 0| throw DeadlyImportError("Out of data while reading "); 279| 0| } 280| 220| SkipSpacesAndLineEnd(&text, end); 281| 220| it->first = strtoul10(text, &text); 282| 220| SkipSpacesAndLineEnd(&text, end); 283| 220| if (*text == 0) { ------------------ | Branch (283:13): [True: 0, False: 220] ------------------ 284| 0| throw DeadlyImportError("Out of data while reading "); 285| 0| } 286| 220| it->second = strtoul10(text, &text); 287| 220| SkipSpacesAndLineEnd(&text, end); 288| 220| } 289| | 290| 2|} ColladaParser.cpp:_ZL12ReadMaterialRKN4pugi8xml_nodeERN6Assimp7Collada8MaterialE: 314| 36|static void ReadMaterial(const XmlNode &node, Material &pMaterial) { 315| 36| for (XmlNode ¤tNode : node.children()) { ------------------ | Branch (315:31): [True: 36, False: 36] ------------------ 316| 36| const std::string ¤tName = currentNode.name(); 317| 36| if (currentName == "instance_effect") { ------------------ | Branch (317:13): [True: 36, False: 0] ------------------ 318| 36| std::string url; 319| 36| readUrlAttribute(currentNode, url); 320| 36| pMaterial.mEffect = url; 321| 36| } 322| 36| } 323| 36|} ColladaParser.cpp:_ZL9ReadLightRN4pugi8xml_nodeERN6Assimp7Collada5LightE: 327| 15|static void ReadLight(XmlNode &node, Light &pLight) { 328| 15| XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); 329| 15| XmlNode currentNode; 330| | // TODO: Check the current technique and skip over unsupported extra techniques 331| | 332| 371| while (xmlIt.getNext(currentNode)) { ------------------ | Branch (332:12): [True: 356, False: 15] ------------------ 333| 356| const std::string ¤tName = currentNode.name(); 334| 356| if (currentName == "spot") { ------------------ | Branch (334:13): [True: 1, False: 355] ------------------ 335| 1| pLight.mType = aiLightSource_SPOT; 336| 355| } else if (currentName == "ambient") { ------------------ | Branch (336:20): [True: 1, False: 354] ------------------ 337| 1| pLight.mType = aiLightSource_AMBIENT; 338| 354| } else if (currentName == "directional") { ------------------ | Branch (338:20): [True: 5, False: 349] ------------------ 339| 5| pLight.mType = aiLightSource_DIRECTIONAL; 340| 349| } else if (currentName == "point") { ------------------ | Branch (340:20): [True: 8, False: 341] ------------------ 341| 8| pLight.mType = aiLightSource_POINT; 342| 341| } else if (currentName == "color") { ------------------ | Branch (342:20): [True: 15, False: 326] ------------------ 343| | // text content contains 3 floats 344| 15| std::string v; 345| 15| XmlParser::getValueAsString(currentNode, v); 346| 15| const char *content = v.c_str(); 347| 15| const char *end = content + v.size(); 348| | 349| 15| content = fast_atoreal_move(content, pLight.mColor.r); 350| 15| SkipSpacesAndLineEnd(&content, end); 351| | 352| 15| content = fast_atoreal_move(content, pLight.mColor.g); 353| 15| SkipSpacesAndLineEnd(&content, end); 354| | 355| 15| content = fast_atoreal_move(content, pLight.mColor.b); 356| 15| SkipSpacesAndLineEnd(&content, end); 357| 326| } else if (currentName == "constant_attenuation") { ------------------ | Branch (357:20): [True: 9, False: 317] ------------------ 358| 9| XmlParser::getValueAsReal(currentNode, pLight.mAttConstant); 359| 317| } else if (currentName == "linear_attenuation") { ------------------ | Branch (359:20): [True: 9, False: 308] ------------------ 360| 9| XmlParser::getValueAsReal(currentNode, pLight.mAttLinear); 361| 308| } else if (currentName == "quadratic_attenuation") { ------------------ | Branch (361:20): [True: 9, False: 299] ------------------ 362| 9| XmlParser::getValueAsReal(currentNode, pLight.mAttQuadratic); 363| 299| } else if (currentName == "falloff_angle") { ------------------ | Branch (363:20): [True: 1, False: 298] ------------------ 364| 1| XmlParser::getValueAsReal(currentNode, pLight.mFalloffAngle); 365| 298| } else if (currentName == "falloff_exponent") { ------------------ | Branch (365:20): [True: 1, False: 297] ------------------ 366| 1| XmlParser::getValueAsReal(currentNode, pLight.mFalloffExponent); 367| 1| } 368| | // FCOLLADA extensions 369| | // ------------------------------------------------------- 370| 297| else if (currentName == "outer_cone") { ------------------ | Branch (370:18): [True: 0, False: 297] ------------------ 371| 0| XmlParser::getValueAsReal(currentNode, pLight.mOuterAngle); 372| 297| } else if (currentName == "penumbra_angle") { // this one is deprecated, now calculated using outer_cone ------------------ | Branch (372:20): [True: 0, False: 297] ------------------ 373| 0| XmlParser::getValueAsReal(currentNode, pLight.mPenumbraAngle); 374| 297| } else if (currentName == "intensity") { ------------------ | Branch (374:20): [True: 1, False: 296] ------------------ 375| 1| XmlParser::getValueAsReal(currentNode, pLight.mIntensity); 376| 296| } else if (currentName == "falloff") { ------------------ | Branch (376:20): [True: 0, False: 296] ------------------ 377| 0| XmlParser::getValueAsReal(currentNode, pLight.mOuterAngle); 378| 296| } else if (currentName == "hotspot_beam") { ------------------ | Branch (378:20): [True: 0, False: 296] ------------------ 379| 0| XmlParser::getValueAsReal(currentNode, pLight.mFalloffAngle); 380| 0| } 381| | // OpenCOLLADA extensions 382| | // ------------------------------------------------------- 383| 296| else if (currentName == "decay_falloff") { ------------------ | Branch (383:18): [True: 0, False: 296] ------------------ 384| 0| XmlParser::getValueAsReal(currentNode, pLight.mOuterAngle); 385| 0| } 386| 356| } 387| 15|} ColladaParser.cpp:_ZL10ReadCameraRN4pugi8xml_nodeERN6Assimp7Collada6CameraE: 391| 10|static void ReadCamera(XmlNode &node, Camera &camera) { 392| 10| XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); 393| 10| XmlNode currentNode; 394| 80| while (xmlIt.getNext(currentNode)) { ------------------ | Branch (394:12): [True: 70, False: 10] ------------------ 395| 70| const std::string ¤tName = currentNode.name(); 396| 70| if (currentName == "orthographic") { ------------------ | Branch (396:13): [True: 0, False: 70] ------------------ 397| 0| camera.mOrtho = true; 398| 70| } else if (currentName == "xfov" || currentName == "xmag") { ------------------ | Branch (398:20): [True: 0, False: 70] | Branch (398:45): [True: 0, False: 70] ------------------ 399| 0| XmlParser::getValueAsReal(currentNode, camera.mHorFov); 400| 70| } else if (currentName == "yfov" || currentName == "ymag") { ------------------ | Branch (400:20): [True: 10, False: 60] | Branch (400:45): [True: 0, False: 60] ------------------ 401| 10| XmlParser::getValueAsReal(currentNode, camera.mVerFov); 402| 60| } else if (currentName == "aspect_ratio") { ------------------ | Branch (402:20): [True: 10, False: 50] ------------------ 403| 10| XmlParser::getValueAsReal(currentNode, camera.mAspect); 404| 50| } else if (currentName == "znear") { ------------------ | Branch (404:20): [True: 10, False: 40] ------------------ 405| 10| XmlParser::getValueAsReal(currentNode, camera.mZNear); 406| 40| } else if (currentName == "zfar") { ------------------ | Branch (406:20): [True: 10, False: 30] ------------------ 407| 10| XmlParser::getValueAsReal(currentNode, camera.mZFar); 408| 10| } 409| 70| } 410| 10|} ColladaParser.cpp:_ZL22ReadNodeTransformationRN4pugi8xml_nodeEPN6Assimp7Collada4NodeENS3_13TransformTypeE: 106| 799|static void ReadNodeTransformation(XmlNode &node, Node *pNode, TransformType pType) { 107| 799| if (node.empty()) { ------------------ | Branch (107:9): [True: 0, False: 799] ------------------ 108| 0| return; 109| 0| } 110| | 111| 799| std::string tagName = node.name(); 112| | 113| 799| Transform tf; 114| 799| tf.mType = pType; 115| | 116| | // read SID 117| 799| if (XmlParser::hasAttribute(node, "sid")) { ------------------ | Branch (117:9): [True: 543, False: 256] ------------------ 118| 543| XmlParser::getStdStrAttribute(node, "sid", tf.mID); 119| 543| } 120| | 121| | // how many parameters to read per transformation type 122| 799| static constexpr unsigned int sNumParameters[] = { 9, 4, 3, 3, 7, 16 }; 123| 799| std::string value; 124| 799| XmlParser::getValueAsString(node, value); 125| 799| const char *content = value.c_str(); 126| 799| const char *end = value.c_str() + value.size(); 127| | // read as many parameters and store in the transformation 128| 4.06k| for (unsigned int a = 0; a < sNumParameters[pType]; a++) { ------------------ | Branch (128:30): [True: 3.26k, False: 799] ------------------ 129| | // skip whitespace before the number 130| 3.26k| SkipSpacesAndLineEnd(&content, end); 131| | // read a number 132| 3.26k| content = fast_atoreal_move(content, tf.f[a]); 133| 3.26k| } 134| | 135| | // place the transformation at the queue of the node 136| 799| pNode->mTransforms.push_back(tf); 137| 799|} _ZNK6Assimp13ColladaParser23ResolveLibraryReferenceIPNS_7Collada4MeshEEERKT_RKNSt3__13mapINS8_12basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEES5_NS8_4lessISF_EENSD_INS8_4pairIKSF_S5_EEEEEERSJ_: 309| 1|const Type &ColladaParser::ResolveLibraryReference(const std::map &pLibrary, const std::string &pURL) const { 310| 1| typename std::map::const_iterator it = pLibrary.find(pURL); 311| 1| if (it == pLibrary.end()) { ------------------ | Branch (311:9): [True: 0, False: 1] ------------------ 312| 0| throw DeadlyImportError("Unable to resolve library reference \"", pURL, "\"."); 313| 0| } 314| 1| return it->second; 315| 1|} _ZNK6Assimp13ColladaParser23ResolveLibraryReferenceINS_7Collada8AccessorEEERKT_RKNSt3__13mapINS7_12basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEES4_NS7_4lessISE_EENSC_INS7_4pairIKSE_S4_EEEEEERSI_: 309| 885|const Type &ColladaParser::ResolveLibraryReference(const std::map &pLibrary, const std::string &pURL) const { 310| 885| typename std::map::const_iterator it = pLibrary.find(pURL); 311| 885| if (it == pLibrary.end()) { ------------------ | Branch (311:9): [True: 2, False: 883] ------------------ 312| 2| throw DeadlyImportError("Unable to resolve library reference \"", pURL, "\"."); 313| 2| } 314| 883| return it->second; 315| 885|} _ZNK6Assimp13ColladaParser23ResolveLibraryReferenceINS_7Collada4DataEEERKT_RKNSt3__13mapINS7_12basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEES4_NS7_4lessISE_EENSC_INS7_4pairIKSE_S4_EEEEEERSI_: 309| 868|const Type &ColladaParser::ResolveLibraryReference(const std::map &pLibrary, const std::string &pURL) const { 310| 868| typename std::map::const_iterator it = pLibrary.find(pURL); 311| 868| if (it == pLibrary.end()) { ------------------ | Branch (311:9): [True: 0, False: 868] ------------------ 312| 0| throw DeadlyImportError("Unable to resolve library reference \"", pURL, "\"."); 313| 0| } 314| 868| return it->second; 315| 868|} _ZN6Assimp3DXF10LineReaderC2ERNS_12StreamReaderILb0ELb0EEE: 63| 27| explicit LineReader(StreamReaderLE& reader) : splitter(reader,false,true), groupcode( 0 ), end() { 64| | // empty 65| 27| } _ZNK6Assimp3DXF10LineReader3EndEv: 88| 249k| bool End() const { 89| 249k| return !((bool)*this); 90| 249k| } _ZNK6Assimp3DXF10LineReadercvbEv: 150| 249k| operator bool() const { 151| 249k| return end <= 1; 152| 249k| } _ZNK6Assimp3DXF10LineReader2IsEiPKc: 68| 345k| bool Is(int gc, const char* what) const { 69| 345k| return groupcode == gc && !strcmp(what,value.c_str()); ------------------ | Branch (69:16): [True: 161k, False: 183k] | Branch (69:35): [True: 16.6k, False: 144k] ------------------ 70| 345k| } _ZNK6Assimp3DXF10LineReader2IsEi: 73| 123k| bool Is(int gc) const { 74| 123k| return groupcode == gc; 75| 123k| } _ZNK6Assimp3DXF10LineReader5ValueEv: 83| 11.9k| const std::string& Value() const { 84| 11.9k| return value; 85| 11.9k| } _ZN6Assimp3DXF10LineReaderppEv: 109| 233k| LineReader& operator++() { 110| 233k| if (end) { ------------------ | Branch (110:13): [True: 18, False: 233k] ------------------ 111| 18| if (end == 1) { ------------------ | Branch (111:17): [True: 18, False: 0] ------------------ 112| 18| ++end; 113| 18| } 114| 18| return *this; 115| 18| } 116| | 117| 233k| try { 118| 233k| groupcode = strtol10(splitter->c_str()); 119| 233k| splitter++; 120| | 121| 233k| value = *splitter; 122| 233k| splitter++; 123| | 124| | // automatically skip over {} meta blocks (these are for application use 125| | // and currently not relevant for Assimp). 126| 233k| if (value.length() && value[0] == '{') { ------------------ | Branch (126:17): [True: 232k, False: 1.52k] | Branch (126:35): [True: 237, False: 232k] ------------------ 127| | 128| 237| size_t cnt = 0; 129| 1.66k| for(;splitter->length() && splitter->at(0) != '}'; splitter++, cnt++); ------------------ | Branch (129:22): [True: 1.62k, False: 42] | Branch (129:44): [True: 1.42k, False: 195] ------------------ 130| | 131| 237| splitter++; 132| 237| ASSIMP_LOG_VERBOSE_DEBUG("DXF: skipped over control group (",cnt," lines)"); 133| 237| } 134| 233k| } catch(std::logic_error&) { 135| 20| ai_assert(!splitter); 136| 20| } 137| 233k| if (!splitter) { ------------------ | Branch (137:13): [True: 24, False: 233k] ------------------ 138| 24| end = 1; 139| 24| } 140| 233k| return *this; 141| 233k| } _ZN6Assimp3DXF10LineReaderppEi: 144| 125k| LineReader& operator++(int) { 145| 125k| return ++(*this); 146| 125k| } _ZNK6Assimp3DXF10LineReader9GroupCodeEv: 78| 146k| int GroupCode() const { 79| 146k| return groupcode; 80| 146k| } _ZNK6Assimp3DXF10LineReader12ValueAsFloatEv: 103| 41.1k| ai_real ValueAsFloat() const { 104| 41.1k| return fast_atof(value.c_str()); 105| 41.1k| } _ZN6Assimp3DXF8PolyLineC2Ev: 163| 2.00k| PolyLine() : flags() { 164| | // empty 165| 2.00k| } _ZNK6Assimp3DXF10LineReader16ValueAsSignedIntEv: 98| 18.2k| int ValueAsSignedInt() const { 99| 18.2k| return strtol10(value.c_str()); 100| 18.2k| } _ZNK6Assimp3DXF10LineReader18ValueAsUnsignedIntEv: 93| 20.4k| unsigned int ValueAsUnsignedInt() const { 94| 20.4k| return strtoul10(value.c_str()); 95| 20.4k| } _ZN6Assimp3DXF11InsertBlockC2Ev: 179| 1.34k| InsertBlock() : pos(0.f, 0.f, 0.f), scale(1.f,1.f,1.f), angle(0.0f) { 180| | // empty 181| 1.34k| } _ZNK6Assimp11DXFImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 356| 380|bool DXFImporter::CanRead( const std::string& filename, IOSystem* pIOHandler, bool /*checkSig*/ ) const { 357| 380| static const char *tokens[] = { "SECTION", "HEADER", "ENDSEC", "BLOCKS" }; 358| | return SearchFileHeaderForToken(pIOHandler, filename, tokens, AI_COUNT_OF(tokens), 32); 359| 380|} _ZNK6Assimp11DXFImporter7GetInfoEv: 363| 661|const aiImporterDesc* DXFImporter::GetInfo () const { 364| 661| return &desc; 365| 661|} _ZN6Assimp11DXFImporter14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 369| 27|void DXFImporter::InternReadFile( const std::string& filename, aiScene* pScene, IOSystem* pIOHandler) { 370| 27| std::shared_ptr file = std::shared_ptr( pIOHandler->Open( filename) ); 371| | 372| | // Check whether we can read the file 373| 27| if (file == nullptr) { ------------------ | Branch (373:9): [True: 0, False: 27] ------------------ 374| 0| throw DeadlyImportError( "Failed to open DXF file ", filename, ""); 375| 0| } 376| | 377| | // Check whether this is a binary DXF file - we can't read binary DXF files :-( 378| 27| char buff[AI_DXF_BINARY_IDENT_LEN] = {0}; 379| 27| file->Read(buff,AI_DXF_BINARY_IDENT_LEN,1); 380| | 381| 27| if (0 == memcmp(AI_DXF_BINARY_IDENT,buff,AI_DXF_BINARY_IDENT_LEN)) { ------------------ | Branch (381:9): [True: 0, False: 27] ------------------ 382| 0| throw DeadlyImportError("DXF: Binary files are not supported at the moment"); 383| 0| } 384| | 385| | // DXF files can grow very large, so read them via the StreamReader, 386| | // which will choose a suitable strategy. 387| 27| file->Seek(0,aiOrigin_SET); 388| 27| StreamReaderLE stream( std::move(file) ); 389| | 390| 27| DXF::LineReader reader (stream); 391| 27| DXF::FileData output; 392| | 393| | // now get all lines of the file and process top-level sections 394| 27| bool eof = false; 395| 4.83k| while(!reader.End()) { ------------------ | Branch (395:11): [True: 4.81k, False: 21] ------------------ 396| | 397| | // blocks table - these 'build blocks' are later (in ENTITIES) 398| | // referenced an included via INSERT statements. 399| 4.81k| if (reader.Is(2,"BLOCKS")) { ------------------ | Branch (399:13): [True: 12, False: 4.80k] ------------------ 400| 12| ParseBlocks(reader,output); 401| 12| continue; 402| 12| } 403| | 404| | // primary entity table 405| 4.80k| if (reader.Is(2,"ENTITIES")) { ------------------ | Branch (405:13): [True: 24, False: 4.77k] ------------------ 406| 24| ParseEntities(reader,output); 407| 24| continue; 408| 24| } 409| | 410| | // skip unneeded sections entirely to avoid any problems with them 411| | // altogether. 412| 4.77k| else if (reader.Is(2,"CLASSES") || reader.Is(2,"TABLES")) { ------------------ | Branch (412:18): [True: 0, False: 4.77k] | Branch (412:44): [True: 1, False: 4.77k] ------------------ 413| 1| SkipSection(reader); 414| 1| continue; 415| 1| } 416| | 417| 4.77k| else if (reader.Is(2,"HEADER")) { ------------------ | Branch (417:18): [True: 6, False: 4.77k] ------------------ 418| 6| ParseHeader(reader,output); 419| 6| continue; 420| 6| } 421| | 422| | // comments 423| 4.77k| else if (reader.Is(999)) { ------------------ | Branch (423:18): [True: 0, False: 4.77k] ------------------ 424| 0| ASSIMP_LOG_INFO("DXF Comment: ", reader.Value()); 425| 0| } 426| | 427| | // don't read past the official EOF sign 428| 4.77k| else if (reader.Is(0,"EOF")) { ------------------ | Branch (428:18): [True: 6, False: 4.76k] ------------------ 429| 6| eof = true; 430| 6| break; 431| 6| } 432| | 433| 4.76k| ++reader; 434| 4.76k| } 435| 27| if (!eof) { ------------------ | Branch (435:9): [True: 18, False: 9] ------------------ 436| 18| ASSIMP_LOG_WARN("DXF: EOF reached, but did not encounter DXF EOF marker"); 437| 18| } 438| | 439| 27| ConvertMeshes(pScene,output); 440| | 441| | // Now rotate the whole scene by 90 degrees around the x axis to convert from AutoCAD's to Assimp's coordinate system 442| 27| pScene->mRootNode->mTransformation = aiMatrix4x4( 443| 27| 1.f,0.f,0.f,0.f, 444| 27| 0.f,0.f,1.f,0.f, 445| 27| 0.f,-1.f,0.f,0.f, 446| 27| 0.f,0.f,0.f,1.f) * pScene->mRootNode->mTransformation; 447| 27|} _ZN6Assimp11DXFImporter13ConvertMeshesEP7aiSceneRNS_3DXF8FileDataE: 450| 24|void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output) { 451| | // the process of resolving all the INSERT statements can grow the 452| | // poly-count excessively, so log the original number. 453| | // XXX Option to import blocks as separate nodes? 454| 24| if (!DefaultLogger::isNullLogger()) { ------------------ | Branch (454:9): [True: 0, False: 24] ------------------ 455| 0| unsigned int vcount = 0, icount = 0; 456| 0| for (const DXF::Block& bl : output.blocks) { ------------------ | Branch (456:35): [True: 0, False: 0] ------------------ 457| 0| for (std::shared_ptr pl : bl.lines) { ------------------ | Branch (457:58): [True: 0, False: 0] ------------------ 458| 0| vcount += static_cast(pl->positions.size()); 459| 0| icount += static_cast(pl->counts.size()); 460| 0| } 461| 0| } 462| | 463| 0| ASSIMP_LOG_VERBOSE_DEBUG("DXF: Unexpanded polycount is ", icount, ", vertex count is ", vcount); 464| 0| } 465| | 466| 24| if (output.blocks.empty()) { ------------------ | Branch (466:9): [True: 2, False: 22] ------------------ 467| 2| throw DeadlyImportError("DXF: no data blocks loaded"); 468| 2| } 469| | 470| 22| DXF::Block* entities( nullptr ); 471| | 472| | // index blocks by name 473| 22| DXF::BlockMap blocks_by_name; 474| 40| for (DXF::Block& bl : output.blocks) { ------------------ | Branch (474:25): [True: 40, False: 22] ------------------ 475| 40| blocks_by_name[bl.name] = &bl; 476| 40| if ( !entities && bl.name == AI_DXF_ENTITIES_MAGIC_BLOCK ) { ------------------ | | 334| 35|#define AI_DXF_ENTITIES_MAGIC_BLOCK "$ASSIMP_ENTITIES_MAGIC" ------------------ | Branch (476:14): [True: 35, False: 5] | Branch (476:27): [True: 21, False: 14] ------------------ 477| 21| entities = &bl; 478| 21| } 479| 40| } 480| | 481| 22| if (!entities) { ------------------ | Branch (481:9): [True: 1, False: 21] ------------------ 482| 1| throw DeadlyImportError("DXF: no ENTITIES data block loaded"); 483| 1| } 484| | 485| 21| typedef std::map LayerMap; 486| | 487| 21| LayerMap layers; 488| 21| std::vector< std::vector< const DXF::PolyLine*> > corr; 489| | 490| | // now expand all block references in the primary ENTITIES block 491| | // XXX this involves heavy memory copying, consider a faster solution for future versions. 492| 21| ExpandBlockReferences(*entities,blocks_by_name); 493| | 494| 21| unsigned int cur = 0; 495| 17.1k| for (std::shared_ptr pl : entities->lines) { ------------------ | Branch (495:50): [True: 17.1k, False: 21] ------------------ 496| 17.1k| if (pl->positions.size()) { ------------------ | Branch (496:13): [True: 17.1k, False: 0] ------------------ 497| | 498| 17.1k| std::map::iterator it = layers.find(pl->layer); 499| 17.1k| if (it == layers.end()) { ------------------ | Branch (499:17): [True: 28, False: 17.1k] ------------------ 500| 28| ++pScene->mNumMeshes; 501| | 502| 28| layers[pl->layer] = cur++; 503| | 504| 28| std::vector< const DXF::PolyLine* > pv; 505| 28| pv.push_back(&*pl); 506| | 507| 28| corr.push_back(pv); 508| 28| } 509| 17.1k| else { 510| 17.1k| corr[(*it).second].push_back(&*pl); 511| 17.1k| } 512| 17.1k| } 513| 17.1k| } 514| | 515| 21| if ( 0 == pScene->mNumMeshes) { ------------------ | Branch (515:10): [True: 4, False: 17] ------------------ 516| 4| throw DeadlyImportError("DXF: this file contains no 3d data"); 517| 4| } 518| | 519| 17| pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes ] (); 520| | 521| 28| for(const LayerMap::value_type& elem : layers){ ------------------ | Branch (521:42): [True: 28, False: 15] ------------------ 522| 28| aiMesh* const mesh = pScene->mMeshes[elem.second] = new aiMesh(); 523| 28| mesh->mName.Set(elem.first); 524| | 525| 28| unsigned int cvert = 0,cface = 0; 526| 17.1k| for(const DXF::PolyLine* pl : corr[elem.second]){ ------------------ | Branch (526:37): [True: 17.1k, False: 28] ------------------ 527| | // sum over all faces since we need to 'verbosify' them. 528| 17.1k| cvert += std::accumulate(pl->counts.begin(),pl->counts.end(),0); 529| 17.1k| cface += static_cast(pl->counts.size()); 530| 17.1k| } 531| | 532| 28| aiVector3D* verts = mesh->mVertices = new aiVector3D[cvert]; 533| 28| aiColor4D* colors = mesh->mColors[0] = new aiColor4D[cvert]; 534| 28| aiFace* faces = mesh->mFaces = new aiFace[cface]; 535| | 536| 28| mesh->mNumVertices = cvert; 537| 28| mesh->mNumFaces = cface; 538| | 539| 28| unsigned int prims = 0; 540| 28| unsigned int overall_indices = 0; 541| 17.1k| for(const DXF::PolyLine* pl : corr[elem.second]){ ------------------ | Branch (541:37): [True: 17.1k, False: 26] ------------------ 542| | 543| 17.1k| std::vector::const_iterator it = pl->indices.begin(); 544| 22.4k| for(unsigned int facenumv : pl->counts) { ------------------ | Branch (544:39): [True: 22.4k, False: 17.1k] ------------------ 545| 22.4k| aiFace& face = *faces++; 546| 22.4k| face.mIndices = new unsigned int[face.mNumIndices = facenumv]; 547| | 548| 99.3k| for (unsigned int i = 0; i < facenumv; ++i) { ------------------ | Branch (548:42): [True: 76.9k, False: 22.4k] ------------------ 549| 76.9k| face.mIndices[i] = overall_indices++; 550| | 551| 76.9k| ai_assert(pl->positions.size() == pl->colors.size()); 552| 76.9k| if (*it >= pl->positions.size()) { ------------------ | Branch (552:25): [True: 2, False: 76.9k] ------------------ 553| 2| throw DeadlyImportError("DXF: vertex index out of bounds"); 554| 2| } 555| | 556| 76.9k| *verts++ = pl->positions[*it]; 557| 76.9k| *colors++ = pl->colors[*it++]; 558| 76.9k| } 559| | 560| | // set primitive flags now, this saves the extra pass in ScenePreprocessor. 561| 22.4k| switch(face.mNumIndices) { 562| 149| case 1: ------------------ | Branch (562:21): [True: 149, False: 22.2k] ------------------ 563| 149| prims |= aiPrimitiveType_POINT; 564| 149| break; 565| 402| case 2: ------------------ | Branch (565:21): [True: 402, False: 22.0k] ------------------ 566| 402| prims |= aiPrimitiveType_LINE; 567| 402| break; 568| 11.4k| case 3: ------------------ | Branch (568:21): [True: 11.4k, False: 10.9k] ------------------ 569| 11.4k| prims |= aiPrimitiveType_TRIANGLE; 570| 11.4k| break; 571| 10.4k| default: ------------------ | Branch (571:21): [True: 10.4k, False: 11.9k] ------------------ 572| 10.4k| prims |= aiPrimitiveType_POLYGON; 573| 10.4k| break; 574| 22.4k| } 575| 22.4k| } 576| 17.1k| } 577| | 578| 26| mesh->mPrimitiveTypes = prims; 579| 26| mesh->mMaterialIndex = 0; 580| 26| } 581| | 582| 15| GenerateHierarchy(pScene,output); 583| 15| GenerateMaterials(pScene,output); 584| 15|} _ZN6Assimp11DXFImporter21ExpandBlockReferencesERNS_3DXF5BlockERKNSt3__13mapINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEPKS2_NS4_4lessISB_EENS9_INS4_4pairIKSB_SD_EEEEEE: 588| 21|void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& blocks_by_name) { 589| 1.12k| for (const DXF::InsertBlock& insert : bl.insertions) { ------------------ | Branch (589:41): [True: 1.12k, False: 21] ------------------ 590| | 591| | // first check if the referenced blocks exists ... 592| 1.12k| const DXF::BlockMap::const_iterator it = blocks_by_name.find(insert.name); 593| 1.12k| if (it == blocks_by_name.end()) { ------------------ | Branch (593:13): [True: 644, False: 483] ------------------ 594| 644| ASSIMP_LOG_ERROR("DXF: Failed to resolve block reference: ", insert.name,"; skipping" ); 595| 644| continue; 596| 644| } 597| | 598| | // XXX this would be the place to implement recursive expansion if needed. 599| 483| const DXF::Block& bl_src = *(*it).second; 600| | 601| 483| const size_t size = bl_src.lines.size(); // the size may increase in the loop 602| 16.6k| for (size_t i = 0; i < size; ++i) { ------------------ | Branch (602:28): [True: 16.2k, False: 483] ------------------ 603| 16.2k| std::shared_ptr pl_in = bl_src.lines[i]; 604| 16.2k| if (!pl_in) { ------------------ | Branch (604:17): [True: 0, False: 16.2k] ------------------ 605| 0| ASSIMP_LOG_ERROR("DXF: PolyLine instance is nullptr, skipping."); 606| 0| continue; 607| 0| } 608| | 609| 16.2k| std::shared_ptr pl_out = std::shared_ptr(new DXF::PolyLine(*pl_in)); 610| | 611| 16.2k| if (bl_src.base.Length() || insert.scale.x!=1.f || insert.scale.y!=1.f || insert.scale.z!=1.f || insert.angle || insert.pos.Length()) { ------------------ | Branch (611:17): [True: 15.6k, False: 571] | Branch (611:41): [True: 0, False: 571] | Branch (611:64): [True: 0, False: 571] | Branch (611:87): [True: 0, False: 571] | Branch (611:110): [True: 0, False: 571] | Branch (611:126): [True: 0, False: 571] ------------------ 612| | // manual coordinate system transformation 613| | // XXX order 614| 15.6k| aiMatrix4x4 trafo, tmp; 615| 15.6k| aiMatrix4x4::Translation(-bl_src.base,trafo); 616| | //Need to translate position before scaling the insert 617| | //otherwise the position ends up being the position*scaling 618| | //STH 2024.01.17 619| 15.6k| trafo *= aiMatrix4x4::Translation(insert.pos,tmp); 620| 15.6k| trafo *= aiMatrix4x4::Scaling(insert.scale,tmp); 621| | //trafo *= aiMatrix4x4::Translation(insert.pos,tmp); 622| | 623| | // XXX rotation currently ignored - I didn't find an appropriate sample model. 624| 15.6k| if (insert.angle != 0.f) { ------------------ | Branch (624:21): [True: 0, False: 15.6k] ------------------ 625| 0| ASSIMP_LOG_WARN("DXF: BLOCK rotation not currently implemented"); 626| 0| } 627| | 628| 55.4k| for (aiVector3D& v : pl_out->positions) { ------------------ | Branch (628:36): [True: 55.4k, False: 15.6k] ------------------ 629| 55.4k| v *= trafo; 630| 55.4k| } 631| 15.6k| } 632| | 633| 16.2k| bl.lines.push_back(pl_out); 634| 16.2k| } 635| 483| } 636| 21|} _ZN6Assimp11DXFImporter17GenerateMaterialsEP7aiSceneRNS_3DXF8FileDataE: 639| 15|void DXFImporter::GenerateMaterials(aiScene* pScene, DXF::FileData& /*output*/) { 640| | // generate an almost-white default material. Reason: 641| | // the default vertex color is GREY, so we are 642| | // already at Assimp's usual default color. 643| | // generate a default material 644| 15| aiMaterial* pcMat = new aiMaterial(); 645| 15| aiString s; 646| 15| s.Set(AI_DEFAULT_MATERIAL_NAME); 647| 15| pcMat->AddProperty(&s, AI_MATKEY_NAME); 648| | 649| 15| aiColor4D clrDiffuse(0.9f,0.9f,0.9f,1.0f); 650| 15| pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_DIFFUSE); 651| | 652| 15| clrDiffuse = aiColor4D(1.0f,1.0f,1.0f,1.0f); 653| 15| pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_SPECULAR); 654| | 655| 15| clrDiffuse = aiColor4D(0.05f,0.05f,0.05f,1.0f); 656| 15| pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_AMBIENT); 657| | 658| 15| pScene->mNumMaterials = 1; 659| 15| pScene->mMaterials = new aiMaterial*[1]; 660| 15| pScene->mMaterials[0] = pcMat; 661| 15|} _ZN6Assimp11DXFImporter17GenerateHierarchyEP7aiSceneRNS_3DXF8FileDataE: 664| 15|void DXFImporter::GenerateHierarchy(aiScene* pScene, DXF::FileData& /*output*/) { 665| | // generate the output scene graph, which is just the root node with a single child for each layer. 666| 15| pScene->mRootNode = new aiNode(); 667| 15| pScene->mRootNode->mName.Set(""); 668| | 669| 15| if (1 == pScene->mNumMeshes) { ------------------ | Branch (669:9): [True: 13, False: 2] ------------------ 670| 13| pScene->mRootNode->mMeshes = new unsigned int[ pScene->mRootNode->mNumMeshes = 1 ]; 671| 13| pScene->mRootNode->mMeshes[0] = 0; 672| 13| } else { 673| 2| pScene->mRootNode->mChildren = new aiNode*[ pScene->mRootNode->mNumChildren = pScene->mNumMeshes ]; 674| 15| for (unsigned int m = 0; m < pScene->mRootNode->mNumChildren;++m) { ------------------ | Branch (674:34): [True: 13, False: 2] ------------------ 675| 13| aiNode* p = pScene->mRootNode->mChildren[m] = new aiNode(); 676| 13| p->mName = pScene->mMeshes[m]->mName; 677| | 678| 13| p->mMeshes = new unsigned int[p->mNumMeshes = 1]; 679| 13| p->mMeshes[0] = m; 680| 13| p->mParent = pScene->mRootNode; 681| 13| } 682| 2| } 683| 15|} _ZN6Assimp11DXFImporter11SkipSectionERNS_3DXF10LineReaderE: 687| 1|void DXFImporter::SkipSection(DXF::LineReader& reader) { 688| 2| for( ;!reader.End() && !reader.Is(0,"ENDSEC"); reader++); ------------------ | Branch (688:11): [True: 2, False: 0] | Branch (688:28): [True: 1, False: 1] ------------------ 689| 1|} _ZN6Assimp11DXFImporter11ParseHeaderERNS_3DXF10LineReaderERNS1_8FileDataE: 692| 6|void DXFImporter::ParseHeader(DXF::LineReader& reader, DXF::FileData& ) { 693| 2.48k| for( ;!reader.End() && !reader.Is(0,"ENDSEC"); reader++); ------------------ | Branch (693:11): [True: 2.48k, False: 0] | Branch (693:28): [True: 2.47k, False: 6] ------------------ 694| 6|} _ZN6Assimp11DXFImporter11ParseBlocksERNS_3DXF10LineReaderERNS1_8FileDataE: 697| 12|void DXFImporter::ParseBlocks(DXF::LineReader& reader, DXF::FileData& output) { 698| 56.6k| while( !reader.End() && !reader.Is(0,"ENDSEC")) { ------------------ | Branch (698:12): [True: 56.6k, False: 6] | Branch (698:29): [True: 56.6k, False: 6] ------------------ 699| 56.6k| if (reader.Is(0,"BLOCK")) { ------------------ | Branch (699:13): [True: 19, False: 56.6k] ------------------ 700| 19| ParseBlock(++reader,output); 701| 19| continue; 702| 19| } 703| 56.6k| ++reader; 704| 56.6k| } 705| | 706| | ASSIMP_LOG_VERBOSE_DEBUG("DXF: got ", output.blocks.size()," entries in BLOCKS" ); 707| 12|} _ZN6Assimp11DXFImporter10ParseBlockERNS_3DXF10LineReaderERNS1_8FileDataE: 710| 19|void DXFImporter::ParseBlock(DXF::LineReader& reader, DXF::FileData& output) { 711| | // push a new block onto the stack. 712| 19| output.blocks.emplace_back(); 713| 19| DXF::Block& block = output.blocks.back(); 714| | 715| 1.25k| while( !reader.End() && !reader.Is(0,"ENDBLK")) { ------------------ | Branch (715:12): [True: 1.24k, False: 4] | Branch (715:29): [True: 1.23k, False: 8] ------------------ 716| | 717| 1.23k| switch(reader.GroupCode()) { ------------------ | Branch (717:16): [True: 90, False: 1.14k] ------------------ 718| 18| case GroupCode_Name: ------------------ | Branch (718:13): [True: 18, False: 1.22k] ------------------ 719| 18| block.name = reader.Value(); 720| 18| break; 721| | 722| 7| case GroupCode_XComp: ------------------ | Branch (722:13): [True: 7, False: 1.23k] ------------------ 723| 7| block.base.x = reader.ValueAsFloat(); 724| 7| break; 725| 7| case GroupCode_YComp: ------------------ | Branch (725:13): [True: 7, False: 1.23k] ------------------ 726| 7| block.base.y = reader.ValueAsFloat(); 727| 7| break; 728| 58| case GroupCode_ZComp: ------------------ | Branch (728:13): [True: 58, False: 1.18k] ------------------ 729| 58| block.base.z = reader.ValueAsFloat(); 730| 58| break; 731| 1.23k| } 732| | 733| 1.23k| if (reader.Is(0,"POLYLINE")) { ------------------ | Branch (733:13): [True: 1, False: 1.23k] ------------------ 734| 1| ParsePolyLine(++reader,output); 735| 1| continue; 736| 1| } 737| | 738| | // XXX is this a valid case? 739| 1.23k| if (reader.Is(0,"INSERT")) { ------------------ | Branch (739:13): [True: 7, False: 1.23k] ------------------ 740| 7| ASSIMP_LOG_WARN("DXF: INSERT within a BLOCK not currently supported; skipping"); 741| 1.88k| for( ;!reader.End() && !reader.Is(0,"ENDBLK"); ++reader); ------------------ | Branch (741:19): [True: 1.88k, False: 1] | Branch (741:36): [True: 1.87k, False: 6] ------------------ 742| 7| break; 743| 7| } 744| | 745| 1.23k| else if (reader.Is(0,"3DFACE") || reader.Is(0,"LINE") || reader.Is(0,"3DLINE")) { ------------------ | Branch (745:18): [True: 0, False: 1.23k] | Branch (745:43): [True: 238, False: 993] | Branch (745:66): [True: 0, False: 993] ------------------ 746| | //http://sourceforge.net/tracker/index.php?func=detail&aid=2970566&group_id=226462&atid=1067632 747| 238| Parse3DFace(++reader, output); 748| 238| continue; 749| 238| } 750| 993| ++reader; 751| 993| } 752| 19|} _ZN6Assimp11DXFImporter13ParseEntitiesERNS_3DXF10LineReaderERNS1_8FileDataE: 755| 24|void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output) { 756| | // Push a new block onto the stack. 757| 24| output.blocks.emplace_back(); 758| 24| DXF::Block& block = output.blocks.back(); 759| | 760| 24| block.name = AI_DXF_ENTITIES_MAGIC_BLOCK; ------------------ | | 334| 24|#define AI_DXF_ENTITIES_MAGIC_BLOCK "$ASSIMP_ENTITIES_MAGIC" ------------------ 761| | 762| 20.5k| while( !reader.End() && !reader.Is(0,"ENDSEC")) { ------------------ | Branch (762:12): [True: 20.5k, False: 13] | Branch (762:29): [True: 20.4k, False: 11] ------------------ 763| 20.4k| if (reader.Is(0,"POLYLINE")) { ------------------ | Branch (763:13): [True: 368, False: 20.1k] ------------------ 764| 368| ParsePolyLine(++reader,output); 765| 368| continue; 766| 368| } 767| | 768| 20.1k| else if (reader.Is(0,"INSERT")) { ------------------ | Branch (768:18): [True: 1.34k, False: 18.7k] ------------------ 769| 1.34k| ParseInsertion(++reader,output); 770| 1.34k| continue; 771| 1.34k| } 772| | 773| 18.7k| else if (reader.Is(0,"3DFACE") || reader.Is(0,"LINE") || reader.Is(0,"3DLINE")) { ------------------ | Branch (773:18): [True: 685, False: 18.0k] | Branch (773:43): [True: 710, False: 17.3k] | Branch (773:66): [True: 0, False: 17.3k] ------------------ 774| | //http://sourceforge.net/tracker/index.php?func=detail&aid=2970566&group_id=226462&atid=1067632 775| 1.39k| Parse3DFace(++reader, output); 776| 1.39k| continue; 777| 1.39k| } 778| | 779| 17.3k| ++reader; 780| 17.3k| } 781| | 782| | ASSIMP_LOG_VERBOSE_DEBUG( "DXF: got ", block.lines.size()," polylines and ", block.insertions.size(), 783| 24| " inserted blocks in ENTITIES" ); 784| 24|} _ZN6Assimp11DXFImporter14ParseInsertionERNS_3DXF10LineReaderERNS1_8FileDataE: 786| 1.34k|void DXFImporter::ParseInsertion(DXF::LineReader& reader, DXF::FileData& output) { 787| 1.34k| output.blocks.back().insertions.emplace_back(); 788| 1.34k| DXF::InsertBlock& bl = output.blocks.back().insertions.back(); 789| | 790| 2.47k| while( !reader.End() && !reader.Is(0)) { ------------------ | Branch (790:12): [True: 2.47k, False: 0] | Branch (790:29): [True: 1.12k, False: 1.34k] ------------------ 791| 1.12k| switch(reader.GroupCode()) { ------------------ | Branch (791:16): [True: 907, False: 219] ------------------ 792| | // name of referenced block 793| 763| case GroupCode_Name: ------------------ | Branch (793:9): [True: 763, False: 363] ------------------ 794| 763| bl.name = reader.Value(); 795| 763| break; 796| | 797| | // translation 798| 2| case GroupCode_XComp: ------------------ | Branch (798:9): [True: 2, False: 1.12k] ------------------ 799| 2| bl.pos.x = reader.ValueAsFloat(); 800| 2| break; 801| 3| case GroupCode_YComp: ------------------ | Branch (801:9): [True: 3, False: 1.12k] ------------------ 802| 3| bl.pos.y = reader.ValueAsFloat(); 803| 3| break; 804| 7| case GroupCode_ZComp: ------------------ | Branch (804:9): [True: 7, False: 1.11k] ------------------ 805| 7| bl.pos.z = reader.ValueAsFloat(); 806| 7| break; 807| | 808| | // scaling 809| 2| case 41: ------------------ | Branch (809:9): [True: 2, False: 1.12k] ------------------ 810| 2| bl.scale.x = reader.ValueAsFloat(); 811| 2| break; 812| 2| case 42: ------------------ | Branch (812:9): [True: 2, False: 1.12k] ------------------ 813| 2| bl.scale.y = reader.ValueAsFloat(); 814| 2| break; 815| 2| case 43: ------------------ | Branch (815:9): [True: 2, False: 1.12k] ------------------ 816| 2| bl.scale.z = reader.ValueAsFloat(); 817| 2| break; 818| | 819| | // rotation angle 820| 126| case 50: ------------------ | Branch (820:9): [True: 126, False: 1.00k] ------------------ 821| 126| bl.angle = reader.ValueAsFloat(); 822| 126| break; 823| 1.12k| } 824| 1.12k| reader++; 825| 1.12k| } 826| 1.34k|} _ZN6Assimp11DXFImporter13ParsePolyLineERNS_3DXF10LineReaderERNS1_8FileDataE: 835| 369|void DXFImporter::ParsePolyLine(DXF::LineReader& reader, DXF::FileData& output) { 836| 369| output.blocks.back().lines.push_back( std::shared_ptr( new DXF::PolyLine() ) ); 837| 369| DXF::PolyLine& line = *output.blocks.back().lines.back(); 838| | 839| 369| unsigned int iguess = 0, vguess = 0; 840| 31.6k| while( !reader.End() && !reader.Is(0,"ENDSEC")) { ------------------ | Branch (840:12): [True: 31.6k, False: 2] | Branch (840:29): [True: 31.6k, False: 0] ------------------ 841| | 842| 31.6k| if (reader.Is(0,"VERTEX")) { ------------------ | Branch (842:13): [True: 12.8k, False: 18.7k] ------------------ 843| 12.8k| ParsePolyLineVertex(++reader,line); 844| 12.8k| if (reader.Is(0,"SEQEND")) { ------------------ | Branch (844:17): [True: 367, False: 12.4k] ------------------ 845| 367| break; 846| 367| } 847| 12.4k| continue; 848| 12.8k| } 849| | 850| 18.7k| switch(reader.GroupCode()) ------------------ | Branch (850:16): [True: 793, False: 17.9k] ------------------ 851| 18.7k| { 852| | // flags --- important that we know whether it is a 853| | // polyface mesh or 'just' a line. 854| 737| case 70: ------------------ | Branch (854:9): [True: 737, False: 18.0k] ------------------ 855| 737| if (!line.flags) { ------------------ | Branch (855:17): [True: 367, False: 370] ------------------ 856| 367| line.flags = reader.ValueAsSignedInt(); 857| 367| } 858| 737| break; 859| | 860| | // optional number of vertices 861| 20| case 71: ------------------ | Branch (861:9): [True: 20, False: 18.7k] ------------------ 862| 20| vguess = reader.ValueAsSignedInt(); 863| 20| line.positions.reserve(vguess); 864| 20| break; 865| | 866| | // optional number of faces 867| 23| case 72: ------------------ | Branch (867:9): [True: 23, False: 18.7k] ------------------ 868| 23| iguess = reader.ValueAsSignedInt(); 869| 23| line.indices.reserve(iguess); 870| 23| break; 871| | 872| | // 8 specifies the layer on which this line is placed on 873| 13| case 8: ------------------ | Branch (873:9): [True: 13, False: 18.7k] ------------------ 874| 13| line.layer = reader.Value(); 875| 13| break; 876| 18.7k| } 877| | 878| 18.7k| reader++; 879| 18.7k| } 880| | 881| 369| if (vguess && line.positions.size() != vguess) { ------------------ | Branch (881:9): [True: 12, False: 357] | Branch (881:19): [True: 3, False: 9] ------------------ 882| 3| ASSIMP_LOG_WARN("DXF: unexpected vertex count in polymesh: ", 883| 3| line.positions.size(),", expected ", vguess ); 884| 3| } 885| | 886| 369| if (line.flags & DXF_POLYLINE_FLAG_POLYFACEMESH ) { ------------------ | Branch (886:9): [True: 365, False: 4] ------------------ 887| 365| if (line.positions.size() < 3 || line.indices.size() < 3) { ------------------ | Branch (887:13): [True: 0, False: 365] | Branch (887:42): [True: 354, False: 11] ------------------ 888| 354| ASSIMP_LOG_WARN("DXF: not enough vertices for polymesh; ignoring"); 889| 354| output.blocks.back().lines.pop_back(); 890| 354| return; 891| 354| } 892| | 893| | // if these numbers are wrong, parsing might have gone wild. 894| | // however, the docs state that applications are not required 895| | // to set the 71 and 72 fields, respectively, to valid values. 896| | // So just fire a warning. 897| 11| if (iguess && line.counts.size() != iguess) { ------------------ | Branch (897:13): [True: 11, False: 0] | Branch (897:23): [True: 2, False: 9] ------------------ 898| 2| ASSIMP_LOG_WARN( "DXF: unexpected face count in polymesh: ", line.counts.size(),", expected ", iguess ); 899| 2| } 900| 11| } 901| 4| else if (!line.indices.size() && !line.counts.size()) { ------------------ | Branch (901:14): [True: 3, False: 1] | Branch (901:38): [True: 3, False: 0] ------------------ 902| | // a poly-line - so there are no indices yet. 903| 3| size_t guess = line.positions.size() + (line.flags & DXF_POLYLINE_FLAG_CLOSED ? 1 : 0); ------------------ | Branch (903:49): [True: 1, False: 2] ------------------ 904| 3| line.indices.reserve(guess); 905| | 906| 3| line.counts.reserve(guess/2); 907| 8| for (unsigned int i = 0; i < line.positions.size()/2; ++i) { ------------------ | Branch (907:34): [True: 5, False: 3] ------------------ 908| 5| line.indices.push_back(i*2); 909| 5| line.indices.push_back(i*2+1); 910| 5| line.counts.push_back(2); 911| 5| } 912| | 913| | // closed polyline? 914| 3| if (line.flags & DXF_POLYLINE_FLAG_CLOSED) { ------------------ | Branch (914:13): [True: 1, False: 2] ------------------ 915| 1| line.indices.push_back(static_cast(line.positions.size()-1)); 916| 1| line.indices.push_back(0); 917| 1| line.counts.push_back(2); 918| 1| } 919| 3| } 920| 369|} _ZN6Assimp11DXFImporter19ParsePolyLineVertexERNS_3DXF10LineReaderERNS1_8PolyLineE: 926| 12.8k|void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& line) { 927| 12.8k| unsigned int cnti = 0, flags = 0; 928| 12.8k| unsigned int indices[4]; 929| | 930| 12.8k| aiVector3D out; 931| 12.8k| aiColor4D clr = AI_DXF_DEFAULT_COLOR; 932| | 933| 116k| while( !reader.End() ) { ------------------ | Branch (933:12): [True: 116k, False: 1] ------------------ 934| | 935| 116k| if (reader.Is(0)) { // SEQEND or another VERTEX ------------------ | Branch (935:13): [True: 12.8k, False: 103k] ------------------ 936| 12.8k| break; 937| 12.8k| } 938| | 939| 103k| switch (reader.GroupCode()) { ------------------ | Branch (939:17): [True: 81.2k, False: 22.2k] ------------------ 940| 10.7k| case 8: ------------------ | Branch (940:9): [True: 10.7k, False: 92.7k] ------------------ 941| | // layer to which the vertex belongs to - assume that 942| | // this is always the layer the top-level poly-line 943| | // entity resides on as well. 944| 10.7k| if(reader.Value() != line.layer) { ------------------ | Branch (944:20): [True: 0, False: 10.7k] ------------------ 945| 0| ASSIMP_LOG_WARN("DXF: expected vertex to be part of a poly-face but the 0x128 flag isn't set"); 946| 0| } 947| 10.7k| break; 948| | 949| 12.7k| case 70: ------------------ | Branch (949:9): [True: 12.7k, False: 90.7k] ------------------ 950| 12.7k| flags = reader.ValueAsUnsignedInt(); 951| 12.7k| break; 952| | 953| | // VERTEX COORDINATES 954| 10.7k| case GroupCode_XComp: ------------------ | Branch (954:9): [True: 10.7k, False: 92.7k] ------------------ 955| 10.7k| out.x = reader.ValueAsFloat(); 956| 10.7k| break; 957| | 958| 10.7k| case GroupCode_YComp: ------------------ | Branch (958:9): [True: 10.7k, False: 92.7k] ------------------ 959| 10.7k| out.y = reader.ValueAsFloat(); 960| 10.7k| break; 961| | 962| 10.7k| case GroupCode_ZComp: ------------------ | Branch (962:9): [True: 10.7k, False: 92.7k] ------------------ 963| 10.7k| out.z = reader.ValueAsFloat(); 964| 10.7k| break; 965| | 966| | // POLYFACE vertex indices 967| 5.77k| case 71: ------------------ | Branch (967:9): [True: 5.77k, False: 97.7k] ------------------ 968| 11.5k| case 72: ------------------ | Branch (968:9): [True: 5.77k, False: 97.7k] ------------------ 969| 17.3k| case 73: ------------------ | Branch (969:9): [True: 5.77k, False: 97.7k] ------------------ 970| 17.8k| case 74: { ------------------ | Branch (970:9): [True: 527, False: 102k] ------------------ 971| 17.8k| if (cnti == 4) { ------------------ | Branch (971:21): [True: 2, False: 17.8k] ------------------ 972| 2| ASSIMP_LOG_WARN("DXF: more than 4 indices per face not supported; ignoring"); 973| 2| break; 974| 2| } 975| 17.8k| const int index = reader.ValueAsSignedInt(); 976| 17.8k| if (index >= 0) { ------------------ | Branch (976:21): [True: 17.2k, False: 596] ------------------ 977| 17.2k| indices[cnti++] = static_cast(index); 978| 17.2k| } else { 979| 596| indices[cnti++] = static_cast(-index); 980| 596| } 981| 17.8k| } 982| 0| break; 983| | 984| | // color 985| 7.57k| case 62: ------------------ | Branch (985:9): [True: 7.57k, False: 95.9k] ------------------ 986| 7.57k| clr = g_aclrDxfIndexColors[reader.ValueAsUnsignedInt() % AI_DXF_NUM_INDEX_COLORS]; ------------------ | | 333| 7.57k|#define AI_DXF_NUM_INDEX_COLORS (sizeof(g_aclrDxfIndexColors)/sizeof(g_aclrDxfIndexColors[0])) ------------------ 987| 7.57k| break; 988| 103k| }; 989| | 990| 103k| reader++; 991| 103k| } 992| | 993| 12.8k| if (line.flags & DXF_POLYLINE_FLAG_POLYFACEMESH && !(flags & DXF_VERTEX_FLAG_PART_OF_POLYFACE)) { ------------------ | | 922| 11.8k|#define DXF_VERTEX_FLAG_PART_OF_POLYFACE 0x80 ------------------ | Branch (993:9): [True: 11.8k, False: 1.02k] | Branch (993:56): [True: 357, False: 11.4k] ------------------ 994| 357| ASSIMP_LOG_WARN("DXF: expected vertex to be part of a polyface but the 0x128 flag isn't set"); 995| 357| } 996| | 997| 12.8k| if (cnti) { ------------------ | Branch (997:9): [True: 5.91k, False: 6.94k] ------------------ 998| 5.91k| line.counts.push_back(cnti); 999| 23.7k| for (unsigned int i = 0; i < cnti; ++i) { ------------------ | Branch (999:34): [True: 17.8k, False: 5.91k] ------------------ 1000| | // IMPORTANT NOTE: POLYMESH indices are ONE-BASED 1001| 17.8k| if (indices[i] == 0) { ------------------ | Branch (1001:17): [True: 0, False: 17.8k] ------------------ 1002| 0| ASSIMP_LOG_WARN("DXF: invalid vertex index, indices are one-based."); 1003| 0| --line.counts.back(); 1004| | // Workaround to fix issue 2229 1005| 0| if (line.counts.back() == 0) { ------------------ | Branch (1005:21): [True: 0, False: 0] ------------------ 1006| 0| line.counts.pop_back(); 1007| 0| } 1008| 0| continue; 1009| 0| } 1010| 17.8k| line.indices.push_back(indices[i]-1); 1011| 17.8k| } 1012| 6.94k| } else { 1013| 6.94k| line.positions.push_back(out); 1014| 6.94k| line.colors.push_back(clr); 1015| 6.94k| } 1016| 12.8k|} _ZN6Assimp11DXFImporter11Parse3DFaceERNS_3DXF10LineReaderERNS1_8FileDataE: 1019| 1.63k|void DXFImporter::Parse3DFace(DXF::LineReader& reader, DXF::FileData& output) { 1020| | // (note) this is also used for for parsing line entities, so we 1021| | // must handle the vertex_count == 2 case as well. 1022| | 1023| 1.63k| output.blocks.back().lines.push_back( std::shared_ptr( new DXF::PolyLine() ) ); 1024| 1.63k| DXF::PolyLine& line = *output.blocks.back().lines.back(); 1025| | 1026| 1.63k| aiVector3D vip[4]; 1027| 1.63k| aiColor4D clr = AI_DXF_DEFAULT_COLOR; 1028| | 1029| 1.63k| bool b[4] = {false,false,false,false}; 1030| 11.6k| while( !reader.End() ) { ------------------ | Branch (1030:12): [True: 11.6k, False: 2] ------------------ 1031| | 1032| | // next entity with a groupcode == 0 is probably already the next vertex or polymesh entity 1033| 11.6k| if (reader.GroupCode() == 0) { ------------------ | Branch (1033:13): [True: 1.62k, False: 10.0k] ------------------ 1034| 1.62k| break; 1035| 1.62k| } 1036| 10.0k| switch (reader.GroupCode()) { ------------------ | Branch (1036:17): [True: 9.15k, False: 913] ------------------ 1037| | 1038| | // 8 specifies the layer 1039| 352| case 8: ------------------ | Branch (1039:9): [True: 352, False: 9.71k] ------------------ 1040| 352| line.layer = reader.Value(); 1041| 352| break; 1042| | 1043| | // x position of the first corner 1044| 848| case 10: ------------------ | Branch (1044:9): [True: 848, False: 9.22k] ------------------ 1045| 848| vip[0].x = reader.ValueAsFloat(); 1046| 848| b[2] = true; 1047| 848| break; 1048| | 1049| | // y position of the first corner 1050| 288| case 20: ------------------ | Branch (1050:9): [True: 288, False: 9.78k] ------------------ 1051| 288| vip[0].y = reader.ValueAsFloat(); 1052| 288| b[2] = true; 1053| 288| break; 1054| | 1055| | // z position of the first corner 1056| 1.22k| case 30: ------------------ | Branch (1056:9): [True: 1.22k, False: 8.84k] ------------------ 1057| 1.22k| vip[0].z = reader.ValueAsFloat(); 1058| 1.22k| b[2] = true; 1059| 1.22k| break; 1060| | 1061| | // x position of the second corner 1062| 701| case 11: ------------------ | Branch (1062:9): [True: 701, False: 9.36k] ------------------ 1063| 701| vip[1].x = reader.ValueAsFloat(); 1064| 701| b[3] = true; 1065| 701| break; 1066| | 1067| | // y position of the second corner 1068| 288| case 21: ------------------ | Branch (1068:9): [True: 288, False: 9.78k] ------------------ 1069| 288| vip[1].y = reader.ValueAsFloat(); 1070| 288| b[3] = true; 1071| 288| break; 1072| | 1073| | // z position of the second corner 1074| 1.20k| case 31: ------------------ | Branch (1074:9): [True: 1.20k, False: 8.85k] ------------------ 1075| 1.20k| vip[1].z = reader.ValueAsFloat(); 1076| 1.20k| b[3] = true; 1077| 1.20k| break; 1078| | 1079| | // x position of the third corner 1080| 293| case 12: ------------------ | Branch (1080:9): [True: 293, False: 9.77k] ------------------ 1081| 293| vip[2].x = reader.ValueAsFloat(); 1082| 293| b[0] = true; 1083| 293| break; 1084| | 1085| | // y position of the third corner 1086| 288| case 22: ------------------ | Branch (1086:9): [True: 288, False: 9.78k] ------------------ 1087| 288| vip[2].y = reader.ValueAsFloat(); 1088| 288| b[0] = true; 1089| 288| break; 1090| | 1091| | // z position of the third corner 1092| 1.62k| case 32: ------------------ | Branch (1092:9): [True: 1.62k, False: 8.44k] ------------------ 1093| 1.62k| vip[2].z = reader.ValueAsFloat(); 1094| 1.62k| b[0] = true; 1095| 1.62k| break; 1096| | 1097| | // x position of the fourth corner 1098| 645| case 13: ------------------ | Branch (1098:9): [True: 645, False: 9.42k] ------------------ 1099| 645| vip[3].x = reader.ValueAsFloat(); 1100| 645| b[1] = true; 1101| 645| break; 1102| | 1103| | // y position of the fourth corner 1104| 671| case 23: ------------------ | Branch (1104:9): [True: 671, False: 9.39k] ------------------ 1105| 671| vip[3].y = reader.ValueAsFloat(); 1106| 671| b[1] = true; 1107| 671| break; 1108| | 1109| | // z position of the fourth corner 1110| 527| case 33: ------------------ | Branch (1110:9): [True: 527, False: 9.54k] ------------------ 1111| 527| vip[3].z = reader.ValueAsFloat(); 1112| 527| b[1] = true; 1113| 527| break; 1114| | 1115| | // color 1116| 197| case 62: ------------------ | Branch (1116:9): [True: 197, False: 9.87k] ------------------ 1117| 197| clr = g_aclrDxfIndexColors[reader.ValueAsUnsignedInt() % AI_DXF_NUM_INDEX_COLORS]; ------------------ | | 333| 197|#define AI_DXF_NUM_INDEX_COLORS (sizeof(g_aclrDxfIndexColors)/sizeof(g_aclrDxfIndexColors[0])) ------------------ 1118| 197| break; 1119| 10.0k| }; 1120| | 1121| 10.0k| ++reader; 1122| 10.0k| } 1123| | 1124| | // the fourth corner may even be identical to the third, 1125| | // in this case we treat it as if it didn't exist. 1126| 1.63k| if (vip[3] == vip[2]) { ------------------ | Branch (1126:9): [True: 199, False: 1.43k] ------------------ 1127| 199| b[1] = false; 1128| 199| } 1129| | 1130| | // sanity checks to see if we got something meaningful 1131| 1.63k| if ((b[1] && !b[0]) || !b[2] || !b[3]) { ------------------ | Branch (1131:10): [True: 1.00k, False: 627] | Branch (1131:18): [True: 56, False: 947] | Branch (1131:28): [True: 141, False: 1.43k] | Branch (1131:37): [True: 78, False: 1.35k] ------------------ 1132| 275| ASSIMP_LOG_WARN("DXF: unexpected vertex setup in 3DFACE/LINE/FACE entity; ignoring"); 1133| 275| output.blocks.back().lines.pop_back(); 1134| 275| return; 1135| 275| } 1136| | 1137| 1.35k| const unsigned int cnt = (2+(b[0]?1:0)+(b[1]?1:0)); ------------------ | Branch (1137:34): [True: 1.27k, False: 83] | Branch (1137:45): [True: 928, False: 427] ------------------ 1138| 1.35k| line.counts.push_back(cnt); 1139| | 1140| 6.26k| for (unsigned int i = 0; i < cnt; ++i) { ------------------ | Branch (1140:30): [True: 4.91k, False: 1.35k] ------------------ 1141| 4.91k| line.indices.push_back(static_cast(line.positions.size())); 1142| 4.91k| line.positions.push_back(vip[i]); 1143| 4.91k| line.colors.push_back(clr); 1144| 4.91k| } 1145| 1.35k|} _ZN6Assimp11DXFImporterC2Ev: 71| 624| DXFImporter() = default; _ZN6Assimp3FBX4Node9AddP70intERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEi: 64| 39.5k|void FBX::Node::AddP70int(const std::string& cur_name, int32_t value) { 65| 39.5k| FBX::Node n("P"); 66| 39.5k| n.AddProperties(cur_name, "int", "Integer", "", value); 67| 39.5k| AddChild(n); 68| 39.5k|} _ZN6Assimp3FBX4Node10AddP70boolERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb: 70| 43.7k|void FBX::Node::AddP70bool(const std::string& cur_name, bool value) { 71| 43.7k| FBX::Node n("P"); 72| 43.7k| n.AddProperties(cur_name, "bool", "", "", int32_t(value)); 73| 43.7k| AddChild(n); 74| 43.7k|} _ZN6Assimp3FBX4Node12AddP70doubleERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEd: 76| 5.83k|void FBX::Node::AddP70double(const std::string &cur_name, double value) { FBX::Node n("P"); 77| 5.83k| n.AddProperties(cur_name, "double", "Number", "", value); 78| 5.83k| AddChild(n); 79| 5.83k|} _ZN6Assimp3FBX4Node13AddP70numberAERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEd: 81| 6.65k|void FBX::Node::AddP70numberA(const std::string &cur_name, double value) { 82| 6.65k| FBX::Node n("P"); 83| 6.65k| n.AddProperties(cur_name, "Number", "", "A", value); 84| 6.65k| AddChild(n); 85| 6.65k|} _ZN6Assimp3FBX4Node11AddP70colorERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEddd: 88| 964| const std::string &cur_name, double r, double g, double b) { 89| 964| FBX::Node n("P"); 90| 964| n.AddProperties(cur_name, "ColorRGB", "Color", "", r, g, b); 91| 964| AddChild(n); 92| 964|} _ZN6Assimp3FBX4Node12AddP70colorAERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEddd: 95| 1.50k| const std::string &cur_name, double r, double g, double b) { 96| 1.50k| FBX::Node n("P"); 97| 1.50k| n.AddProperties(cur_name, "Color", "", "A", r, g, b); 98| 1.50k| AddChild(n); 99| 1.50k|} _ZN6Assimp3FBX4Node12AddP70vectorERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEddd: 102| 4.74k| const std::string &cur_name, double x, double y, double z) { 103| 4.74k| FBX::Node n("P"); 104| 4.74k| n.AddProperties(cur_name, "Vector3D", "Vector", "", x, y, z); 105| 4.74k| AddChild(n); 106| 4.74k|} _ZN6Assimp3FBX4Node13AddP70vectorAERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEddd: 109| 438| const std::string &cur_name, double x, double y, double z) { 110| 438| FBX::Node n("P"); 111| 438| n.AddProperties(cur_name, "Vector", "", "A", x, y, z); 112| 438| AddChild(n); 113| 438|} _ZN6Assimp3FBX4Node12AddP70stringERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_: 116| 675| const std::string &cur_name, const std::string &value) { 117| 675| FBX::Node n("P"); 118| 675| n.AddProperties(cur_name, "KString", "", "", value); 119| 675| AddChild(n); 120| 675|} _ZN6Assimp3FBX4Node10AddP70enumERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEi: 123| 38.9k| const std::string &cur_name, int32_t value) { 124| 38.9k| FBX::Node n("P"); 125| 38.9k| n.AddProperties(cur_name, "enum", "", "", value); 126| 38.9k| AddChild(n); 127| 38.9k|} _ZN6Assimp3FBX4Node10AddP70timeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEl: 130| 680| const std::string &cur_name, int64_t value) { 131| 680| FBX::Node n("P"); 132| 680| n.AddProperties(cur_name, "KTime", "Time", "", value); 133| 680| AddChild(n); 134| 680|} _ZN6Assimp3FBX4Node4DumpERKNSt3__110shared_ptrINS_8IOStreamEEEbi: 141| 832| bool binary, int indent) { 142| 832| if (binary) { ------------------ | Branch (142:9): [True: 832, False: 0] ------------------ 143| 832| Assimp::StreamWriterLE outstream(outfile); 144| 832| DumpBinary(outstream); 145| 832| } else { 146| 0| std::ostringstream ss; 147| 0| DumpAscii(ss, indent); 148| 0| std::string s = ss.str(); 149| 0| outfile->Write(s.c_str(), s.size(), 1); 150| 0| } 151| 832|} _ZN6Assimp3FBX4Node4DumpERNS_12StreamWriterILb0ELb0EEEbi: 156| 222k|) { 157| 222k| if (binary) { ------------------ | Branch (157:9): [True: 222k, False: 0] ------------------ 158| 222k| DumpBinary(outstream); 159| 222k| } else { 160| 0| std::ostringstream ss; 161| 0| DumpAscii(ss, indent); 162| 0| outstream.PutString(ss.str()); 163| 0| } 164| 222k|} _ZN6Assimp3FBX4Node5BeginERNS_12StreamWriterILb0ELb0EEEbi: 172| 25.7k|) { 173| 25.7k| if (binary) { ------------------ | Branch (173:9): [True: 25.7k, False: 0] ------------------ 174| 25.7k| BeginBinary(s); 175| 25.7k| } else { 176| | // assume we're at the correct place to start already 177| 0| (void)indent; 178| 0| std::ostringstream ss; 179| 0| BeginAscii(ss, indent); 180| 0| s.PutString(ss.str()); 181| 0| } 182| 25.7k|} _ZN6Assimp3FBX4Node14DumpPropertiesERNS_12StreamWriterILb0ELb0EEEbi: 187| 25.1k|) { 188| 25.1k| if (binary) { ------------------ | Branch (188:9): [True: 25.1k, False: 0] ------------------ 189| 25.1k| DumpPropertiesBinary(s); 190| 25.1k| } else { 191| 0| std::ostringstream ss; 192| 0| DumpPropertiesAscii(ss, indent); 193| 0| s.PutString(ss.str()); 194| 0| } 195| 25.1k|} _ZN6Assimp3FBX4Node13EndPropertiesERNS_12StreamWriterILb0ELb0EEEbi: 200| 25.3k|) { 201| 25.3k| EndProperties(s, binary, indent, properties.size()); 202| 25.3k|} _ZN6Assimp3FBX4Node13EndPropertiesERNS_12StreamWriterILb0ELb0EEEbim: 208| 25.5k|) { 209| 25.5k| if (binary) { ------------------ | Branch (209:9): [True: 25.5k, False: 0] ------------------ 210| 25.5k| EndPropertiesBinary(s, num_properties); 211| 25.5k| } else { 212| | // nothing to do 213| 0| (void)indent; 214| 0| } 215| 25.5k|} _ZN6Assimp3FBX4Node13BeginChildrenERNS_12StreamWriterILb0ELb0EEEbi: 220| 25.7k|) { 221| 25.7k| if (binary) { ------------------ | Branch (221:9): [True: 25.7k, False: 0] ------------------ 222| | // nothing to do 223| 25.7k| } else { 224| 0| std::ostringstream ss; 225| 0| BeginChildrenAscii(ss, indent); 226| 0| s.PutString(ss.str()); 227| 0| } 228| 25.7k|} _ZN6Assimp3FBX4Node3EndERNS_12StreamWriterILb0ELb0EEEbib: 248| 25.7k|) { 249| 25.7k| if (binary) { ------------------ | Branch (249:9): [True: 25.7k, False: 0] ------------------ 250| 25.7k| EndBinary(s, has_children); 251| 25.7k| } else { 252| 0| std::ostringstream ss; 253| 0| EndAscii(ss, indent, has_children); 254| 0| if (ss.tellp() > 0) ------------------ | Branch (254:13): [True: 0, False: 0] ------------------ 255| 0| s.PutString(ss.str()); 256| 0| } 257| 25.7k|} _ZN6Assimp3FBX4Node10DumpBinaryERNS_12StreamWriterILb0ELb0EEE: 263| 779k|{ 264| | // write header section (with placeholders for some things) 265| 779k| BeginBinary(s); 266| | 267| | // write properties 268| 779k| DumpPropertiesBinary(s); 269| | 270| | // go back and fill in property related placeholders 271| 779k| EndPropertiesBinary(s, properties.size()); 272| | 273| | // write children 274| 779k| DumpChildrenBinary(s); 275| | 276| | // finish, filling in end offset placeholder 277| 779k| EndBinary(s, force_has_children || !children.empty()); ------------------ | Branch (277:18): [True: 264, False: 779k] | Branch (277:40): [True: 157k, False: 621k] ------------------ 278| 779k|} _ZN6Assimp3FBX4Node11BeginBinaryERNS_12StreamWriterILb0ELb0EEE: 306| 843k|{ 307| | // remember start pos so we can come back and write the end pos 308| 843k| this->start_pos = s.Tell(); 309| | 310| | // placeholders for end pos and property section info 311| 843k| s.PutU8(0); // end pos 312| 843k| s.PutU8(0); // number of properties 313| 843k| s.PutU8(0); // total property section length 314| | 315| | // node name 316| 843k| s.PutU1(uint8_t(name.size())); // length of node name 317| 843k| s.PutString(name); // node name as raw bytes 318| | 319| | // property data comes after here 320| 843k| this->property_start = s.Tell(); 321| 843k|} _ZN6Assimp3FBX4Node20DumpPropertiesBinaryERNS_12StreamWriterILb0ELb0EEE: 324| 805k|{ 325| 1.63M| for (auto &p : properties) { ------------------ | Branch (325:18): [True: 1.63M, False: 805k] ------------------ 326| 1.63M| p.DumpBinary(s); 327| 1.63M| } 328| 805k|} _ZN6Assimp3FBX4Node19EndPropertiesBinaryERNS_12StreamWriterILb0ELb0EEEm: 333| 843k|) { 334| 843k| if (num_properties == 0) { return; } ------------------ | Branch (334:9): [True: 79.8k, False: 763k] ------------------ 335| 763k| size_t pos = s.Tell(); 336| | ai_assert(pos > property_start); 337| 763k| size_t property_section_size = pos - property_start; 338| 763k| s.Seek(start_pos + 8); // 8 bytes of uint64_t of end_pos 339| 763k| s.PutU8(num_properties); 340| 763k| s.PutU8(property_section_size); 341| 763k| s.Seek(pos); 342| 763k|} _ZN6Assimp3FBX4Node18DumpChildrenBinaryERNS_12StreamWriterILb0ELb0EEE: 345| 779k|{ 346| 779k| for (FBX::Node& child : children) { ------------------ | Branch (346:27): [True: 556k, False: 779k] ------------------ 347| 556k| child.DumpBinary(s); 348| 556k| } 349| 779k|} _ZN6Assimp3FBX4Node9EndBinaryERNS_12StreamWriterILb0ELb0EEEb: 354| 843k|) { 355| | // if there were children, add a null record 356| 843k| if (has_children) { s.PutString(Assimp::FBX::NULL_RECORD_STRING); } ------------------ | Branch (356:9): [True: 183k, False: 659k] ------------------ 357| | 358| | // now go back and write initial pos 359| 843k| this->end_pos = s.Tell(); 360| 843k| s.Seek(start_pos); 361| 843k| s.PutU8(end_pos); 362| 843k| s.Seek(end_pos); 363| 843k|} _ZN6Assimp3FBX4Node23WritePropertyNodeBinaryERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS2_6vectorIdNS6_IdEEEERNS_12StreamWriterILb0ELb0EEE: 487| 25.1k|){ 488| 25.1k| FBX::Node node(name); 489| 25.1k| node.BeginBinary(s); 490| 25.1k| s.PutU1('d'); 491| 25.1k| s.PutU4(uint32_t(v.size())); // number of elements 492| 25.1k| s.PutU4(0); // no encoding (1 would be zip-compressed) 493| 25.1k| s.PutU4(uint32_t(v.size()) * 8); // data size 494| 19.2M| for (auto it = v.begin(); it != v.end(); ++it) { s.PutF8(*it); } ------------------ | Branch (494:31): [True: 19.1M, False: 25.1k] ------------------ 495| 25.1k| node.EndPropertiesBinary(s, 1); 496| 25.1k| node.EndBinary(s, false); 497| 25.1k|} _ZN6Assimp3FBX4Node23WritePropertyNodeBinaryERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS2_6vectorIiNS6_IiEEEERNS_12StreamWriterILb0ELb0EEE: 505| 12.8k|){ 506| 12.8k| FBX::Node node(name); 507| 12.8k| node.BeginBinary(s); 508| 12.8k| s.PutU1('i'); 509| 12.8k| s.PutU4(uint32_t(v.size())); // number of elements 510| 12.8k| s.PutU4(0); // no encoding (1 would be zip-compressed) 511| 12.8k| s.PutU4(uint32_t(v.size()) * 4); // data size 512| 5.74M| for (auto it = v.begin(); it != v.end(); ++it) { s.PutI4(*it); } ------------------ | Branch (512:31): [True: 5.72M, False: 12.8k] ------------------ 513| 12.8k| node.EndPropertiesBinary(s, 1); 514| 12.8k| node.EndBinary(s, false); 515| 12.8k|} _ZN6Assimp3FBX4Node17WritePropertyNodeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS2_6vectorIdNS6_IdEEEERNS_12StreamWriterILb0ELb0EEEbi: 527| 25.1k|){ 528| 25.1k| if (binary) { ------------------ | Branch (528:9): [True: 25.1k, False: 0] ------------------ 529| 25.1k| FBX::Node::WritePropertyNodeBinary(name, v, s); 530| 25.1k| } else { 531| 0| FBX::Node::WritePropertyNodeAscii(name, v, s, indent); 532| 0| } 533| 25.1k|} _ZN6Assimp3FBX4Node17WritePropertyNodeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS2_6vectorIiNS6_IiEEEERNS_12StreamWriterILb0ELb0EEEbi: 543| 12.8k|){ 544| 12.8k| if (binary) { ------------------ | Branch (544:9): [True: 12.8k, False: 0] ------------------ 545| 12.8k| FBX::Node::WritePropertyNodeBinary(name, v, s); 546| 12.8k| } else { 547| 0| FBX::Node::WritePropertyNodeAscii(name, v, s, indent); 548| 0| } 549| 12.8k|} _ZN6Assimp3FBX4NodeC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 77| 657k| : name(n) 78| 657k| , force_has_children( false ) { 79| | // empty 80| 657k| } _ZN6Assimp3FBX4Node8AddChildERKS1_: 105| 228k| void AddChild(const Node& node) { children.push_back(node); } _ZN6Assimp3FBX4NodeC2Ev: 73| 13.2k| Node() = default; _ZN6Assimp3FBX4Node17WritePropertyNodeIiEEvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEET_RNS_12StreamWriterILb0ELb0EEEbi: 180| 25.7k| ) { 181| 25.7k| FBX::FBXExportProperty p(value); 182| 25.7k| FBX::Node node(name, std::move(p)); 183| 25.7k| node.Dump(s, binary, indent); 184| 25.7k| } _ZN6Assimp3FBX4NodeC2IJNS0_17FBXExportPropertyEEEERKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpOT_: 85| 64.0k| : name(n) 86| 64.0k| , force_has_children(false) { 87| 64.0k| AddProperties(std::forward(more)...); 88| 64.0k| } _ZN6Assimp3FBX4Node13AddPropertiesINS0_17FBXExportPropertyEJEEEvOT_DpOT0_: 98| 141k| void AddProperties(T&& value, More&&... more) { 99| 141k| properties.emplace_back(std::forward(value)); 100| 141k| AddProperties(std::forward(more)...); 101| 141k| } _ZN6Assimp3FBX4Node13AddPropertiesEv: 102| 712k| void AddProperties() {} _ZN6Assimp3FBX4Node8AddChildIJiEEEvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEDpOT_: 112| 111k| ) { 113| 111k| FBX::Node c(name); 114| 111k| c.AddProperties(std::forward(more)...); 115| 111k| children.push_back(std::move(c)); 116| 111k| } _ZN6Assimp3FBX4Node13AddPropertiesIiJEEEvOT_DpOT0_: 98| 193k| void AddProperties(T&& value, More&&... more) { 99| 193k| properties.emplace_back(std::forward(value)); 100| 193k| AddProperties(std::forward(more)...); 101| 193k| } _ZN6Assimp3FBX4Node17WritePropertyNodeINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvRKS9_T_RNS_12StreamWriterILb0ELb0EEEbi: 180| 624| ) { 181| 624| FBX::FBXExportProperty p(value); 182| 624| FBX::Node node(name, std::move(p)); 183| 624| node.Dump(s, binary, indent); 184| 624| } _ZN6Assimp3FBX4Node17WritePropertyNodeINSt3__16vectorIhNS3_9allocatorIhEEEEEEvRKNS3_12basic_stringIcNS3_11char_traitsIcEENS5_IcEEEET_RNS_12StreamWriterILb0ELb0EEEbi: 180| 208| ) { 181| 208| FBX::FBXExportProperty p(value); 182| 208| FBX::Node node(name, std::move(p)); 183| 208| node.Dump(s, binary, indent); 184| 208| } _ZN6Assimp3FBX4Node6AddP70IJEEEvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_SB_SB_DpOT_: 142| 858| ) { 143| 858| Node n("P"); 144| 858| n.AddProperties(name, type, type2, flags, std::forward(more)...); 145| 858| AddChild(n); 146| 858| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_SB_SB_EEEvOT_DpOT0_: 98| 858| void AddProperties(T&& value, More&&... more) { 99| 858| properties.emplace_back(std::forward(value)); 100| 858| AddProperties(std::forward(more)...); 101| 858| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_SB_EEEvOT_DpOT0_: 98| 858| void AddProperties(T&& value, More&&... more) { 99| 858| properties.emplace_back(std::forward(value)); 100| 858| AddProperties(std::forward(more)...); 101| 858| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_EEEvOT_DpOT0_: 98| 858| void AddProperties(T&& value, More&&... more) { 99| 858| properties.emplace_back(std::forward(value)); 100| 858| AddProperties(std::forward(more)...); 101| 858| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEvOT_DpOT0_: 98| 46.1k| void AddProperties(T&& value, More&&... more) { 99| 46.1k| properties.emplace_back(std::forward(value)); 100| 46.1k| AddProperties(std::forward(more)...); 101| 46.1k| } _ZN6Assimp3FBX4Node13AddPropertiesIRlJRA1_KcRA6_S4_EEEvOT_DpOT0_: 98| 208| void AddProperties(T&& value, More&&... more) { 99| 208| properties.emplace_back(std::forward(value)); 100| 208| AddProperties(std::forward(more)...); 101| 208| } _ZN6Assimp3FBX4Node13AddPropertiesIRA1_KcJRA6_S3_EEEvOT_DpOT0_: 98| 208| void AddProperties(T&& value, More&&... more) { 99| 208| properties.emplace_back(std::forward(value)); 100| 208| AddProperties(std::forward(more)...); 101| 208| } _ZN6Assimp3FBX4Node13AddPropertiesIRA6_KcJEEEvOT_DpOT0_: 98| 613| void AddProperties(T&& value, More&&... more) { 99| 613| properties.emplace_back(std::forward(value)); 100| 613| AddProperties(std::forward(more)...); 101| 613| } _ZN6Assimp3FBX4Node8AddChildIJlEEEvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEDpOT_: 112| 208| ) { 113| 208| FBX::Node c(name); 114| 208| c.AddProperties(std::forward(more)...); 115| 208| children.push_back(std::move(c)); 116| 208| } _ZN6Assimp3FBX4Node13AddPropertiesIlJEEEvOT_DpOT0_: 98| 234| void AddProperties(T&& value, More&&... more) { 99| 234| properties.emplace_back(std::forward(value)); 100| 234| AddProperties(std::forward(more)...); 101| 234| } _ZN6Assimp3FBX4NodeC2IJRA15_KcEEERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 85| 334| : name(n) 86| 334| , force_has_children(false) { 87| 334| AddProperties(std::forward(more)...); 88| 334| } _ZN6Assimp3FBX4Node13AddPropertiesIRA15_KcJEEEvOT_DpOT0_: 98| 12.9k| void AddProperties(T&& value, More&&... more) { 99| 12.9k| properties.emplace_back(std::forward(value)); 100| 12.9k| AddProperties(std::forward(more)...); 101| 12.9k| } _ZN6Assimp3FBX4Node8AddChildIJRiEEEvRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpOT_: 112| 1.21k| ) { 113| 1.21k| FBX::Node c(name); 114| 1.21k| c.AddProperties(std::forward(more)...); 115| 1.21k| children.push_back(std::move(c)); 116| 1.21k| } _ZN6Assimp3FBX4Node13AddPropertiesIRiJEEEvOT_DpOT0_: 98| 79.7k| void AddProperties(T&& value, More&&... more) { 99| 79.7k| properties.emplace_back(std::forward(value)); 100| 79.7k| AddProperties(std::forward(more)...); 101| 79.7k| } _ZN6Assimp3FBX4NodeC2IJRA13_KcEEERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 85| 52| : name(n) 86| 52| , force_has_children(false) { 87| 52| AddProperties(std::forward(more)...); 88| 52| } _ZN6Assimp3FBX4Node13AddPropertiesIRA13_KcJEEEvOT_DpOT0_: 98| 52| void AddProperties(T&& value, More&&... more) { 99| 52| properties.emplace_back(std::forward(value)); 100| 52| AddProperties(std::forward(more)...); 101| 52| } _ZN6Assimp3FBX4Node6AddP70IJdEEEvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_SB_SB_DpOT_: 142| 442| ) { 143| 442| Node n("P"); 144| 442| n.AddProperties(name, type, type2, flags, std::forward(more)...); 145| 442| AddChild(n); 146| 442| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_SB_SB_dEEEvOT_DpOT0_: 98| 442| void AddProperties(T&& value, More&&... more) { 99| 442| properties.emplace_back(std::forward(value)); 100| 442| AddProperties(std::forward(more)...); 101| 442| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_SB_dEEEvOT_DpOT0_: 98| 442| void AddProperties(T&& value, More&&... more) { 99| 442| properties.emplace_back(std::forward(value)); 100| 442| AddProperties(std::forward(more)...); 101| 442| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_dEEEvOT_DpOT0_: 98| 442| void AddProperties(T&& value, More&&... more) { 99| 442| properties.emplace_back(std::forward(value)); 100| 442| AddProperties(std::forward(more)...); 101| 442| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJdEEEvOT_DpOT0_: 98| 442| void AddProperties(T&& value, More&&... more) { 99| 442| properties.emplace_back(std::forward(value)); 100| 442| AddProperties(std::forward(more)...); 101| 442| } _ZN6Assimp3FBX4Node13AddPropertiesIdJEEEvOT_DpOT0_: 98| 2.49k| void AddProperties(T&& value, More&&... more) { 99| 2.49k| properties.emplace_back(std::forward(value)); 100| 2.49k| AddProperties(std::forward(more)...); 101| 2.49k| } _ZN6Assimp3FBX4Node6AddP70IJiEEEvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_SB_SB_DpOT_: 142| 286| ) { 143| 286| Node n("P"); 144| 286| n.AddProperties(name, type, type2, flags, std::forward(more)...); 145| 286| AddChild(n); 146| 286| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_SB_SB_iEEEvOT_DpOT0_: 98| 286| void AddProperties(T&& value, More&&... more) { 99| 286| properties.emplace_back(std::forward(value)); 100| 286| AddProperties(std::forward(more)...); 101| 286| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_SB_iEEEvOT_DpOT0_: 98| 286| void AddProperties(T&& value, More&&... more) { 99| 286| properties.emplace_back(std::forward(value)); 100| 286| AddProperties(std::forward(more)...); 101| 286| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_iEEEvOT_DpOT0_: 98| 286| void AddProperties(T&& value, More&&... more) { 99| 286| properties.emplace_back(std::forward(value)); 100| 286| AddProperties(std::forward(more)...); 101| 286| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJiEEEvOT_DpOT0_: 98| 286| void AddProperties(T&& value, More&&... more) { 99| 286| properties.emplace_back(std::forward(value)); 100| 286| AddProperties(std::forward(more)...); 101| 286| } _ZN6Assimp3FBX4Node6AddP70IJlEEEvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_SB_SB_DpOT_: 142| 26| ) { 143| 26| Node n("P"); 144| 26| n.AddProperties(name, type, type2, flags, std::forward(more)...); 145| 26| AddChild(n); 146| 26| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_SB_SB_lEEEvOT_DpOT0_: 98| 26| void AddProperties(T&& value, More&&... more) { 99| 26| properties.emplace_back(std::forward(value)); 100| 26| AddProperties(std::forward(more)...); 101| 26| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_SB_lEEEvOT_DpOT0_: 98| 26| void AddProperties(T&& value, More&&... more) { 99| 26| properties.emplace_back(std::forward(value)); 100| 26| AddProperties(std::forward(more)...); 101| 26| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_lEEEvOT_DpOT0_: 98| 26| void AddProperties(T&& value, More&&... more) { 99| 26| properties.emplace_back(std::forward(value)); 100| 26| AddProperties(std::forward(more)...); 101| 26| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJlEEEvOT_DpOT0_: 98| 26| void AddProperties(T&& value, More&&... more) { 99| 26| properties.emplace_back(std::forward(value)); 100| 26| AddProperties(std::forward(more)...); 101| 26| } _ZN6Assimp3FBX4NodeC2IJRA14_KcEEERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 85| 208| : name(n) 86| 208| , force_has_children(false) { 87| 208| AddProperties(std::forward(more)...); 88| 208| } _ZN6Assimp3FBX4Node13AddPropertiesIRA14_KcJEEEvOT_DpOT0_: 98| 12.8k| void AddProperties(T&& value, More&&... more) { 99| 12.8k| properties.emplace_back(std::forward(value)); 100| 12.8k| AddProperties(std::forward(more)...); 101| 12.8k| } _ZN6Assimp3FBX4NodeC2IJRA12_KcEEERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 85| 208| : name(n) 86| 208| , force_has_children(false) { 87| 208| AddProperties(std::forward(more)...); 88| 208| } _ZN6Assimp3FBX4Node13AddPropertiesIRA12_KcJEEEvOT_DpOT0_: 98| 208| void AddProperties(T&& value, More&&... more) { 99| 208| properties.emplace_back(std::forward(value)); 100| 208| AddProperties(std::forward(more)...); 101| 208| } _ZN6Assimp3FBX4NodeC2IJRA6_KcEEERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 85| 256| : name(n) 86| 256| , force_has_children(false) { 87| 256| AddProperties(std::forward(more)...); 88| 256| } _ZN6Assimp3FBX4NodeC2IJRA8_KcEEERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 85| 430| : name(n) 86| 430| , force_has_children(false) { 87| 430| AddProperties(std::forward(more)...); 88| 430| } _ZN6Assimp3FBX4Node13AddPropertiesIRA8_KcJEEEvOT_DpOT0_: 98| 16.0k| void AddProperties(T&& value, More&&... more) { 99| 16.0k| properties.emplace_back(std::forward(value)); 100| 16.0k| AddProperties(std::forward(more)...); 101| 16.0k| } _ZN6Assimp3FBX4Node6AddP70IJdddEEEvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEESB_SB_SB_DpOT_: 142| 1.83k| ) { 143| 1.83k| Node n("P"); 144| 1.83k| n.AddProperties(name, type, type2, flags, std::forward(more)...); 145| 1.83k| AddChild(n); 146| 1.83k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_SB_SB_dddEEEvOT_DpOT0_: 98| 1.83k| void AddProperties(T&& value, More&&... more) { 99| 1.83k| properties.emplace_back(std::forward(value)); 100| 1.83k| AddProperties(std::forward(more)...); 101| 1.83k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_SB_dddEEEvOT_DpOT0_: 98| 1.83k| void AddProperties(T&& value, More&&... more) { 99| 1.83k| properties.emplace_back(std::forward(value)); 100| 1.83k| AddProperties(std::forward(more)...); 101| 1.83k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_dddEEEvOT_DpOT0_: 98| 1.83k| void AddProperties(T&& value, More&&... more) { 99| 1.83k| properties.emplace_back(std::forward(value)); 100| 1.83k| AddProperties(std::forward(more)...); 101| 1.83k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJdddEEEvOT_DpOT0_: 98| 1.83k| void AddProperties(T&& value, More&&... more) { 99| 1.83k| properties.emplace_back(std::forward(value)); 100| 1.83k| AddProperties(std::forward(more)...); 101| 1.83k| } _ZN6Assimp3FBX4Node13AddPropertiesIdJddEEEvOT_DpOT0_: 98| 1.83k| void AddProperties(T&& value, More&&... more) { 99| 1.83k| properties.emplace_back(std::forward(value)); 100| 1.83k| AddProperties(std::forward(more)...); 101| 1.83k| } _ZN6Assimp3FBX4Node13AddPropertiesIdJdEEEvOT_DpOT0_: 98| 2.03k| void AddProperties(T&& value, More&&... more) { 99| 2.03k| properties.emplace_back(std::forward(value)); 100| 2.03k| AddProperties(std::forward(more)...); 101| 2.03k| } _ZN6Assimp3FBX4NodeC2IJRA9_KcEEERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 85| 415| : name(n) 86| 415| , force_has_children(false) { 87| 415| AddProperties(std::forward(more)...); 88| 415| } _ZN6Assimp3FBX4Node13AddPropertiesIRA9_KcJEEEvOT_DpOT0_: 98| 3.49k| void AddProperties(T&& value, More&&... more) { 99| 3.49k| properties.emplace_back(std::forward(value)); 100| 3.49k| AddProperties(std::forward(more)...); 101| 3.49k| } _ZN6Assimp3FBX4Node11AddPropertyIRA16_KcEEvOT_: 92| 57| void AddProperty(T&& value) { 93| 57| properties.emplace_back(std::forward(value)); 94| 57| } _ZN6Assimp3FBX4Node11AddPropertyIRA18_KcEEvOT_: 92| 117| void AddProperty(T&& value) { 93| 117| properties.emplace_back(std::forward(value)); 94| 117| } _ZN6Assimp3FBX4Node6AddP70IJRA1_KcEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEESE_SE_SE_DpOT_: 142| 48| ) { 143| 48| Node n("P"); 144| 48| n.AddProperties(name, type, type2, flags, std::forward(more)...); 145| 48| AddChild(n); 146| 48| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_SB_SB_RA1_KcEEEvOT_DpOT0_: 98| 48| void AddProperties(T&& value, More&&... more) { 99| 48| properties.emplace_back(std::forward(value)); 100| 48| AddProperties(std::forward(more)...); 101| 48| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_SB_RA1_KcEEEvOT_DpOT0_: 98| 48| void AddProperties(T&& value, More&&... more) { 99| 48| properties.emplace_back(std::forward(value)); 100| 48| AddProperties(std::forward(more)...); 101| 48| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_RA1_KcEEEvOT_DpOT0_: 98| 48| void AddProperties(T&& value, More&&... more) { 99| 48| properties.emplace_back(std::forward(value)); 100| 48| AddProperties(std::forward(more)...); 101| 48| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA1_KcEEEvOT_DpOT0_: 98| 146| void AddProperties(T&& value, More&&... more) { 99| 146| properties.emplace_back(std::forward(value)); 100| 146| AddProperties(std::forward(more)...); 101| 146| } _ZN6Assimp3FBX4Node13AddPropertiesIRA1_KcJEEEvOT_DpOT0_: 98| 23.2k| void AddProperties(T&& value, More&&... more) { 99| 23.2k| properties.emplace_back(std::forward(value)); 100| 23.2k| AddProperties(std::forward(more)...); 101| 23.2k| } _ZN6Assimp3FBX4NodeC2IJRA19_KcEEERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 85| 26| : name(n) 86| 26| , force_has_children(false) { 87| 26| AddProperties(std::forward(more)...); 88| 26| } _ZN6Assimp3FBX4Node13AddPropertiesIRA19_KcJEEEvOT_DpOT0_: 98| 12.1k| void AddProperties(T&& value, More&&... more) { 99| 12.1k| properties.emplace_back(std::forward(value)); 100| 12.1k| AddProperties(std::forward(more)...); 101| 12.1k| } _ZN6Assimp3FBX4NodeC2IJRA17_KcEEERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 85| 26| : name(n) 86| 26| , force_has_children(false) { 87| 26| AddProperties(std::forward(more)...); 88| 26| } _ZN6Assimp3FBX4Node13AddPropertiesIRA17_KcJEEEvOT_DpOT0_: 98| 124| void AddProperties(T&& value, More&&... more) { 99| 124| properties.emplace_back(std::forward(value)); 100| 124| AddProperties(std::forward(more)...); 101| 124| } _ZN6Assimp3FBX4NodeC2IJRA5_KcEEERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 85| 19| : name(n) 86| 19| , force_has_children(false) { 87| 19| AddProperties(std::forward(more)...); 88| 19| } _ZN6Assimp3FBX4Node13AddPropertiesIRA5_KcJEEEvOT_DpOT0_: 98| 327| void AddProperties(T&& value, More&&... more) { 99| 327| properties.emplace_back(std::forward(value)); 100| 327| AddProperties(std::forward(more)...); 101| 327| } _ZN6Assimp3FBX4Node11AddPropertyIRlEEvOT_: 92| 12.8k| void AddProperty(T&& value) { 93| 12.8k| properties.emplace_back(std::forward(value)); 94| 12.8k| } _ZN6Assimp3FBX4Node11AddPropertyINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEvOT_: 92| 12.8k| void AddProperty(T&& value) { 93| 12.8k| properties.emplace_back(std::forward(value)); 94| 12.8k| } _ZN6Assimp3FBX4Node8AddChildIJRA8_KcEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 112| 12.4k| ) { 113| 12.4k| FBX::Node c(name); 114| 12.4k| c.AddProperties(std::forward(more)...); 115| 12.4k| children.push_back(std::move(c)); 116| 12.4k| } _ZN6Assimp3FBX4Node8AddChildIJRNSt3__16vectorIiNS3_9allocatorIiEEEEEEEvRKNS3_12basic_stringIcNS3_11char_traitsIcEENS5_IcEEEEDpOT_: 112| 15.7k| ) { 113| 15.7k| FBX::Node c(name); 114| 15.7k| c.AddProperties(std::forward(more)...); 115| 15.7k| children.push_back(std::move(c)); 116| 15.7k| } _ZN6Assimp3FBX4Node13AddPropertiesIRNSt3__16vectorIiNS3_9allocatorIiEEEEJEEEvOT_DpOT0_: 98| 15.7k| void AddProperties(T&& value, More&&... more) { 99| 15.7k| properties.emplace_back(std::forward(value)); 100| 15.7k| AddProperties(std::forward(more)...); 101| 15.7k| } _ZN6Assimp3FBX4Node11AddPropertyIRA5_KcEEvOT_: 92| 12.6k| void AddProperty(T&& value) { 93| 12.6k| properties.emplace_back(std::forward(value)); 94| 12.6k| } _ZN6Assimp3FBX4NodeC2IJiEEERKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEDpOT_: 85| 37.7k| : name(n) 86| 37.7k| , force_has_children(false) { 87| 37.7k| AddProperties(std::forward(more)...); 88| 37.7k| } _ZN6Assimp3FBX4Node17WritePropertyNodeIPKcEEvRKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEET_RNS_12StreamWriterILb0ELb0EEEbi: 180| 37.4k| ) { 181| 37.4k| FBX::FBXExportProperty p(value); 182| 37.4k| FBX::Node node(name, std::move(p)); 183| 37.4k| node.Dump(s, binary, indent); 184| 37.4k| } _ZN6Assimp3FBX4Node8AddChildIJRA1_KcEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 112| 12.6k| ) { 113| 12.6k| FBX::Node c(name); 114| 12.6k| c.AddProperties(std::forward(more)...); 115| 12.6k| children.push_back(std::move(c)); 116| 12.6k| } _ZN6Assimp3FBX4Node8AddChildIJRA14_KcEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 112| 12.6k| ) { 113| 12.6k| FBX::Node c(name); 114| 12.6k| c.AddProperties(std::forward(more)...); 115| 12.6k| children.push_back(std::move(c)); 116| 12.6k| } _ZN6Assimp3FBX4Node8AddChildIJRA10_KcEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 112| 290| ) { 113| 290| FBX::Node c(name); 114| 290| c.AddProperties(std::forward(more)...); 115| 290| children.push_back(std::move(c)); 116| 290| } _ZN6Assimp3FBX4Node13AddPropertiesIRA10_KcJEEEvOT_DpOT0_: 98| 290| void AddProperties(T&& value, More&&... more) { 99| 290| properties.emplace_back(std::forward(value)); 100| 290| AddProperties(std::forward(more)...); 101| 290| } _ZN6Assimp3FBX4Node8AddChildIJRA19_KcEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 112| 12.1k| ) { 113| 12.1k| FBX::Node c(name); 114| 12.1k| c.AddProperties(std::forward(more)...); 115| 12.1k| children.push_back(std::move(c)); 116| 12.1k| } _ZN6Assimp3FBX4Node8AddChildIJRA18_KcEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 112| 201| ) { 113| 201| FBX::Node c(name); 114| 201| c.AddProperties(std::forward(more)...); 115| 201| children.push_back(std::move(c)); 116| 201| } _ZN6Assimp3FBX4Node13AddPropertiesIRA18_KcJEEEvOT_DpOT0_: 98| 201| void AddProperties(T&& value, More&&... more) { 99| 201| properties.emplace_back(std::forward(value)); 100| 201| AddProperties(std::forward(more)...); 101| 201| } _ZN6Assimp3FBX4Node8AddChildIJRA21_KcEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 112| 12.6k| ) { 113| 12.6k| FBX::Node c(name); 114| 12.6k| c.AddProperties(std::forward(more)...); 115| 12.6k| children.push_back(std::move(c)); 116| 12.6k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA21_KcJEEEvOT_DpOT0_: 98| 12.6k| void AddProperties(T&& value, More&&... more) { 99| 12.6k| properties.emplace_back(std::forward(value)); 100| 12.6k| AddProperties(std::forward(more)...); 101| 12.6k| } _ZN6Assimp3FBX4Node8AddChildIJRA15_KcEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 112| 12.6k| ) { 113| 12.6k| FBX::Node c(name); 114| 12.6k| c.AddProperties(std::forward(more)...); 115| 12.6k| children.push_back(std::move(c)); 116| 12.6k| } _ZN6Assimp3FBX4Node11AddPropertyIRA1_KcEEvOT_: 92| 246| void AddProperty(T&& value) { 93| 246| properties.emplace_back(std::forward(value)); 94| 246| } _ZN6Assimp3FBX4Node8AddChildIJRA6_KcEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 112| 92| ) { 113| 92| FBX::Node c(name); 114| 92| c.AddProperties(std::forward(more)...); 115| 92| children.push_back(std::move(c)); 116| 92| } _ZN6Assimp3FBX4Node13AddPropertiesIRKlJNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERA5_KcEEEvOT_DpOT0_: 98| 92| void AddProperties(T&& value, More&&... more) { 99| 92| properties.emplace_back(std::forward(value)); 100| 92| AddProperties(std::forward(more)...); 101| 92| } _ZN6Assimp3FBX4Node13AddPropertiesINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA5_KcEEEvOT_DpOT0_: 98| 118| void AddProperties(T&& value, More&&... more) { 99| 118| properties.emplace_back(std::forward(value)); 100| 118| AddProperties(std::forward(more)...); 101| 118| } _ZN6Assimp3FBX4Node8AddChildIJRA5_KcEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 112| 190| ) { 113| 190| FBX::Node c(name); 114| 190| c.AddProperties(std::forward(more)...); 115| 190| children.push_back(std::move(c)); 116| 190| } _ZN6Assimp3FBX4Node8AddChildIJRNSt3__16vectorIhNS3_9allocatorIhEEEEEEEvRKNS3_12basic_stringIcNS3_11char_traitsIcEENS5_IcEEEEDpOT_: 112| 7| ) { 113| 7| FBX::Node c(name); 114| 7| c.AddProperties(std::forward(more)...); 115| 7| children.push_back(std::move(c)); 116| 7| } _ZN6Assimp3FBX4Node13AddPropertiesIRNSt3__16vectorIhNS3_9allocatorIhEEEEJEEEvOT_DpOT0_: 98| 7| void AddProperties(T&& value, More&&... more) { 99| 7| properties.emplace_back(std::forward(value)); 100| 7| AddProperties(std::forward(more)...); 101| 7| } _ZN6Assimp3FBX4Node8AddChildIJRNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEvRKS9_DpOT_: 112| 380| ) { 113| 380| FBX::Node c(name); 114| 380| c.AddProperties(std::forward(more)...); 115| 380| children.push_back(std::move(c)); 116| 380| } _ZN6Assimp3FBX4Node13AddPropertiesIRNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJEEEvOT_DpOT0_: 98| 472| void AddProperties(T&& value, More&&... more) { 99| 472| properties.emplace_back(std::forward(value)); 100| 472| AddProperties(std::forward(more)...); 101| 472| } _ZN6Assimp3FBX4Node6AddP70IJRNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEvRKS9_SC_SC_SC_DpOT_: 142| 92| ) { 143| 92| Node n("P"); 144| 92| n.AddProperties(name, type, type2, flags, std::forward(more)...); 145| 92| AddChild(n); 146| 92| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_SB_SB_RS9_EEEvOT_DpOT0_: 98| 92| void AddProperties(T&& value, More&&... more) { 99| 92| properties.emplace_back(std::forward(value)); 100| 92| AddProperties(std::forward(more)...); 101| 92| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_SB_RS9_EEEvOT_DpOT0_: 98| 92| void AddProperties(T&& value, More&&... more) { 99| 92| properties.emplace_back(std::forward(value)); 100| 92| AddProperties(std::forward(more)...); 101| 92| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJSB_RS9_EEEvOT_DpOT0_: 98| 92| void AddProperties(T&& value, More&&... more) { 99| 92| properties.emplace_back(std::forward(value)); 100| 92| AddProperties(std::forward(more)...); 101| 92| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRS9_EEEvOT_DpOT0_: 98| 92| void AddProperties(T&& value, More&&... more) { 99| 92| properties.emplace_back(std::forward(value)); 100| 92| AddProperties(std::forward(more)...); 101| 92| } _ZN6Assimp3FBX4NodeC2IJRA3_KcRKlRlRKNSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEEEEESH_DpOT_: 85| 98| : name(n) 86| 98| , force_has_children(false) { 87| 98| AddProperties(std::forward(more)...); 88| 98| } _ZN6Assimp3FBX4Node13AddPropertiesIRA3_KcJRKlRlRKNSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEEEEEvOT_DpOT0_: 98| 98| void AddProperties(T&& value, More&&... more) { 99| 98| properties.emplace_back(std::forward(value)); 100| 98| AddProperties(std::forward(more)...); 101| 98| } _ZN6Assimp3FBX4Node13AddPropertiesIRKlJRlRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEEvOT_DpOT0_: 98| 98| void AddProperties(T&& value, More&&... more) { 99| 98| properties.emplace_back(std::forward(value)); 100| 98| AddProperties(std::forward(more)...); 101| 98| } _ZN6Assimp3FBX4Node13AddPropertiesIRlJRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEvOT_DpOT0_: 98| 7.40k| void AddProperties(T&& value, More&&... more) { 99| 7.40k| properties.emplace_back(std::forward(value)); 100| 7.40k| AddProperties(std::forward(more)...); 101| 7.40k| } _ZN6Assimp3FBX4NodeC2IJRA3_KcRKlS7_EEERKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEDpOT_: 85| 98| : name(n) 86| 98| , force_has_children(false) { 87| 98| AddProperties(std::forward(more)...); 88| 98| } _ZN6Assimp3FBX4Node13AddPropertiesIRA3_KcJRKlS7_EEEvOT_DpOT0_: 98| 98| void AddProperties(T&& value, More&&... more) { 99| 98| properties.emplace_back(std::forward(value)); 100| 98| AddProperties(std::forward(more)...); 101| 98| } _ZN6Assimp3FBX4Node13AddPropertiesIRKlJS4_EEEvOT_DpOT0_: 98| 98| void AddProperties(T&& value, More&&... more) { 99| 98| properties.emplace_back(std::forward(value)); 100| 98| AddProperties(std::forward(more)...); 101| 98| } _ZN6Assimp3FBX4Node13AddPropertiesIRKlJEEEvOT_DpOT0_: 98| 3.18k| void AddProperties(T&& value, More&&... more) { 99| 3.18k| properties.emplace_back(std::forward(value)); 100| 3.18k| AddProperties(std::forward(more)...); 101| 3.18k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKlJRKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERA1_KcEEEvOT_DpOT0_: 98| 98| void AddProperties(T&& value, More&&... more) { 99| 98| properties.emplace_back(std::forward(value)); 100| 98| AddProperties(std::forward(more)...); 101| 98| } _ZN6Assimp3FBX4Node8AddChildIJRA17_KcEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 112| 98| ) { 113| 98| FBX::Node c(name); 114| 98| c.AddProperties(std::forward(more)...); 115| 98| children.push_back(std::move(c)); 116| 98| } _ZN6Assimp3FBX4Node8AddChildIJRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEEEvSB_DpOT_: 112| 98| ) { 113| 98| FBX::Node c(name); 114| 98| c.AddProperties(std::forward(more)...); 115| 98| children.push_back(std::move(c)); 116| 98| } _ZN6Assimp3FBX4Node8AddChildIJddEEEvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEDpOT_: 112| 196| ) { 113| 196| FBX::Node c(name); 114| 196| c.AddProperties(std::forward(more)...); 115| 196| children.push_back(std::move(c)); 116| 196| } _ZN6Assimp3FBX4Node8AddChildIJiiiiEEEvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEDpOT_: 112| 98| ) { 113| 98| FBX::Node c(name); 114| 98| c.AddProperties(std::forward(more)...); 115| 98| children.push_back(std::move(c)); 116| 98| } _ZN6Assimp3FBX4Node13AddPropertiesIiJiiiEEEvOT_DpOT0_: 98| 98| void AddProperties(T&& value, More&&... more) { 99| 98| properties.emplace_back(std::forward(value)); 100| 98| AddProperties(std::forward(more)...); 101| 98| } _ZN6Assimp3FBX4Node13AddPropertiesIiJiiEEEvOT_DpOT0_: 98| 98| void AddProperties(T&& value, More&&... more) { 99| 98| properties.emplace_back(std::forward(value)); 100| 98| AddProperties(std::forward(more)...); 101| 98| } _ZN6Assimp3FBX4Node13AddPropertiesIiJiEEEvOT_DpOT0_: 98| 98| void AddProperties(T&& value, More&&... more) { 99| 98| properties.emplace_back(std::forward(value)); 100| 98| AddProperties(std::forward(more)...); 101| 98| } _ZN6Assimp3FBX4NodeC2IJRA3_KcRlS6_EEERKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEDpOT_: 85| 68.4k| : name(n) 86| 68.4k| , force_has_children(false) { 87| 68.4k| AddProperties(std::forward(more)...); 88| 68.4k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA3_KcJRlS6_EEEvOT_DpOT0_: 98| 68.4k| void AddProperties(T&& value, More&&... more) { 99| 68.4k| properties.emplace_back(std::forward(value)); 100| 68.4k| AddProperties(std::forward(more)...); 101| 68.4k| } _ZN6Assimp3FBX4Node13AddPropertiesIRlJS3_EEEvOT_DpOT0_: 98| 68.4k| void AddProperties(T&& value, More&&... more) { 99| 68.4k| properties.emplace_back(std::forward(value)); 100| 68.4k| AddProperties(std::forward(more)...); 101| 68.4k| } _ZN6Assimp3FBX4Node13AddPropertiesIRlJEEEvOT_DpOT0_: 98| 72.1k| void AddProperties(T&& value, More&&... more) { 99| 72.1k| properties.emplace_back(std::forward(value)); 100| 72.1k| AddProperties(std::forward(more)...); 101| 72.1k| } _ZN6Assimp3FBX4Node8AddChildIJRNSt3__16vectorIdNS3_9allocatorIdEEEEEEEvRKNS3_12basic_stringIcNS3_11char_traitsIcEENS5_IcEEEEDpOT_: 112| 3.08k| ) { 113| 3.08k| FBX::Node c(name); 114| 3.08k| c.AddProperties(std::forward(more)...); 115| 3.08k| children.push_back(std::move(c)); 116| 3.08k| } _ZN6Assimp3FBX4Node13AddPropertiesIRNSt3__16vectorIdNS3_9allocatorIdEEEEJEEEvOT_DpOT0_: 98| 3.08k| void AddProperties(T&& value, More&&... more) { 99| 3.08k| properties.emplace_back(std::forward(value)); 100| 3.08k| AddProperties(std::forward(more)...); 101| 3.08k| } _ZN6Assimp3FBX4NodeC2IJRA3_KcRKlRlEEERKNSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEEDpOT_: 85| 3.08k| : name(n) 86| 3.08k| , force_has_children(false) { 87| 3.08k| AddProperties(std::forward(more)...); 88| 3.08k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA3_KcJRKlRlEEEvOT_DpOT0_: 98| 3.08k| void AddProperties(T&& value, More&&... more) { 99| 3.08k| properties.emplace_back(std::forward(value)); 100| 3.08k| AddProperties(std::forward(more)...); 101| 3.08k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKlJRlEEEvOT_DpOT0_: 98| 3.08k| void AddProperties(T&& value, More&&... more) { 99| 3.08k| properties.emplace_back(std::forward(value)); 100| 3.08k| AddProperties(std::forward(more)...); 101| 3.08k| } _ZN6Assimp3FBX4NodeC2IJRA3_KcRlRKlEEERKNSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEEDpOT_: 85| 3.08k| : name(n) 86| 3.08k| , force_has_children(false) { 87| 3.08k| AddProperties(std::forward(more)...); 88| 3.08k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA3_KcJRlRKlEEEvOT_DpOT0_: 98| 3.08k| void AddProperties(T&& value, More&&... more) { 99| 3.08k| properties.emplace_back(std::forward(value)); 100| 3.08k| AddProperties(std::forward(more)...); 101| 3.08k| } _ZN6Assimp3FBX4Node13AddPropertiesIRlJRKlEEEvOT_DpOT0_: 98| 3.08k| void AddProperties(T&& value, More&&... more) { 99| 3.08k| properties.emplace_back(std::forward(value)); 100| 3.08k| AddProperties(std::forward(more)...); 101| 3.08k| } _ZN6Assimp3FBX4Node13AddPropertiesIRlJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERA5_KcEEEvOT_DpOT0_: 98| 26| void AddProperties(T&& value, More&&... more) { 99| 26| properties.emplace_back(std::forward(value)); 100| 26| AddProperties(std::forward(more)...); 101| 26| } _ZN6Assimp3FBX4Node8AddChildIJdEEEvRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEDpOT_: 112| 26| ) { 113| 26| FBX::Node c(name); 114| 26| c.AddProperties(std::forward(more)...); 115| 26| children.push_back(std::move(c)); 116| 26| } _ZN6Assimp3FBX4Node8AddChildIJRA7_KcEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 112| 26| ) { 113| 26| FBX::Node c(name); 114| 26| c.AddProperties(std::forward(more)...); 115| 26| children.push_back(std::move(c)); 116| 26| } _ZN6Assimp3FBX4Node13AddPropertiesIRA7_KcJEEEvOT_DpOT0_: 98| 26| void AddProperties(T&& value, More&&... more) { 99| 26| properties.emplace_back(std::forward(value)); 100| 26| AddProperties(std::forward(more)...); 101| 26| } _ZN6Assimp3FBX4Node13AddPropertiesIRKlJNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERA8_KcEEEvOT_DpOT0_: 98| 3.08k| void AddProperties(T&& value, More&&... more) { 99| 3.08k| properties.emplace_back(std::forward(value)); 100| 3.08k| AddProperties(std::forward(more)...); 101| 3.08k| } _ZN6Assimp3FBX4Node13AddPropertiesINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA8_KcEEEvOT_DpOT0_: 98| 3.08k| void AddProperties(T&& value, More&&... more) { 99| 3.08k| properties.emplace_back(std::forward(value)); 100| 3.08k| AddProperties(std::forward(more)...); 101| 3.08k| } _ZN6Assimp3FBX4Node8AddChildIJRA1_KcS5_EEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 112| 3.08k| ) { 113| 3.08k| FBX::Node c(name); 114| 3.08k| c.AddProperties(std::forward(more)...); 115| 3.08k| children.push_back(std::move(c)); 116| 3.08k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA1_KcJS5_EEEvOT_DpOT0_: 98| 3.08k| void AddProperties(T&& value, More&&... more) { 99| 3.08k| properties.emplace_back(std::forward(value)); 100| 3.08k| AddProperties(std::forward(more)...); 101| 3.08k| } _ZN6Assimp3FBX4Node8AddChildIJR12aiMatrix4x4tIfEEEEvRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEDpOT_: 112| 6.17k| ) { 113| 6.17k| FBX::Node c(name); 114| 6.17k| c.AddProperties(std::forward(more)...); 115| 6.17k| children.push_back(std::move(c)); 116| 6.17k| } _ZN6Assimp3FBX4Node13AddPropertiesIR12aiMatrix4x4tIfEJEEEvOT_DpOT0_: 98| 6.17k| void AddProperties(T&& value, More&&... more) { 99| 6.17k| properties.emplace_back(std::forward(value)); 100| 6.17k| AddProperties(std::forward(more)...); 101| 6.17k| } _ZN6Assimp3FBX4Node13AddPropertiesIRlJRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERA6_KcEEEvOT_DpOT0_: 98| 57| void AddProperties(T&& value, More&&... more) { 99| 57| properties.emplace_back(std::forward(value)); 100| 57| AddProperties(std::forward(more)...); 101| 57| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA6_KcEEEvOT_DpOT0_: 98| 57| void AddProperties(T&& value, More&&... more) { 99| 57| properties.emplace_back(std::forward(value)); 100| 57| AddProperties(std::forward(more)...); 101| 57| } _ZN6Assimp3FBX4Node8AddChildIJNS0_17FBXExportPropertyEEEEvRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpOT_: 112| 77.4k| ) { 113| 77.4k| FBX::Node c(name); 114| 77.4k| c.AddProperties(std::forward(more)...); 115| 77.4k| children.push_back(std::move(c)); 116| 77.4k| } _ZN6Assimp3FBX4Node13AddPropertiesIRlJRNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERA1_KcEEEvOT_DpOT0_: 98| 28| void AddProperties(T&& value, More&&... more) { 99| 28| properties.emplace_back(std::forward(value)); 100| 28| AddProperties(std::forward(more)...); 101| 28| } _ZN6Assimp3FBX4Node13AddPropertiesIRNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA1_KcEEEvOT_DpOT0_: 98| 28| void AddProperties(T&& value, More&&... more) { 99| 28| properties.emplace_back(std::forward(value)); 100| 28| AddProperties(std::forward(more)...); 101| 28| } _ZN6Assimp3FBX4Node13AddPropertiesIRlJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERA1_KcEEEvOT_DpOT0_: 98| 7.33k| void AddProperties(T&& value, More&&... more) { 99| 7.33k| properties.emplace_back(std::forward(value)); 100| 7.33k| AddProperties(std::forward(more)...); 101| 7.33k| } _ZN6Assimp3FBX4Node13AddPropertiesINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA1_KcEEEvOT_DpOT0_: 98| 7.33k| void AddProperties(T&& value, More&&... more) { 99| 7.33k| properties.emplace_back(std::forward(value)); 100| 7.33k| AddProperties(std::forward(more)...); 101| 7.33k| } _ZN6Assimp3FBX4Node13AddPropertiesIRlJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERKSA_EEEvOT_DpOT0_: 98| 37.1k| void AddProperties(T&& value, More&&... more) { 99| 37.1k| properties.emplace_back(std::forward(value)); 100| 37.1k| AddProperties(std::forward(more)...); 101| 37.1k| } _ZN6Assimp3FBX4Node13AddPropertiesINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRKS9_EEEvOT_DpOT0_: 98| 37.1k| void AddProperties(T&& value, More&&... more) { 99| 37.1k| properties.emplace_back(std::forward(value)); 100| 37.1k| AddProperties(std::forward(more)...); 101| 37.1k| } _ZN6Assimp3FBX4Node13AddPropertiesIRlJNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEERA9_KcEEEvOT_DpOT0_: 98| 3.07k| void AddProperties(T&& value, More&&... more) { 99| 3.07k| properties.emplace_back(std::forward(value)); 100| 3.07k| AddProperties(std::forward(more)...); 101| 3.07k| } _ZN6Assimp3FBX4Node13AddPropertiesINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA9_KcEEEvOT_DpOT0_: 98| 3.07k| void AddProperties(T&& value, More&&... more) { 99| 3.07k| properties.emplace_back(std::forward(value)); 100| 3.07k| AddProperties(std::forward(more)...); 101| 3.07k| } _ZN6Assimp3FBX4NodeC2IJRA3_KcRlS6_RKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEEEESF_DpOT_: 85| 7.30k| : name(n) 86| 7.30k| , force_has_children(false) { 87| 7.30k| AddProperties(std::forward(more)...); 88| 7.30k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA3_KcJRlS6_RKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEEEEEvOT_DpOT0_: 98| 7.30k| void AddProperties(T&& value, More&&... more) { 99| 7.30k| properties.emplace_back(std::forward(value)); 100| 7.30k| AddProperties(std::forward(more)...); 101| 7.30k| } _ZN6Assimp3FBX4Node13AddPropertiesIRlJS3_RKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEEEEvOT_DpOT0_: 98| 7.30k| void AddProperties(T&& value, More&&... more) { 99| 7.30k| properties.emplace_back(std::forward(value)); 100| 7.30k| AddProperties(std::forward(more)...); 101| 7.30k| } _ZN6Assimp3FBX4Node8AddChildIJRdEEEvRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEEDpOT_: 112| 5.48k| ) { 113| 5.48k| FBX::Node c(name); 114| 5.48k| c.AddProperties(std::forward(more)...); 115| 5.48k| children.push_back(std::move(c)); 116| 5.48k| } _ZN6Assimp3FBX4Node13AddPropertiesIRdJEEEvOT_DpOT0_: 98| 25.6k| void AddProperties(T&& value, More&&... more) { 99| 25.6k| properties.emplace_back(std::forward(value)); 100| 25.6k| AddProperties(std::forward(more)...); 101| 25.6k| } _ZN6Assimp3FBX4Node8AddChildIJRKNSt3__16vectorIlNS3_9allocatorIlEEEEEEEvRKNS3_12basic_stringIcNS3_11char_traitsIcEENS5_IcEEEEDpOT_: 112| 5.48k| ) { 113| 5.48k| FBX::Node c(name); 114| 5.48k| c.AddProperties(std::forward(more)...); 115| 5.48k| children.push_back(std::move(c)); 116| 5.48k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__16vectorIlNS3_9allocatorIlEEEEJEEEvOT_DpOT0_: 98| 5.48k| void AddProperties(T&& value, More&&... more) { 99| 5.48k| properties.emplace_back(std::forward(value)); 100| 5.48k| AddProperties(std::forward(more)...); 101| 5.48k| } _ZN6Assimp3FBX4Node8AddChildIJRKNSt3__16vectorIfNS3_9allocatorIfEEEEEEEvRKNS3_12basic_stringIcNS3_11char_traitsIcEENS5_IcEEEEDpOT_: 112| 5.48k| ) { 113| 5.48k| FBX::Node c(name); 114| 5.48k| c.AddProperties(std::forward(more)...); 115| 5.48k| children.push_back(std::move(c)); 116| 5.48k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__16vectorIfNS3_9allocatorIfEEEEJEEEvOT_DpOT0_: 98| 5.48k| void AddProperties(T&& value, More&&... more) { 99| 5.48k| properties.emplace_back(std::forward(value)); 100| 5.48k| AddProperties(std::forward(more)...); 101| 5.48k| } _ZN6Assimp3FBX4Node8AddChildIJNSt3__16vectorIiNS3_9allocatorIiEEEEEEEvRKNS3_12basic_stringIcNS3_11char_traitsIcEENS5_IcEEEEDpOT_: 112| 10.9k| ) { 113| 10.9k| FBX::Node c(name); 114| 10.9k| c.AddProperties(std::forward(more)...); 115| 10.9k| children.push_back(std::move(c)); 116| 10.9k| } _ZN6Assimp3FBX4Node13AddPropertiesINSt3__16vectorIiNS3_9allocatorIiEEEEJEEEvOT_DpOT0_: 98| 10.9k| void AddProperties(T&& value, More&&... more) { 99| 10.9k| properties.emplace_back(std::forward(value)); 100| 10.9k| AddProperties(std::forward(more)...); 101| 10.9k| } _ZN6Assimp3FBX4Node8AddChildIJNSt3__16vectorIfNS3_9allocatorIfEEEEEEEvRKNS3_12basic_stringIcNS3_11char_traitsIcEENS5_IcEEEEDpOT_: 112| 5.48k| ) { 113| 5.48k| FBX::Node c(name); 114| 5.48k| c.AddProperties(std::forward(more)...); 115| 5.48k| children.push_back(std::move(c)); 116| 5.48k| } _ZN6Assimp3FBX4Node13AddPropertiesINSt3__16vectorIfNS3_9allocatorIfEEEEJEEEvOT_DpOT0_: 98| 5.48k| void AddProperties(T&& value, More&&... more) { 99| 5.48k| properties.emplace_back(std::forward(value)); 100| 5.48k| AddProperties(std::forward(more)...); 101| 5.48k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA4_KcRA8_SC_RA1_SC_RiEEEvOT_DpOT0_: 98| 39.5k| void AddProperties(T&& value, More&&... more) { 99| 39.5k| properties.emplace_back(std::forward(value)); 100| 39.5k| AddProperties(std::forward(more)...); 101| 39.5k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA4_KcJRA8_S3_RA1_S3_RiEEEvOT_DpOT0_: 98| 39.5k| void AddProperties(T&& value, More&&... more) { 99| 39.5k| properties.emplace_back(std::forward(value)); 100| 39.5k| AddProperties(std::forward(more)...); 101| 39.5k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA8_KcJRA1_S3_RiEEEvOT_DpOT0_: 98| 39.5k| void AddProperties(T&& value, More&&... more) { 99| 39.5k| properties.emplace_back(std::forward(value)); 100| 39.5k| AddProperties(std::forward(more)...); 101| 39.5k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA1_KcJRiEEEvOT_DpOT0_: 98| 78.4k| void AddProperties(T&& value, More&&... more) { 99| 78.4k| properties.emplace_back(std::forward(value)); 100| 78.4k| AddProperties(std::forward(more)...); 101| 78.4k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA5_KcRA1_SC_SG_iEEEvOT_DpOT0_: 98| 43.7k| void AddProperties(T&& value, More&&... more) { 99| 43.7k| properties.emplace_back(std::forward(value)); 100| 43.7k| AddProperties(std::forward(more)...); 101| 43.7k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA5_KcJRA1_S3_S7_iEEEvOT_DpOT0_: 98| 43.7k| void AddProperties(T&& value, More&&... more) { 99| 43.7k| properties.emplace_back(std::forward(value)); 100| 43.7k| AddProperties(std::forward(more)...); 101| 43.7k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA1_KcJS5_iEEEvOT_DpOT0_: 98| 43.7k| void AddProperties(T&& value, More&&... more) { 99| 43.7k| properties.emplace_back(std::forward(value)); 100| 43.7k| AddProperties(std::forward(more)...); 101| 43.7k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA1_KcJiEEEvOT_DpOT0_: 98| 43.7k| void AddProperties(T&& value, More&&... more) { 99| 43.7k| properties.emplace_back(std::forward(value)); 100| 43.7k| AddProperties(std::forward(more)...); 101| 43.7k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA7_KcSE_RA1_SC_RdEEEvOT_DpOT0_: 98| 5.83k| void AddProperties(T&& value, More&&... more) { 99| 5.83k| properties.emplace_back(std::forward(value)); 100| 5.83k| AddProperties(std::forward(more)...); 101| 5.83k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA7_KcJS5_RA1_S3_RdEEEvOT_DpOT0_: 98| 5.83k| void AddProperties(T&& value, More&&... more) { 99| 5.83k| properties.emplace_back(std::forward(value)); 100| 5.83k| AddProperties(std::forward(more)...); 101| 5.83k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA7_KcJRA1_S3_RdEEEvOT_DpOT0_: 98| 5.83k| void AddProperties(T&& value, More&&... more) { 99| 5.83k| properties.emplace_back(std::forward(value)); 100| 5.83k| AddProperties(std::forward(more)...); 101| 5.83k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA1_KcJRdEEEvOT_DpOT0_: 98| 5.83k| void AddProperties(T&& value, More&&... more) { 99| 5.83k| properties.emplace_back(std::forward(value)); 100| 5.83k| AddProperties(std::forward(more)...); 101| 5.83k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA7_KcRA1_SC_RA2_SC_RdEEEvOT_DpOT0_: 98| 6.65k| void AddProperties(T&& value, More&&... more) { 99| 6.65k| properties.emplace_back(std::forward(value)); 100| 6.65k| AddProperties(std::forward(more)...); 101| 6.65k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA7_KcJRA1_S3_RA2_S3_RdEEEvOT_DpOT0_: 98| 6.65k| void AddProperties(T&& value, More&&... more) { 99| 6.65k| properties.emplace_back(std::forward(value)); 100| 6.65k| AddProperties(std::forward(more)...); 101| 6.65k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA1_KcJRA2_S3_RdEEEvOT_DpOT0_: 98| 6.65k| void AddProperties(T&& value, More&&... more) { 99| 6.65k| properties.emplace_back(std::forward(value)); 100| 6.65k| AddProperties(std::forward(more)...); 101| 6.65k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA2_KcJRdEEEvOT_DpOT0_: 98| 6.65k| void AddProperties(T&& value, More&&... more) { 99| 6.65k| properties.emplace_back(std::forward(value)); 100| 6.65k| AddProperties(std::forward(more)...); 101| 6.65k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA9_KcRA6_SC_RA1_SC_RdSJ_SJ_EEEvOT_DpOT0_: 98| 964| void AddProperties(T&& value, More&&... more) { 99| 964| properties.emplace_back(std::forward(value)); 100| 964| AddProperties(std::forward(more)...); 101| 964| } _ZN6Assimp3FBX4Node13AddPropertiesIRA9_KcJRA6_S3_RA1_S3_RdSA_SA_EEEvOT_DpOT0_: 98| 964| void AddProperties(T&& value, More&&... more) { 99| 964| properties.emplace_back(std::forward(value)); 100| 964| AddProperties(std::forward(more)...); 101| 964| } _ZN6Assimp3FBX4Node13AddPropertiesIRA6_KcJRA1_S3_RdS8_S8_EEEvOT_DpOT0_: 98| 964| void AddProperties(T&& value, More&&... more) { 99| 964| properties.emplace_back(std::forward(value)); 100| 964| AddProperties(std::forward(more)...); 101| 964| } _ZN6Assimp3FBX4Node13AddPropertiesIRA1_KcJRdS6_S6_EEEvOT_DpOT0_: 98| 5.70k| void AddProperties(T&& value, More&&... more) { 99| 5.70k| properties.emplace_back(std::forward(value)); 100| 5.70k| AddProperties(std::forward(more)...); 101| 5.70k| } _ZN6Assimp3FBX4Node13AddPropertiesIRdJS3_S3_EEEvOT_DpOT0_: 98| 7.64k| void AddProperties(T&& value, More&&... more) { 99| 7.64k| properties.emplace_back(std::forward(value)); 100| 7.64k| AddProperties(std::forward(more)...); 101| 7.64k| } _ZN6Assimp3FBX4Node13AddPropertiesIRdJS3_EEEvOT_DpOT0_: 98| 7.64k| void AddProperties(T&& value, More&&... more) { 99| 7.64k| properties.emplace_back(std::forward(value)); 100| 7.64k| AddProperties(std::forward(more)...); 101| 7.64k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA6_KcRA1_SC_RA2_SC_RdSJ_SJ_EEEvOT_DpOT0_: 98| 1.50k| void AddProperties(T&& value, More&&... more) { 99| 1.50k| properties.emplace_back(std::forward(value)); 100| 1.50k| AddProperties(std::forward(more)...); 101| 1.50k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA6_KcJRA1_S3_RA2_S3_RdSA_SA_EEEvOT_DpOT0_: 98| 1.50k| void AddProperties(T&& value, More&&... more) { 99| 1.50k| properties.emplace_back(std::forward(value)); 100| 1.50k| AddProperties(std::forward(more)...); 101| 1.50k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA1_KcJRA2_S3_RdS8_S8_EEEvOT_DpOT0_: 98| 1.94k| void AddProperties(T&& value, More&&... more) { 99| 1.94k| properties.emplace_back(std::forward(value)); 100| 1.94k| AddProperties(std::forward(more)...); 101| 1.94k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA2_KcJRdS6_S6_EEEvOT_DpOT0_: 98| 1.94k| void AddProperties(T&& value, More&&... more) { 99| 1.94k| properties.emplace_back(std::forward(value)); 100| 1.94k| AddProperties(std::forward(more)...); 101| 1.94k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA9_KcRA7_SC_RA1_SC_RdSJ_SJ_EEEvOT_DpOT0_: 98| 4.74k| void AddProperties(T&& value, More&&... more) { 99| 4.74k| properties.emplace_back(std::forward(value)); 100| 4.74k| AddProperties(std::forward(more)...); 101| 4.74k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA9_KcJRA7_S3_RA1_S3_RdSA_SA_EEEvOT_DpOT0_: 98| 4.74k| void AddProperties(T&& value, More&&... more) { 99| 4.74k| properties.emplace_back(std::forward(value)); 100| 4.74k| AddProperties(std::forward(more)...); 101| 4.74k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA7_KcJRA1_S3_RdS8_S8_EEEvOT_DpOT0_: 98| 4.74k| void AddProperties(T&& value, More&&... more) { 99| 4.74k| properties.emplace_back(std::forward(value)); 100| 4.74k| AddProperties(std::forward(more)...); 101| 4.74k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA7_KcRA1_SC_RA2_SC_RdSJ_SJ_EEEvOT_DpOT0_: 98| 438| void AddProperties(T&& value, More&&... more) { 99| 438| properties.emplace_back(std::forward(value)); 100| 438| AddProperties(std::forward(more)...); 101| 438| } _ZN6Assimp3FBX4Node13AddPropertiesIRA7_KcJRA1_S3_RA2_S3_RdSA_SA_EEEvOT_DpOT0_: 98| 438| void AddProperties(T&& value, More&&... more) { 99| 438| properties.emplace_back(std::forward(value)); 100| 438| AddProperties(std::forward(more)...); 101| 438| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA8_KcRA1_SC_SG_SB_EEEvOT_DpOT0_: 98| 675| void AddProperties(T&& value, More&&... more) { 99| 675| properties.emplace_back(std::forward(value)); 100| 675| AddProperties(std::forward(more)...); 101| 675| } _ZN6Assimp3FBX4Node13AddPropertiesIRA8_KcJRA1_S3_S7_RKNSt3__112basic_stringIcNS8_11char_traitsIcEENS8_9allocatorIcEEEEEEEvOT_DpOT0_: 98| 675| void AddProperties(T&& value, More&&... more) { 99| 675| properties.emplace_back(std::forward(value)); 100| 675| AddProperties(std::forward(more)...); 101| 675| } _ZN6Assimp3FBX4Node13AddPropertiesIRA1_KcJS5_RKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEEvOT_DpOT0_: 98| 675| void AddProperties(T&& value, More&&... more) { 99| 675| properties.emplace_back(std::forward(value)); 100| 675| AddProperties(std::forward(more)...); 101| 675| } _ZN6Assimp3FBX4Node13AddPropertiesIRA1_KcJRKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEEEEvOT_DpOT0_: 98| 675| void AddProperties(T&& value, More&&... more) { 99| 675| properties.emplace_back(std::forward(value)); 100| 675| AddProperties(std::forward(more)...); 101| 675| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA5_KcRA1_SC_SG_RiEEEvOT_DpOT0_: 98| 38.9k| void AddProperties(T&& value, More&&... more) { 99| 38.9k| properties.emplace_back(std::forward(value)); 100| 38.9k| AddProperties(std::forward(more)...); 101| 38.9k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA5_KcJRA1_S3_S7_RiEEEvOT_DpOT0_: 98| 38.9k| void AddProperties(T&& value, More&&... more) { 99| 38.9k| properties.emplace_back(std::forward(value)); 100| 38.9k| AddProperties(std::forward(more)...); 101| 38.9k| } _ZN6Assimp3FBX4Node13AddPropertiesIRA1_KcJS5_RiEEEvOT_DpOT0_: 98| 38.9k| void AddProperties(T&& value, More&&... more) { 99| 38.9k| properties.emplace_back(std::forward(value)); 100| 38.9k| AddProperties(std::forward(more)...); 101| 38.9k| } _ZN6Assimp3FBX4Node13AddPropertiesIRKNSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEJRA6_KcRA5_SC_RA1_SC_RlEEEvOT_DpOT0_: 98| 680| void AddProperties(T&& value, More&&... more) { 99| 680| properties.emplace_back(std::forward(value)); 100| 680| AddProperties(std::forward(more)...); 101| 680| } _ZN6Assimp3FBX4Node13AddPropertiesIRA6_KcJRA5_S3_RA1_S3_RlEEEvOT_DpOT0_: 98| 680| void AddProperties(T&& value, More&&... more) { 99| 680| properties.emplace_back(std::forward(value)); 100| 680| AddProperties(std::forward(more)...); 101| 680| } _ZN6Assimp3FBX4Node13AddPropertiesIRA5_KcJRA1_S3_RlEEEvOT_DpOT0_: 98| 680| void AddProperties(T&& value, More&&... more) { 99| 680| properties.emplace_back(std::forward(value)); 100| 680| AddProperties(std::forward(more)...); 101| 680| } _ZN6Assimp3FBX4Node13AddPropertiesIRA1_KcJRlEEEvOT_DpOT0_: 98| 680| void AddProperties(T&& value, More&&... more) { 99| 680| properties.emplace_back(std::forward(value)); 100| 680| AddProperties(std::forward(more)...); 101| 680| } _ZN6Assimp3FBX17FBXExportPropertyC2Eb: 61| 37.1k|: type('C') 62| 37.1k|, data(1, uint8_t(v)) {} _ZN6Assimp3FBX17FBXExportPropertyC2Ei: 72| 299k|: type('I') 73| 299k|, data(4) { 74| 299k| uint8_t* d = data.data(); 75| 299k| (reinterpret_cast(d))[0] = v; 76| 299k|} _ZN6Assimp3FBX17FBXExportPropertyC2Ed: 86| 47.2k|: type('D') 87| 47.2k|, data(8) { 88| 47.2k| uint8_t* d = data.data(); 89| 47.2k| (reinterpret_cast(d))[0] = v; 90| 47.2k|} _ZN6Assimp3FBX17FBXExportPropertyC2El: 93| 229k|: type('L') 94| 229k|, data(8) { 95| 229k| uint8_t* d = data.data(); 96| 229k| (reinterpret_cast(d))[0] = v; 97| 229k|} _ZN6Assimp3FBX17FBXExportPropertyC2EPKcb: 102| 702k|: FBXExportProperty(std::string(c), raw) { 103| | // empty 104| 702k|} _ZN6Assimp3FBX17FBXExportPropertyC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEb: 108| 970k|: type(raw ? 'R' : 'S') ------------------ | Branch (108:8): [True: 0, False: 970k] ------------------ 109| 970k|, data(s.size()) { 110| 7.77M| for (size_t i = 0; i < s.size(); ++i) { ------------------ | Branch (110:24): [True: 6.80M, False: 970k] ------------------ 111| 6.80M| data[i] = uint8_t(s[i]); 112| 6.80M| } 113| 970k|} _ZN6Assimp3FBX17FBXExportPropertyC2ERKNSt3__16vectorIhNS2_9allocatorIhEEEE: 116| 215|: type('R') 117| 215|, data(r) { 118| | // empty 119| 215|} _ZN6Assimp3FBX17FBXExportPropertyC2ERKNSt3__16vectorIiNS2_9allocatorIiEEEE: 122| 26.6k|: type('i') 123| 26.6k|, data(4 * va.size() ) { 124| 26.6k| int32_t* d = reinterpret_cast(data.data()); 125| 292k| for (size_t i = 0; i < va.size(); ++i) { ------------------ | Branch (125:24): [True: 266k, False: 26.6k] ------------------ 126| 266k| d[i] = va[i]; 127| 266k| } 128| 26.6k|} _ZN6Assimp3FBX17FBXExportPropertyC2ERKNSt3__16vectorIlNS2_9allocatorIlEEEE: 131| 5.48k|: type('l') 132| 5.48k|, data(8 * va.size()) { 133| 5.48k| int64_t* d = reinterpret_cast(data.data()); 134| 43.8k| for (size_t i = 0; i < va.size(); ++i) { ------------------ | Branch (134:24): [True: 38.4k, False: 5.48k] ------------------ 135| 38.4k| d[i] = va[i]; 136| 38.4k| } 137| 5.48k|} _ZN6Assimp3FBX17FBXExportPropertyC2ERKNSt3__16vectorIfNS2_9allocatorIfEEEE: 140| 10.9k|: type('f') 141| 10.9k|, data(4 * va.size()) { 142| 10.9k| float* d = reinterpret_cast(data.data()); 143| 71.2k| for (size_t i = 0; i < va.size(); ++i) { ------------------ | Branch (143:24): [True: 60.3k, False: 10.9k] ------------------ 144| 60.3k| d[i] = va[i]; 145| 60.3k| } 146| 10.9k|} _ZN6Assimp3FBX17FBXExportPropertyC2ERKNSt3__16vectorIdNS2_9allocatorIdEEEE: 149| 3.08k|: type('d') 150| 3.08k|, data(8 * va.size()) { 151| 3.08k| double* d = reinterpret_cast(data.data()); 152| 19.7k| for (size_t i = 0; i < va.size(); ++i) { ------------------ | Branch (152:24): [True: 16.6k, False: 3.08k] ------------------ 153| 16.6k| d[i] = va[i]; 154| 16.6k| } 155| 3.08k|} _ZN6Assimp3FBX17FBXExportPropertyC2ERK12aiMatrix4x4tIfE: 158| 6.17k|: type('d') 159| 6.17k|, data(8 * 16) { 160| 6.17k| double* d = reinterpret_cast(data.data()); 161| 30.8k| for (unsigned int c = 0; c < 4; ++c) { ------------------ | Branch (161:30): [True: 24.6k, False: 6.17k] ------------------ 162| 123k| for (unsigned int r = 0; r < 4; ++r) { ------------------ | Branch (162:34): [True: 98.7k, False: 24.6k] ------------------ 163| 98.7k| d[4 * c + r] = vm[r][c]; 164| 98.7k| } 165| 24.6k| } 166| 6.17k|} _ZN6Assimp3FBX17FBXExportProperty10DumpBinaryERNS_12StreamWriterILb0ELb0EEE: 190| 1.63M|void FBXExportProperty::DumpBinary(Assimp::StreamWriterLE& s) { 191| 1.63M| s.PutU1(type); 192| 1.63M| uint8_t* d = data.data(); 193| 1.63M| size_t N; 194| 1.63M| switch (type) { 195| 37.1k| case 'C': s.PutU1(*(reinterpret_cast(d))); return; ------------------ | Branch (195:9): [True: 37.1k, False: 1.59M] ------------------ 196| 0| case 'Y': s.PutI2(*(reinterpret_cast(d))); return; ------------------ | Branch (196:9): [True: 0, False: 1.63M] ------------------ 197| 299k| case 'I': s.PutI4(*(reinterpret_cast(d))); return; ------------------ | Branch (197:9): [True: 299k, False: 1.33M] ------------------ 198| 0| case 'F': s.PutF4(*(reinterpret_cast(d))); return; ------------------ | Branch (198:9): [True: 0, False: 1.63M] ------------------ 199| 47.2k| case 'D': s.PutF8(*(reinterpret_cast(d))); return; ------------------ | Branch (199:9): [True: 47.2k, False: 1.58M] ------------------ 200| 229k| case 'L': s.PutI8(*(reinterpret_cast(d))); return; ------------------ | Branch (200:9): [True: 229k, False: 1.40M] ------------------ 201| 970k| case 'S': ------------------ | Branch (201:9): [True: 970k, False: 665k] ------------------ 202| 970k| case 'R': ------------------ | Branch (202:9): [True: 215, False: 1.63M] ------------------ 203| 970k| s.PutU4(uint32_t(data.size())); 204| 8.13M| for (size_t i = 0; i < data.size(); ++i) { s.PutU1(data[i]); } ------------------ | Branch (204:32): [True: 7.16M, False: 970k] ------------------ 205| 970k| return; 206| 26.6k| case 'i': ------------------ | Branch (206:9): [True: 26.6k, False: 1.60M] ------------------ 207| 26.6k| N = data.size() / 4; 208| 26.6k| s.PutU4(uint32_t(N)); // number of elements 209| 26.6k| s.PutU4(0); // no encoding (1 would be zip-compressed) 210| | // TODO: compress if large? 211| 26.6k| s.PutU4(uint32_t(data.size())); // data size 212| 292k| for (size_t i = 0; i < N; ++i) { ------------------ | Branch (212:32): [True: 266k, False: 26.6k] ------------------ 213| 266k| s.PutI4((reinterpret_cast(d))[i]); 214| 266k| } 215| 26.6k| return; 216| 5.48k| case 'l': ------------------ | Branch (216:9): [True: 5.48k, False: 1.63M] ------------------ 217| 5.48k| N = data.size() / 8; 218| 5.48k| s.PutU4(uint32_t(N)); // number of elements 219| 5.48k| s.PutU4(0); // no encoding (1 would be zip-compressed) 220| | // TODO: compress if large? 221| 5.48k| s.PutU4(uint32_t(data.size())); // data size 222| 43.8k| for (size_t i = 0; i < N; ++i) { ------------------ | Branch (222:32): [True: 38.4k, False: 5.48k] ------------------ 223| 38.4k| s.PutI8((reinterpret_cast(d))[i]); 224| 38.4k| } 225| 5.48k| return; 226| 10.9k| case 'f': ------------------ | Branch (226:9): [True: 10.9k, False: 1.62M] ------------------ 227| 10.9k| N = data.size() / 4; 228| 10.9k| s.PutU4(uint32_t(N)); // number of elements 229| 10.9k| s.PutU4(0); // no encoding (1 would be zip-compressed) 230| | // TODO: compress if large? 231| 10.9k| s.PutU4(uint32_t(data.size())); // data size 232| 71.2k| for (size_t i = 0; i < N; ++i) { ------------------ | Branch (232:32): [True: 60.3k, False: 10.9k] ------------------ 233| 60.3k| s.PutF4((reinterpret_cast(d))[i]); 234| 60.3k| } 235| 10.9k| return; 236| 9.25k| case 'd': ------------------ | Branch (236:9): [True: 9.25k, False: 1.62M] ------------------ 237| 9.25k| N = data.size() / 8; 238| 9.25k| s.PutU4(uint32_t(N)); // number of elements 239| 9.25k| s.PutU4(0); // no encoding (1 would be zip-compressed) 240| | // TODO: compress if large? 241| 9.25k| s.PutU4(uint32_t(data.size())); // data size 242| 124k| for (size_t i = 0; i < N; ++i) { ------------------ | Branch (242:32): [True: 115k, False: 9.25k] ------------------ 243| 115k| s.PutF8((reinterpret_cast(d))[i]); 244| 115k| } 245| 9.25k| return; 246| 0| default: ------------------ | Branch (246:9): [True: 0, False: 1.63M] ------------------ 247| 0| std::ostringstream err; 248| 0| err << "Tried to dump property with invalid type '"; 249| 0| err << type << "'!"; 250| 0| throw DeadlyExportError(err.str()); 251| 1.63M| } 252| 1.63M|} _ZN6Assimp14ExportSceneFBXEPKcPNS_8IOSystemEPK7aiScenePKNS_16ExportPropertiesE: 110| 208| ){ 111| | // initialize the exporter 112| 208| FBXExporter exporter(pScene, pProperties); 113| | 114| | // perform binary export 115| 208| exporter.ExportBinary(pFile, pIOSystem); 116| 208| } _ZN6Assimp11FBXExporterC2EPK7aiScenePKNS_16ExportPropertiesE: 138| 208|: binary(false) 139| 208|, mScene(pScene) 140| 208|, mProperties(pProperties) 141| 208|, outfile() 142| 208|, connections() 143| 208|, mesh_uids() 144| 208|, material_uids() 145| 208|, node_uids() { 146| | // will probably need to determine UIDs, connections, etc here. 147| | // basically anything that needs to be known 148| | // before we start writing sections to the stream. 149| 208|} _ZN6Assimp11FBXExporter12ExportBinaryEPKcPNS_8IOSystemE: 154| 208|){ 155| | // remember that we're exporting in binary mode 156| 208| binary = true; 157| | 158| | // we're not currently using these preferences, 159| | // but clang will cry about it if we never touch it. 160| | // TODO: some of these might be relevant to export 161| 208| (void)mProperties; 162| | 163| | // open the indicated file for writing (in binary mode) 164| 208| outfile.reset(pIOSystem->Open(pFile,"wb")); 165| 208| if (!outfile) { ------------------ | Branch (165:9): [True: 0, False: 208] ------------------ 166| 0| throw DeadlyExportError( 167| 0| "could not open output .fbx file: " + std::string(pFile) 168| 0| ); 169| 0| } 170| | 171| | // first a binary-specific file header 172| 208| WriteBinaryHeader(); 173| | 174| | // the rest of the file is in node entries. 175| | // we have to serialize each entry before we write to the output, 176| | // as the first thing we write is the byte offset of the _next_ entry. 177| | // Either that or we can skip back to write the offset when we finish. 178| 208| WriteAllNodes(); 179| | 180| | // finally we have a binary footer to the file 181| 208| WriteBinaryFooter(); 182| | 183| | // explicitly release file pointer, 184| | // so we don't have to rely on class destruction. 185| 208| outfile.reset(); 186| 208|} _ZN6Assimp11FBXExporter17WriteBinaryHeaderEv: 241| 208|{ 242| | // first a specific sequence of 23 bytes, always the same 243| 208| const char binary_header[24] = "Kaydara FBX Binary\x20\x20\x00\x1a\x00"; 244| 208| outfile->Write(binary_header, 1, 23); 245| | 246| | // then FBX version number, "multiplied" by 1000, as little-endian uint32. 247| | // so 7.3 becomes 7300 == 0x841C0000, 7.4 becomes 7400 == 0xE81C0000, etc 248| 208| { 249| 208| StreamWriterLE outstream(outfile); 250| 208| outstream.PutU4(EXPORT_VERSION_INT); 251| 208| } // StreamWriter destructor writes the data to the file 252| | 253| | // after this the node data starts immediately 254| | // (probably with the FBXHEaderExtension node) 255| 208|} _ZN6Assimp11FBXExporter17WriteBinaryFooterEv: 258| 207|{ 259| 207| outfile->Write(NULL_RECORD, NumNullRecords, 1); 260| | 261| 207| outfile->Write(GENERIC_FOOTID.c_str(), GENERIC_FOOTID.size(), 1); 262| | 263| | // here some padding is added for alignment to 16 bytes. 264| | // if already aligned, the full 16 bytes is added. 265| 207| size_t pos = outfile->Tell(); 266| 207| size_t pad = 16 - (pos % 16); 267| 1.92k| for (size_t i = 0; i < pad; ++i) { ------------------ | Branch (267:24): [True: 1.71k, False: 207] ------------------ 268| 1.71k| outfile->Write("\x00", 1, 1); 269| 1.71k| } 270| | 271| | // not sure what this is, but it seems to always be 0 in modern files 272| 1.03k| for (size_t i = 0; i < 4; ++i) { ------------------ | Branch (272:24): [True: 828, False: 207] ------------------ 273| 828| outfile->Write("\x00", 1, 1); 274| 828| } 275| | 276| | // now the file version again 277| 207| { 278| 207| StreamWriterLE outstream(outfile); 279| 207| outstream.PutU4(EXPORT_VERSION_INT); 280| 207| } // StreamWriter destructor writes the data to the file 281| | 282| | // and finally some binary footer added to all files 283| 25.0k| for (size_t i = 0; i < 120; ++i) { ------------------ | Branch (283:24): [True: 24.8k, False: 207] ------------------ 284| 24.8k| outfile->Write("\x00", 1, 1); 285| 24.8k| } 286| 207| outfile->Write(FOOT_MAGIC.c_str(), FOOT_MAGIC.size(), 1); 287| 207|} _ZN6Assimp11FBXExporter13WriteAllNodesEv: 290| 208|{ 291| | // header 292| | // (and fileid, creation time, creator, if binary) 293| 208| WriteHeaderExtension(); 294| | 295| | // global settings 296| 208| WriteGlobalSettings(); 297| | 298| | // documents 299| 208| WriteDocuments(); 300| | 301| | // references 302| 208| WriteReferences(); 303| | 304| | // definitions 305| 208| WriteDefinitions(); 306| | 307| | // objects 308| 208| WriteObjects(); 309| | 310| | // connections 311| 208| WriteConnections(); 312| | 313| | // WriteTakes? (deprecated since at least 2015 (fbx 7.4)) 314| 208|} _ZN6Assimp11FBXExporter20WriteHeaderExtensionEv: 318| 208|{ 319| 208| if (!binary) { ------------------ | Branch (319:9): [True: 0, False: 208] ------------------ 320| | // no title, follows directly from the top comment 321| 0| } 322| 208| FBX::Node n("FBXHeaderExtension"); 323| 208| StreamWriterLE outstream(outfile); 324| 208| int indent = 0; 325| | 326| | // begin node 327| 208| n.Begin(outstream, binary, indent); 328| | 329| | // write properties 330| | // (none) 331| | 332| | // finish properties 333| 208| n.EndProperties(outstream, binary, indent, 0); 334| | 335| | // begin children 336| 208| n.BeginChildren(outstream, binary, indent); 337| | 338| 208| indent = 1; 339| | 340| | // write child nodes 341| 208| FBX::Node::WritePropertyNode( 342| 208| "FBXHeaderVersion", int32_t(1003), outstream, binary, indent 343| 208| ); 344| 208| FBX::Node::WritePropertyNode( 345| 208| "FBXVersion", int32_t(EXPORT_VERSION_INT), outstream, binary, indent 346| 208| ); 347| 208| if (binary) { ------------------ | Branch (347:9): [True: 208, False: 0] ------------------ 348| 208| FBX::Node::WritePropertyNode( 349| 208| "EncryptionType", int32_t(0), outstream, binary, indent 350| 208| ); 351| 208| } 352| | 353| 208| FBX::Node CreationTimeStamp("CreationTimeStamp"); 354| 208| time_t rawtime; 355| 208| time(&rawtime); 356| 208| struct tm * now = localtime(&rawtime); 357| 208| CreationTimeStamp.AddChild("Version", int32_t(1000)); 358| 208| CreationTimeStamp.AddChild("Year", int32_t(now->tm_year + 1900)); 359| 208| CreationTimeStamp.AddChild("Month", int32_t(now->tm_mon + 1)); 360| 208| CreationTimeStamp.AddChild("Day", int32_t(now->tm_mday)); 361| 208| CreationTimeStamp.AddChild("Hour", int32_t(now->tm_hour)); 362| 208| CreationTimeStamp.AddChild("Minute", int32_t(now->tm_min)); 363| 208| CreationTimeStamp.AddChild("Second", int32_t(now->tm_sec)); 364| 208| CreationTimeStamp.AddChild("Millisecond", int32_t(0)); 365| 208| CreationTimeStamp.Dump(outstream, binary, indent); 366| | 367| 208| std::stringstream creator; 368| 208| creator << "Open Asset Import Library (Assimp) " << aiGetVersionMajor() 369| 208| << "." << aiGetVersionMinor() << "." << aiGetVersionRevision(); 370| 208| FBX::Node::WritePropertyNode( 371| 208| "Creator", creator.str(), outstream, binary, indent 372| 208| ); 373| | 374| 208| indent = 0; 375| | 376| | // finish node 377| 208| n.End(outstream, binary, indent, true); 378| | 379| | // that's it for FBXHeaderExtension... 380| 208| if (!binary) { return; } ------------------ | Branch (380:9): [True: 0, False: 208] ------------------ 381| | 382| | // but binary files also need top-level FileID, CreationTime, Creator: 383| 208| std::vector raw(GENERIC_FILEID.size()); 384| 3.53k| for (size_t i = 0; i < GENERIC_FILEID.size(); ++i) { ------------------ | Branch (384:24): [True: 3.32k, False: 208] ------------------ 385| 3.32k| raw[i] = uint8_t(GENERIC_FILEID[i]); 386| 3.32k| } 387| 208| FBX::Node::WritePropertyNode( 388| 208| "FileId", std::move(raw), outstream, binary, indent 389| 208| ); 390| 208| FBX::Node::WritePropertyNode( 391| 208| "CreationTime", GENERIC_CTIME, outstream, binary, indent 392| 208| ); 393| 208| FBX::Node::WritePropertyNode( 394| 208| "Creator", creator.str(), outstream, binary, indent 395| 208| ); 396| 208|} _Z12WritePropIntPK7aiSceneRN6Assimp3FBX4NodeERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEi: 401| 1.87k|{ 402| 1.87k| int value; 403| 1.87k| if (scene->mMetaData != nullptr && scene->mMetaData->Get(key, value)) { ------------------ | Branch (403:9): [True: 1.87k, False: 0] | Branch (403:40): [True: 0, False: 1.87k] ------------------ 404| 0| p.AddP70int(key, value); 405| 1.87k| } else { 406| 1.87k| p.AddP70int(key, defaultValue); 407| 1.87k| } 408| 1.87k|} _Z15WritePropDoublePK7aiSceneRN6Assimp3FBX4NodeERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEd: 411| 624|{ 412| 624| double value; 413| 624| if (scene->mMetaData != nullptr && scene->mMetaData->Get(key, value)) { ------------------ | Branch (413:9): [True: 624, False: 0] | Branch (413:40): [True: 0, False: 624] ------------------ 414| 0| p.AddP70double(key, value); 415| 624| } else { 416| | // fallback lookup float instead 417| 624| float floatValue; 418| 624| if (scene->mMetaData != nullptr && scene->mMetaData->Get(key, floatValue)) { ------------------ | Branch (418:13): [True: 624, False: 0] | Branch (418:44): [True: 0, False: 624] ------------------ 419| 0| p.AddP70double(key, (double)floatValue); 420| 624| } else { 421| 624| p.AddP70double(key, defaultValue); 422| 624| } 423| 624| } 424| 624|} _Z13WritePropEnumPK7aiSceneRN6Assimp3FBX4NodeERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEEi: 427| 624|{ 428| 624| int value; 429| 624| if (scene->mMetaData != nullptr && scene->mMetaData->Get(key, value)) { ------------------ | Branch (429:9): [True: 624, False: 0] | Branch (429:40): [True: 0, False: 624] ------------------ 430| 0| p.AddP70enum(key, value); 431| 624| } else { 432| 624| p.AddP70enum(key, defaultValue); 433| 624| } 434| 624|} _Z14WritePropColorPK7aiSceneRN6Assimp3FBX4NodeERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEERK10aiVector3tIfE: 437| 208|{ 438| 208| aiVector3D value; 439| 208| if (scene->mMetaData != nullptr && scene->mMetaData->Get(key, value)) { ------------------ | Branch (439:9): [True: 208, False: 0] | Branch (439:40): [True: 0, False: 208] ------------------ 440| | // ai_real can be float or double, cast to avoid warnings 441| 0| p.AddP70color(key, (double)value.x, (double)value.y, (double)value.z); 442| 208| } else { 443| 208| p.AddP70color(key, (double)defaultValue.x, (double)defaultValue.y, (double)defaultValue.z); 444| 208| } 445| 208|} _Z15WritePropStringPK7aiSceneRN6Assimp3FBX4NodeERKNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEESE_: 448| 208|{ 449| 208| aiString value; // MetaData doesn't hold std::string 450| 208| if (scene->mMetaData != nullptr && scene->mMetaData->Get(key, value)) { ------------------ | Branch (450:9): [True: 208, False: 0] | Branch (450:40): [True: 0, False: 208] ------------------ 451| 0| p.AddP70string(key, value.C_Str()); 452| 208| } else { 453| 208| p.AddP70string(key, defaultValue); 454| 208| } 455| 208|} _ZN6Assimp11FBXExporter19WriteGlobalSettingsEv: 457| 208|void FBXExporter::WriteGlobalSettings () { 458| 208| FBX::Node gs("GlobalSettings"); 459| 208| gs.AddChild("Version", int32_t(1000)); 460| | 461| 208| FBX::Node p("Properties70"); 462| 208| WritePropInt(mScene, p, "UpAxis", 1); 463| 208| WritePropInt(mScene, p, "UpAxisSign", 1); 464| 208| WritePropInt(mScene, p, "FrontAxis", 2); 465| 208| WritePropInt(mScene, p, "FrontAxisSign", 1); 466| 208| WritePropInt(mScene, p, "CoordAxis", 0); 467| 208| WritePropInt(mScene, p, "CoordAxisSign", 1); 468| 208| WritePropInt(mScene, p, "OriginalUpAxis", 1); 469| 208| WritePropInt(mScene, p, "OriginalUpAxisSign", 1); 470| 208| WritePropDouble(mScene, p, "UnitScaleFactor", 1.0); 471| 208| WritePropDouble(mScene, p, "OriginalUnitScaleFactor", 1.0); 472| 208| WritePropColor(mScene, p, "AmbientColor", aiVector3D((ai_real)0.0, (ai_real)0.0, (ai_real)0.0)); 473| 208| WritePropString(mScene, p,"DefaultCamera", "Producer Perspective"); 474| 208| WritePropEnum(mScene, p, "TimeMode", 11); 475| 208| WritePropEnum(mScene, p, "TimeProtocol", 2); 476| 208| WritePropEnum(mScene, p, "SnapOnFrameMode", 0); 477| 208| p.AddP70time("TimeSpanStart", 0); // TODO: animation support 478| 208| p.AddP70time("TimeSpanStop", FBX::SECOND); // TODO: animation support 479| 208| WritePropDouble(mScene, p, "CustomFrameRate", -1.0); 480| 208| p.AddP70("TimeMarker", "Compound", "", ""); // not sure what this is 481| 208| WritePropInt(mScene, p, "CurrentTimeMarker", -1); 482| 208| gs.AddChild(p); 483| | 484| 208| gs.Dump(outfile, binary, 0); 485| 208|} _ZN6Assimp11FBXExporter14WriteDocumentsEv: 487| 208|void FBXExporter::WriteDocuments() { 488| 208| if (!binary) { ------------------ | Branch (488:9): [True: 0, False: 208] ------------------ 489| 0| WriteAsciiSectionHeader("Documents Description"); 490| 0| } 491| | 492| | // not sure what the use of multiple documents would be, 493| | // or whether any end-application supports it 494| 208| FBX::Node docs("Documents"); 495| 208| docs.AddChild("Count", int32_t(1)); 496| 208| FBX::Node doc("Document"); 497| | 498| | // generate uid 499| 208| int64_t uid = generate_uid(); 500| 208| doc.AddProperties(uid, "", "Scene"); 501| 208| FBX::Node p("Properties70"); 502| 208| p.AddP70("SourceObject", "object", "", ""); // what is this even for? 503| 208| p.AddP70string("ActiveAnimStackName", ""); // should do this properly? 504| 208| doc.AddChild(p); 505| | 506| | // UID for root node in scene hierarchy. 507| | // always set to 0 in the case of a single document. 508| | // not sure what happens if more than one document exists, 509| | // but that won't matter to us as we're exporting a single scene. 510| 208| doc.AddChild("RootNode", int64_t(0)); 511| | 512| 208| docs.AddChild(doc); 513| 208| docs.Dump(outfile, binary, 0); 514| 208|} _ZN6Assimp11FBXExporter15WriteReferencesEv: 516| 208|void FBXExporter::WriteReferences() { 517| 208| if (!binary) { ------------------ | Branch (517:9): [True: 0, False: 208] ------------------ 518| 0| WriteAsciiSectionHeader("Document References"); 519| 0| } 520| | // always empty for now. 521| | // not really sure what this is for. 522| 208| FBX::Node n("References"); 523| 208| n.force_has_children = true; 524| 208| n.Dump(outfile, binary, 0); 525| 208|} _Z11count_nodesPK6aiNodeS1_: 532| 37.2k|size_t count_nodes(const aiNode* n, const aiNode* root) { 533| 37.2k| size_t count; 534| 37.2k| if (n == root) { ------------------ | Branch (534:9): [True: 208, False: 37.0k] ------------------ 535| 208| count = n->mNumMeshes; // (not counting root node) 536| 37.0k| } else if (n->mNumMeshes > 1) { ------------------ | Branch (536:16): [True: 267, False: 36.8k] ------------------ 537| 267| count = n->mNumMeshes + 1; 538| 36.8k| } else { 539| 36.8k| count = 1; 540| 36.8k| } 541| 74.3k| for (size_t i = 0; i < n->mNumChildren; ++i) { ------------------ | Branch (541:24): [True: 37.0k, False: 37.2k] ------------------ 542| 37.0k| count += count_nodes(n->mChildren[i], root); 543| 37.0k| } 544| 37.2k| return count; 545| 37.2k|} _ZN6Assimp11FBXExporter16WriteDefinitionsEv: 608| 208|void FBXExporter::WriteDefinitions () { 609| | // basically this is just bookkeeping: 610| | // determining how many of each type of object there are 611| | // and specifying the base properties to use when otherwise unspecified. 612| | 613| | // ascii section header 614| 208| if (!binary) { ------------------ | Branch (614:9): [True: 0, False: 208] ------------------ 615| 0| WriteAsciiSectionHeader("Object definitions"); 616| 0| } 617| | 618| | // we need to count the objects 619| 208| int32_t count; 620| 208| int32_t total_count = 0; 621| | 622| | // and store them 623| 208| std::vector object_nodes; 624| 208| FBX::Node n, pt, p; 625| | 626| | // GlobalSettings 627| | // this seems to always be here in Maya exports 628| 208| n = FBX::Node("ObjectType", "GlobalSettings"); 629| 208| count = 1; 630| 208| n.AddChild("Count", count); 631| 208| object_nodes.push_back(n); 632| 208| total_count += count; 633| | 634| | // AnimationStack / FbxAnimStack 635| | // this seems to always be here in Maya exports, 636| | // but no harm seems to come of leaving it out. 637| 208| count = mScene->mNumAnimations; 638| 208| if (count) { ------------------ | Branch (638:9): [True: 26, False: 182] ------------------ 639| 26| n = FBX::Node("ObjectType", "AnimationStack"); 640| 26| n.AddChild("Count", count); 641| 26| pt = FBX::Node("PropertyTemplate", "FbxAnimStack"); 642| 26| p = FBX::Node("Properties70"); 643| 26| p.AddP70string("Description", ""); 644| 26| p.AddP70time("LocalStart", 0); 645| 26| p.AddP70time("LocalStop", 0); 646| 26| p.AddP70time("ReferenceStart", 0); 647| 26| p.AddP70time("ReferenceStop", 0); 648| 26| pt.AddChild(p); 649| 26| n.AddChild(pt); 650| 26| object_nodes.push_back(n); 651| 26| total_count += count; 652| 26| } 653| | 654| | // AnimationLayer / FbxAnimLayer 655| | // this seems to always be here in Maya exports, 656| | // but no harm seems to come of leaving it out. 657| | // Assimp doesn't support animation layers, 658| | // so there will be one per aiAnimation 659| 208| count = mScene->mNumAnimations; 660| 208| if (count) { ------------------ | Branch (660:9): [True: 26, False: 182] ------------------ 661| 26| n = FBX::Node("ObjectType", "AnimationLayer"); 662| 26| n.AddChild("Count", count); 663| 26| pt = FBX::Node("PropertyTemplate", "FBXAnimLayer"); 664| 26| p = FBX::Node("Properties70"); 665| 26| p.AddP70("Weight", "Number", "", "A", double(100)); 666| 26| p.AddP70bool("Mute", false); 667| 26| p.AddP70bool("Solo", false); 668| 26| p.AddP70bool("Lock", false); 669| 26| p.AddP70color("Color", 0.8, 0.8, 0.8); 670| 26| p.AddP70("BlendMode", "enum", "", "", int32_t(0)); 671| 26| p.AddP70("RotationAccumulationMode", "enum", "", "", int32_t(0)); 672| 26| p.AddP70("ScaleAccumulationMode", "enum", "", "", int32_t(0)); 673| 26| p.AddP70("BlendModeBypass", "ULongLong", "", "", int64_t(0)); 674| 26| pt.AddChild(p); 675| 26| n.AddChild(pt); 676| 26| object_nodes.push_back(n); 677| 26| total_count += count; 678| 26| } 679| | 680| | // NodeAttribute 681| | // this is completely absurd. 682| | // there can only be one "NodeAttribute" template, 683| | // but FbxSkeleton, FbxCamera, FbxLight all are "NodeAttributes". 684| | // so if only one exists we should set the template for that, 685| | // otherwise... we just pick one :/. 686| | // the others have to set all their properties every instance, 687| | // because there's no template. 688| 208| count = 1; // TODO: select properly 689| 208| if (count) { ------------------ | Branch (689:9): [True: 208, False: 0] ------------------ 690| | // FbxSkeleton 691| 208| n = FBX::Node("ObjectType", "NodeAttribute"); 692| 208| n.AddChild("Count", count); 693| 208| pt = FBX::Node("PropertyTemplate", "FbxSkeleton"); 694| 208| p = FBX::Node("Properties70"); 695| 208| p.AddP70color("Color", 0.8, 0.8, 0.8); 696| 208| p.AddP70double("Size", 33.333333333333); 697| 208| p.AddP70("LimbLength", "double", "Number", "H", double(1)); 698| | // note: not sure what the "H" flag is for - hidden? 699| 208| pt.AddChild(p); 700| 208| n.AddChild(pt); 701| 208| object_nodes.push_back(n); 702| 208| total_count += count; 703| 208| } 704| | 705| | // Model / FbxNode 706| | // <~~ node hierarchy 707| 208| count = int32_t(count_nodes(mScene->mRootNode, mScene->mRootNode)); 708| 208| if (count) { ------------------ | Branch (708:9): [True: 208, False: 0] ------------------ 709| 208| n = FBX::Node("ObjectType", "Model"); 710| 208| n.AddChild("Count", count); 711| 208| pt = FBX::Node("PropertyTemplate", "FbxNode"); 712| 208| p = FBX::Node("Properties70"); 713| 208| p.AddP70enum("QuaternionInterpolate", 0); 714| 208| p.AddP70vector("RotationOffset", 0.0, 0.0, 0.0); 715| 208| p.AddP70vector("RotationPivot", 0.0, 0.0, 0.0); 716| 208| p.AddP70vector("ScalingOffset", 0.0, 0.0, 0.0); 717| 208| p.AddP70vector("ScalingPivot", 0.0, 0.0, 0.0); 718| 208| p.AddP70bool("TranslationActive", false); 719| 208| p.AddP70vector("TranslationMin", 0.0, 0.0, 0.0); 720| 208| p.AddP70vector("TranslationMax", 0.0, 0.0, 0.0); 721| 208| p.AddP70bool("TranslationMinX", false); 722| 208| p.AddP70bool("TranslationMinY", false); 723| 208| p.AddP70bool("TranslationMinZ", false); 724| 208| p.AddP70bool("TranslationMaxX", false); 725| 208| p.AddP70bool("TranslationMaxY", false); 726| 208| p.AddP70bool("TranslationMaxZ", false); 727| 208| p.AddP70enum("RotationOrder", 0); 728| 208| p.AddP70bool("RotationSpaceForLimitOnly", false); 729| 208| p.AddP70double("RotationStiffnessX", 0.0); 730| 208| p.AddP70double("RotationStiffnessY", 0.0); 731| 208| p.AddP70double("RotationStiffnessZ", 0.0); 732| 208| p.AddP70double("AxisLen", 10.0); 733| 208| p.AddP70vector("PreRotation", 0.0, 0.0, 0.0); 734| 208| p.AddP70vector("PostRotation", 0.0, 0.0, 0.0); 735| 208| p.AddP70bool("RotationActive", false); 736| 208| p.AddP70vector("RotationMin", 0.0, 0.0, 0.0); 737| 208| p.AddP70vector("RotationMax", 0.0, 0.0, 0.0); 738| 208| p.AddP70bool("RotationMinX", false); 739| 208| p.AddP70bool("RotationMinY", false); 740| 208| p.AddP70bool("RotationMinZ", false); 741| 208| p.AddP70bool("RotationMaxX", false); 742| 208| p.AddP70bool("RotationMaxY", false); 743| 208| p.AddP70bool("RotationMaxZ", false); 744| 208| p.AddP70enum("InheritType", 0); 745| 208| p.AddP70bool("ScalingActive", false); 746| 208| p.AddP70vector("ScalingMin", 0.0, 0.0, 0.0); 747| 208| p.AddP70vector("ScalingMax", 1.0, 1.0, 1.0); 748| 208| p.AddP70bool("ScalingMinX", false); 749| 208| p.AddP70bool("ScalingMinY", false); 750| 208| p.AddP70bool("ScalingMinZ", false); 751| 208| p.AddP70bool("ScalingMaxX", false); 752| 208| p.AddP70bool("ScalingMaxY", false); 753| 208| p.AddP70bool("ScalingMaxZ", false); 754| 208| p.AddP70vector("GeometricTranslation", 0.0, 0.0, 0.0); 755| 208| p.AddP70vector("GeometricRotation", 0.0, 0.0, 0.0); 756| 208| p.AddP70vector("GeometricScaling", 1.0, 1.0, 1.0); 757| 208| p.AddP70double("MinDampRangeX", 0.0); 758| 208| p.AddP70double("MinDampRangeY", 0.0); 759| 208| p.AddP70double("MinDampRangeZ", 0.0); 760| 208| p.AddP70double("MaxDampRangeX", 0.0); 761| 208| p.AddP70double("MaxDampRangeY", 0.0); 762| 208| p.AddP70double("MaxDampRangeZ", 0.0); 763| 208| p.AddP70double("MinDampStrengthX", 0.0); 764| 208| p.AddP70double("MinDampStrengthY", 0.0); 765| 208| p.AddP70double("MinDampStrengthZ", 0.0); 766| 208| p.AddP70double("MaxDampStrengthX", 0.0); 767| 208| p.AddP70double("MaxDampStrengthY", 0.0); 768| 208| p.AddP70double("MaxDampStrengthZ", 0.0); 769| 208| p.AddP70double("PreferedAngleX", 0.0); 770| 208| p.AddP70double("PreferedAngleY", 0.0); 771| 208| p.AddP70double("PreferedAngleZ", 0.0); 772| 208| p.AddP70("LookAtProperty", "object", "", ""); 773| 208| p.AddP70("UpVectorProperty", "object", "", ""); 774| 208| p.AddP70bool("Show", true); 775| 208| p.AddP70bool("NegativePercentShapeSupport", true); 776| 208| p.AddP70int("DefaultAttributeIndex", -1); 777| 208| p.AddP70bool("Freeze", false); 778| 208| p.AddP70bool("LODBox", false); 779| 208| p.AddP70( 780| 208| "Lcl Translation", "Lcl Translation", "", "A", 781| 208| double(0), double(0), double(0) 782| 208| ); 783| 208| p.AddP70( 784| 208| "Lcl Rotation", "Lcl Rotation", "", "A", 785| 208| double(0), double(0), double(0) 786| 208| ); 787| 208| p.AddP70( 788| 208| "Lcl Scaling", "Lcl Scaling", "", "A", 789| 208| double(1), double(1), double(1) 790| 208| ); 791| 208| p.AddP70("Visibility", "Visibility", "", "A", double(1)); 792| 208| p.AddP70( 793| 208| "Visibility Inheritance", "Visibility Inheritance", "", "", 794| 208| int32_t(1) 795| 208| ); 796| 208| pt.AddChild(p); 797| 208| n.AddChild(pt); 798| 208| object_nodes.push_back(n); 799| 208| total_count += count; 800| 208| } 801| | 802| | // Geometry / FbxMesh 803| | // <~~ aiMesh 804| 208| count = mScene->mNumMeshes; 805| | 806| | // Blendshapes are considered Geometry 807| 208| int32_t bsDeformerCount=0; 808| 3.78k| for (size_t mi = 0; mi < mScene->mNumMeshes; ++mi) { ------------------ | Branch (808:25): [True: 3.57k, False: 208] ------------------ 809| 3.57k| aiMesh* m = mScene->mMeshes[mi]; 810| 3.57k| if (m->mNumAnimMeshes > 0) { ------------------ | Branch (810:13): [True: 0, False: 3.57k] ------------------ 811| 0| count+=m->mNumAnimMeshes; 812| 0| bsDeformerCount+=m->mNumAnimMeshes; // One deformer per blendshape 813| 0| bsDeformerCount++; // Plus one master blendshape deformer 814| 0| } 815| 3.57k| } 816| | 817| 208| if (count) { ------------------ | Branch (817:9): [True: 174, False: 34] ------------------ 818| 174| n = FBX::Node("ObjectType", "Geometry"); 819| 174| n.AddChild("Count", count); 820| 174| pt = FBX::Node("PropertyTemplate", "FbxMesh"); 821| 174| p = FBX::Node("Properties70"); 822| 174| p.AddP70color("Color", 0, 0, 0); 823| 174| p.AddP70vector("BBoxMin", 0, 0, 0); 824| 174| p.AddP70vector("BBoxMax", 0, 0, 0); 825| 174| p.AddP70bool("Primary Visibility", true); 826| 174| p.AddP70bool("Casts Shadows", true); 827| 174| p.AddP70bool("Receive Shadows", true); 828| 174| pt.AddChild(p); 829| 174| n.AddChild(pt); 830| 174| object_nodes.push_back(n); 831| 174| total_count += count; 832| 174| } 833| | 834| | // Material / FbxSurfacePhong, FbxSurfaceLambert, FbxSurfaceMaterial 835| | // <~~ aiMaterial 836| | // basically if there's any phong material this is defined as phong, 837| | // and otherwise lambert. 838| | // More complex materials cause a bare-bones FbxSurfaceMaterial definition 839| | // and are treated specially, as they're not really supported by FBX. 840| | // TODO: support Maya's Stingray PBS material 841| 208| count = mScene->mNumMaterials; 842| 208| if (count) { ------------------ | Branch (842:9): [True: 174, False: 34] ------------------ 843| 174| bool has_phong = has_phong_mat(mScene); 844| 174| n = FBX::Node("ObjectType", "Material"); 845| 174| n.AddChild("Count", count); 846| 174| pt = FBX::Node("PropertyTemplate"); 847| 174| if (has_phong) { ------------------ | Branch (847:13): [True: 57, False: 117] ------------------ 848| 57| pt.AddProperty("FbxSurfacePhong"); 849| 117| } else { 850| 117| pt.AddProperty("FbxSurfaceLambert"); 851| 117| } 852| 174| p = FBX::Node("Properties70"); 853| 174| if (has_phong) { ------------------ | Branch (853:13): [True: 57, False: 117] ------------------ 854| 57| p.AddP70string("ShadingModel", "Phong"); 855| 117| } else { 856| 117| p.AddP70string("ShadingModel", "Lambert"); 857| 117| } 858| 174| p.AddP70bool("MultiLayer", false); 859| 174| p.AddP70colorA("EmissiveColor", 0.0, 0.0, 0.0); 860| 174| p.AddP70numberA("EmissiveFactor", 1.0); 861| 174| p.AddP70colorA("AmbientColor", 0.2, 0.2, 0.2); 862| 174| p.AddP70numberA("AmbientFactor", 1.0); 863| 174| p.AddP70colorA("DiffuseColor", 0.8, 0.8, 0.8); 864| 174| p.AddP70numberA("DiffuseFactor", 1.0); 865| 174| p.AddP70vector("Bump", 0.0, 0.0, 0.0); 866| 174| p.AddP70vector("NormalMap", 0.0, 0.0, 0.0); 867| 174| p.AddP70double("BumpFactor", 1.0); 868| 174| p.AddP70colorA("TransparentColor", 0.0, 0.0, 0.0); 869| 174| p.AddP70numberA("TransparencyFactor", 0.0); 870| 174| p.AddP70color("DisplacementColor", 0.0, 0.0, 0.0); 871| 174| p.AddP70double("DisplacementFactor", 1.0); 872| 174| p.AddP70color("VectorDisplacementColor", 0.0, 0.0, 0.0); 873| 174| p.AddP70double("VectorDisplacementFactor", 1.0); 874| 174| if (has_phong) { ------------------ | Branch (874:13): [True: 57, False: 117] ------------------ 875| 57| p.AddP70colorA("SpecularColor", 0.2, 0.2, 0.2); 876| 57| p.AddP70numberA("SpecularFactor", 1.0); 877| 57| p.AddP70numberA("ShininessExponent", 20.0); 878| 57| p.AddP70colorA("ReflectionColor", 0.0, 0.0, 0.0); 879| 57| p.AddP70numberA("ReflectionFactor", 1.0); 880| 57| } 881| 174| pt.AddChild(p); 882| 174| n.AddChild(pt); 883| 174| object_nodes.push_back(n); 884| 174| total_count += count; 885| 174| } 886| | 887| | // Video / FbxVideo 888| | // one for each image file. 889| 208| count = int32_t(count_images(mScene)); 890| 208| if (count) { ------------------ | Branch (890:9): [True: 48, False: 160] ------------------ 891| 48| n = FBX::Node("ObjectType", "Video"); 892| 48| n.AddChild("Count", count); 893| 48| pt = FBX::Node("PropertyTemplate", "FbxVideo"); 894| 48| p = FBX::Node("Properties70"); 895| 48| p.AddP70bool("ImageSequence", false); 896| 48| p.AddP70int("ImageSequenceOffset", 0); 897| 48| p.AddP70double("FrameRate", 0.0); 898| 48| p.AddP70int("LastFrame", 0); 899| 48| p.AddP70int("Width", 0); 900| 48| p.AddP70int("Height", 0); 901| 48| p.AddP70("Path", "KString", "XRefUrl", "", ""); 902| 48| p.AddP70int("StartFrame", 0); 903| 48| p.AddP70int("StopFrame", 0); 904| 48| p.AddP70double("PlaySpeed", 0.0); 905| 48| p.AddP70time("Offset", 0); 906| 48| p.AddP70enum("InterlaceMode", 0); 907| 48| p.AddP70bool("FreeRunning", false); 908| 48| p.AddP70bool("Loop", false); 909| 48| p.AddP70enum("AccessMode", 0); 910| 48| pt.AddChild(p); 911| 48| n.AddChild(pt); 912| 48| object_nodes.push_back(n); 913| 48| total_count += count; 914| 48| } 915| | 916| | // Texture / FbxFileTexture 917| | // <~~ aiTexture 918| 208| count = int32_t(count_textures(mScene)); 919| 208| if (count) { ------------------ | Branch (919:9): [True: 48, False: 160] ------------------ 920| 48| n = FBX::Node("ObjectType", "Texture"); 921| 48| n.AddChild("Count", count); 922| 48| pt = FBX::Node("PropertyTemplate", "FbxFileTexture"); 923| 48| p = FBX::Node("Properties70"); 924| 48| p.AddP70enum("TextureTypeUse", 0); 925| 48| p.AddP70numberA("Texture alpha", 1.0); 926| 48| p.AddP70enum("CurrentMappingType", 0); 927| 48| p.AddP70enum("WrapModeU", 0); 928| 48| p.AddP70enum("WrapModeV", 0); 929| 48| p.AddP70bool("UVSwap", false); 930| 48| p.AddP70bool("PremultiplyAlpha", true); 931| 48| p.AddP70vectorA("Translation", 0.0, 0.0, 0.0); 932| 48| p.AddP70vectorA("Rotation", 0.0, 0.0, 0.0); 933| 48| p.AddP70vectorA("Scaling", 1.0, 1.0, 1.0); 934| 48| p.AddP70vector("TextureRotationPivot", 0.0, 0.0, 0.0); 935| 48| p.AddP70vector("TextureScalingPivot", 0.0, 0.0, 0.0); 936| 48| p.AddP70enum("CurrentTextureBlendMode", 1); 937| 48| p.AddP70string("UVSet", "default"); 938| 48| p.AddP70bool("UseMaterial", false); 939| 48| p.AddP70bool("UseMipMap", false); 940| 48| pt.AddChild(p); 941| 48| n.AddChild(pt); 942| 48| object_nodes.push_back(n); 943| 48| total_count += count; 944| 48| } 945| | 946| | // AnimationCurveNode / FbxAnimCurveNode 947| 208| count = mScene->mNumAnimations * 3; 948| 208| if (count) { ------------------ | Branch (948:9): [True: 26, False: 182] ------------------ 949| 26| n = FBX::Node("ObjectType", "AnimationCurveNode"); 950| 26| n.AddChild("Count", count); 951| 26| pt = FBX::Node("PropertyTemplate", "FbxAnimCurveNode"); 952| 26| p = FBX::Node("Properties70"); 953| 26| p.AddP70("d", "Compound", "", ""); 954| 26| pt.AddChild(p); 955| 26| n.AddChild(pt); 956| 26| object_nodes.push_back(n); 957| 26| total_count += count; 958| 26| } 959| | 960| | // AnimationCurve / FbxAnimCurve 961| 208| count = mScene->mNumAnimations * 9; 962| 208| if (count) { ------------------ | Branch (962:9): [True: 26, False: 182] ------------------ 963| 26| n = FBX::Node("ObjectType", "AnimationCurve"); 964| 26| n.AddChild("Count", count); 965| 26| object_nodes.push_back(n); 966| 26| total_count += count; 967| 26| } 968| | 969| | // Pose 970| 208| count = 0; 971| 3.78k| for (size_t i = 0; i < mScene->mNumMeshes; ++i) { ------------------ | Branch (971:24): [True: 3.57k, False: 208] ------------------ 972| 3.57k| aiMesh* mesh = mScene->mMeshes[i]; 973| 3.57k| if (mesh->HasBones()) { ++count; } ------------------ | Branch (973:13): [True: 27, False: 3.54k] ------------------ 974| 3.57k| } 975| 208| if (count) { ------------------ | Branch (975:9): [True: 19, False: 189] ------------------ 976| 19| n = FBX::Node("ObjectType", "Pose"); 977| 19| n.AddChild("Count", count); 978| 19| object_nodes.push_back(n); 979| 19| total_count += count; 980| 19| } 981| | 982| | // Deformer 983| 208| count = int32_t(count_deformers(mScene))+bsDeformerCount; 984| 208| if (count) { ------------------ | Branch (984:9): [True: 19, False: 189] ------------------ 985| 19| n = FBX::Node("ObjectType", "Deformer"); 986| 19| n.AddChild("Count", count); 987| 19| object_nodes.push_back(n); 988| 19| total_count += count; 989| 19| } 990| | 991| | // (template) 992| 208| count = 0; 993| 208| if (count) { ------------------ | Branch (993:9): [True: 0, False: 208] ------------------ 994| 0| n = FBX::Node("ObjectType", ""); 995| 0| n.AddChild("Count", count); 996| 0| pt = FBX::Node("PropertyTemplate", ""); 997| 0| p = FBX::Node("Properties70"); 998| 0| pt.AddChild(p); 999| 0| n.AddChild(pt); 1000| 0| object_nodes.push_back(n); 1001| 0| total_count += count; 1002| 0| } 1003| | 1004| | // now write it all 1005| 208| FBX::Node defs("Definitions"); 1006| 208| defs.AddChild("Version", int32_t(100)); 1007| 208| defs.AddChild("Count", int32_t(total_count)); 1008| 1.21k| for (auto &on : object_nodes) { ------------------ | Branch (1008:19): [True: 1.21k, False: 208] ------------------ 1009| 1.21k| defs.AddChild(on); 1010| 1.21k| } 1011| 208| defs.Dump(outfile, binary, 0); 1012| 208|} _Z19get_world_transformPK6aiNodePK7aiScene: 1032| 4.32k|aiMatrix4x4 get_world_transform(const aiNode* node, const aiScene* scene) { 1033| 4.32k| std::vector node_chain; 1034| 19.2k| while (node != scene->mRootNode && node != nullptr) { ------------------ | Branch (1034:12): [True: 14.9k, False: 4.32k] | Branch (1034:40): [True: 14.9k, False: 0] ------------------ 1035| 14.9k| node_chain.push_back(node); 1036| 14.9k| node = node->mParent; 1037| 14.9k| } 1038| 4.32k| aiMatrix4x4 transform; 1039| 19.2k| for (auto n = node_chain.rbegin(); n != node_chain.rend(); ++n) { ------------------ | Branch (1039:40): [True: 14.9k, False: 4.32k] ------------------ 1040| 14.9k| transform *= (*n)->mTransformation; 1041| 14.9k| } 1042| 4.32k| return transform; 1043| 4.32k|} _ZN6Assimp11FBXExporter12WriteObjectsEv: 1086| 208|void FBXExporter::WriteObjects () { 1087| 208| if (!binary) { ------------------ | Branch (1087:9): [True: 0, False: 208] ------------------ 1088| 0| WriteAsciiSectionHeader("Object properties"); 1089| 0| } 1090| | // numbers should match those given in definitions! make sure to check 1091| 208| StreamWriterLE outstream(outfile); 1092| 208| FBX::Node object_node("Objects"); 1093| 208| int indent = 0; 1094| 208| object_node.Begin(outstream, binary, indent); 1095| 208| object_node.EndProperties(outstream, binary, indent); 1096| 208| object_node.BeginChildren(outstream, binary, indent); 1097| | 1098| 208| bool bJoinIdenticalVertices = mProperties->GetPropertyBool("bJoinIdenticalVertices", true); 1099| | // save vertex_indices as it is needed later 1100| 208| std::vector> vVertexIndice(mScene->mNumMeshes); 1101| 208| std::vector uniq_v_before_mi; 1102| | 1103| 208| const auto bTransparencyFactorReferencedToOpacity = mProperties->GetPropertyBool(AI_CONFIG_EXPORT_FBX_TRANSPARENCY_FACTOR_REFER_TO_OPACITY, false); 1104| | 1105| | // geometry (aiMesh) 1106| 208| mesh_uids.clear(); 1107| 208| indent = 1; 1108| 208| std::function visit_node_geo = [&](const aiNode *node) { 1109| 208| if (node->mNumMeshes == 0) { 1110| 208| for (uint32_t ni = 0; ni < node->mNumChildren; ni++) { 1111| 208| visit_node_geo(node->mChildren[ni]); 1112| 208| } 1113| 208| return; 1114| 208| } 1115| | 1116| | // start the node record 1117| 208| FBX::Node n("Geometry"); 1118| 208| int64_t uid = generate_uid(); 1119| 208| mesh_uids[node] = uid; 1120| 208| n.AddProperty(uid); 1121| 208| n.AddProperty(FBX::SEPARATOR + "Geometry"); 1122| 208| n.AddProperty("Mesh"); 1123| 208| n.Begin(outstream, binary, indent); 1124| 208| n.DumpProperties(outstream, binary, indent); 1125| 208| n.EndProperties(outstream, binary, indent); 1126| 208| n.BeginChildren(outstream, binary, indent); 1127| | 1128| | // output vertex data - each vertex should be unique (probably) 1129| 208| std::vector flattened_vertices; 1130| | // index of original vertex in vertex data vector 1131| 208| std::vector vertex_indices; 1132| | 1133| 208| std::vector normal_data; 1134| 208| std::vector color_data; 1135| | 1136| 208| std::vector polygon_data; 1137| | 1138| 208| std::vector> uv_data; 1139| 208| std::vector> uv_indices; 1140| | 1141| 208| indent = 2; 1142| | 1143| 208| for (uint32_t n_mi = 0; n_mi < node->mNumMeshes; n_mi++) { 1144| 208| const auto mi = node->mMeshes[n_mi]; 1145| 208| const aiMesh *m = mScene->mMeshes[mi]; 1146| | 1147| 208| size_t v_offset = vertex_indices.size(); 1148| 208| size_t uniq_v_before = flattened_vertices.size() / 3; 1149| | 1150| | // map of vertex value to its index in the data vector 1151| 208| std::map index_by_vertex_value; 1152| 208| if (bJoinIdenticalVertices) { 1153| 208| int32_t index = 0; 1154| 208| for (size_t vi = 0; vi < m->mNumVertices; ++vi) { 1155| 208| aiVector3D vtx = m->mVertices[vi]; 1156| 208| auto elem = index_by_vertex_value.find(vtx); 1157| 208| if (elem == index_by_vertex_value.end()) { 1158| 208| vertex_indices.push_back(index); 1159| 208| index_by_vertex_value[vtx] = index; 1160| 208| flattened_vertices.insert(flattened_vertices.end(), { vtx.x, vtx.y, vtx.z }); 1161| 208| ++index; 1162| 208| } else { 1163| 208| vertex_indices.push_back(int32_t(elem->second)); 1164| 208| } 1165| 208| } 1166| 208| } else { // do not join vertex, respect the export flag 1167| 208| vertex_indices.resize(v_offset + m->mNumVertices); 1168| 208| std::iota(vertex_indices.begin() + v_offset, vertex_indices.end(), 0); 1169| 208| for(unsigned int v = 0; v < m->mNumVertices; ++ v) { 1170| 208| aiVector3D vtx = m->mVertices[v]; 1171| 208| flattened_vertices.insert(flattened_vertices.end(), {vtx.x, vtx.y, vtx.z}); 1172| 208| } 1173| 208| } 1174| 208| vVertexIndice[mi].insert( 1175| | // TODO test whether this can be end or not 1176| 208| vVertexIndice[mi].end(), 1177| 208| vertex_indices.begin() + v_offset, 1178| 208| vertex_indices.end() 1179| 208| ); 1180| | 1181| | // here could be edges but they're insane. 1182| | // it's optional anyway, so let's ignore it. 1183| | 1184| | // output polygon data as a flattened array of vertex indices. 1185| | // the last vertex index of each polygon is negated and - 1 1186| 208| for (size_t fi = 0; fi < m->mNumFaces; fi++) { 1187| 208| const aiFace &f = m->mFaces[fi]; 1188| 208| if (f.mNumIndices == 0) continue; 1189| 208| size_t pvi = 0; 1190| 208| for (; pvi < f.mNumIndices - 1; pvi++) { 1191| 208| polygon_data.push_back( 1192| 208| static_cast(uniq_v_before + vertex_indices[v_offset + f.mIndices[pvi]]) 1193| 208| ); 1194| 208| } 1195| 208| polygon_data.push_back( 1196| 208| static_cast(-1 ^ (uniq_v_before + vertex_indices[v_offset+f.mIndices[pvi]])) 1197| 208| ); 1198| 208| } 1199| | 1200| 208| uniq_v_before_mi.push_back(static_cast(uniq_v_before)); 1201| | 1202| 208| if (m->HasNormals()) { 1203| 208| normal_data.reserve(3 * polygon_data.size()); 1204| 208| for (size_t fi = 0; fi < m->mNumFaces; fi++) { 1205| 208| const aiFace & f = m->mFaces[fi]; 1206| 208| for (size_t pvi = 0; pvi < f.mNumIndices; pvi++) { 1207| 208| const aiVector3D &curN = m->mNormals[f.mIndices[pvi]]; 1208| 208| normal_data.insert(normal_data.end(), { curN.x, curN.y, curN.z }); 1209| 208| } 1210| 208| } 1211| 208| } 1212| | 1213| 208| const int32_t colorChannelIndex = 0; 1214| 208| if (m->HasVertexColors(colorChannelIndex)) { 1215| 208| color_data.reserve(4 * polygon_data.size()); 1216| 208| for (size_t fi = 0; fi < m->mNumFaces; fi++) { 1217| 208| const aiFace &f = m->mFaces[fi]; 1218| 208| for (size_t pvi = 0; pvi < f.mNumIndices; pvi++) { 1219| 208| const aiColor4D &c = m->mColors[colorChannelIndex][f.mIndices[pvi]]; 1220| 208| color_data.insert(color_data.end(), { c.r, c.g, c.b, c.a }); 1221| 208| } 1222| 208| } 1223| 208| } 1224| | 1225| 208| const auto num_uv = static_cast(m->GetNumUVChannels()); 1226| 208| uv_indices.resize(std::max(num_uv, uv_indices.size())); 1227| 208| uv_data.resize(std::max(num_uv, uv_data.size())); 1228| 208| std::map index_by_uv; 1229| | 1230| | // uvs, if any 1231| 208| for (size_t uvi = 0; uvi < m->GetNumUVChannels(); uvi++) { 1232| 208| const auto nc = m->mNumUVComponents[uvi]; 1233| 208| if (nc > 2) { 1234| | // FBX only supports 2-channel UV maps... 1235| | // or at least i'm not sure how to indicate a different number 1236| 208| std::stringstream err; 1237| 208| err << "Only 2-channel UV maps supported by FBX,"; 1238| 208| err << " but mesh " << mi; 1239| 208| if (m->mName.length) { 1240| 208| err << " (" << m->mName.C_Str() << ")"; 1241| 208| } 1242| 208| err << " UV map " << uvi; 1243| 208| err << " has " << m->mNumUVComponents[uvi]; 1244| 208| err << " components! Data will be preserved,"; 1245| 208| err << " but may be incorrectly interpreted on load."; 1246| 208| ASSIMP_LOG_WARN(err.str()); 1247| 208| } 1248| | 1249| 208| int32_t index = static_cast(uv_data[uvi].size()) / nc; 1250| 208| for (size_t fi = 0; fi < m->mNumFaces; fi++) { 1251| 208| const aiFace &f = m->mFaces[fi]; 1252| 208| for (size_t pvi = 0; pvi < f.mNumIndices; pvi++) { 1253| 208| const aiVector3D &curUv = m->mTextureCoords[uvi][f.mIndices[pvi]]; 1254| 208| auto elem = index_by_uv.find(curUv); 1255| 208| if (elem == index_by_uv.end()) { 1256| 208| index_by_uv[curUv] = index; 1257| 208| uv_indices[uvi].push_back(index); 1258| 208| for (uint32_t x = 0; x < nc; ++x) { 1259| 208| uv_data[uvi].push_back(curUv[x]); 1260| 208| } 1261| 208| ++index; 1262| 208| } else { 1263| 208| uv_indices[uvi].push_back(elem->second); 1264| 208| } 1265| 208| } 1266| 208| } 1267| 208| } 1268| 208| } 1269| | 1270| | 1271| 208| FBX::Node::WritePropertyNode("Vertices", flattened_vertices, outstream, binary, indent); 1272| 208| FBX::Node::WritePropertyNode("PolygonVertexIndex", polygon_data, outstream, binary, indent); 1273| 208| FBX::Node::WritePropertyNode("GeometryVersion", int32_t(124), outstream, binary, indent); 1274| | 1275| 208| if (!normal_data.empty()) { 1276| 208| FBX::Node normals("LayerElementNormal", int32_t(0)); 1277| 208| normals.Begin(outstream, binary, indent); 1278| 208| normals.DumpProperties(outstream, binary, indent); 1279| 208| normals.EndProperties(outstream, binary, indent); 1280| 208| normals.BeginChildren(outstream, binary, indent); 1281| 208| indent = 3; 1282| 208| FBX::Node::WritePropertyNode("Version", int32_t(101), outstream, binary, indent); 1283| 208| FBX::Node::WritePropertyNode("Name", "", outstream, binary, indent); 1284| 208| FBX::Node::WritePropertyNode("MappingInformationType", "ByPolygonVertex", outstream, binary, indent); 1285| 208| FBX::Node::WritePropertyNode("ReferenceInformationType", "Direct", outstream, binary, indent); 1286| 208| FBX::Node::WritePropertyNode("Normals", normal_data, outstream, binary, indent); 1287| | // note: version 102 has a NormalsW also... not sure what it is, 1288| | // so stick with version 101 for now. 1289| 208| indent = 2; 1290| 208| normals.End(outstream, binary, indent, true); 1291| 208| } 1292| | 1293| 208| if (!color_data.empty()) { 1294| 208| const auto colorChannelIndex = 0; 1295| 208| FBX::Node vertexcolors("LayerElementColor", int32_t(colorChannelIndex)); 1296| 208| vertexcolors.Begin(outstream, binary, indent); 1297| 208| vertexcolors.DumpProperties(outstream, binary, indent); 1298| 208| vertexcolors.EndProperties(outstream, binary, indent); 1299| 208| vertexcolors.BeginChildren(outstream, binary, indent); 1300| 208| indent = 3; 1301| 208| FBX::Node::WritePropertyNode("Version", int32_t(101), outstream, binary, indent); 1302| 208| char layerName[8]; 1303| 208| snprintf(layerName, sizeof(layerName), "COLOR_%d", colorChannelIndex); 1304| 208| FBX::Node::WritePropertyNode("Name", (const char *)layerName, outstream, binary, indent); 1305| 208| FBX::Node::WritePropertyNode("MappingInformationType", "ByPolygonVertex", outstream, binary, indent); 1306| 208| FBX::Node::WritePropertyNode("ReferenceInformationType", "Direct", outstream, binary, indent); 1307| 208| FBX::Node::WritePropertyNode("Colors", color_data, outstream, binary, indent); 1308| 208| indent = 2; 1309| 208| vertexcolors.End(outstream, binary, indent, true); 1310| 208| } 1311| | 1312| 208| for (uint32_t uvi = 0; uvi < uv_data.size(); uvi++) { 1313| 208| FBX::Node uv("LayerElementUV", int32_t(uvi)); 1314| 208| uv.Begin(outstream, binary, indent); 1315| 208| uv.DumpProperties(outstream, binary, indent); 1316| 208| uv.EndProperties(outstream, binary, indent); 1317| 208| uv.BeginChildren(outstream, binary, indent); 1318| 208| indent = 3; 1319| 208| FBX::Node::WritePropertyNode("Version", int32_t(101), outstream, binary, indent); 1320| 208| FBX::Node::WritePropertyNode("Name", "", outstream, binary, indent); 1321| 208| FBX::Node::WritePropertyNode("MappingInformationType", "ByPolygonVertex", outstream, binary, indent); 1322| 208| FBX::Node::WritePropertyNode("ReferenceInformationType", "IndexToDirect", outstream, binary, indent); 1323| 208| FBX::Node::WritePropertyNode("UV", uv_data[uvi], outstream, binary, indent); 1324| 208| FBX::Node::WritePropertyNode("UVIndex", uv_indices[uvi], outstream, binary, indent); 1325| 208| indent = 2; 1326| 208| uv.End(outstream, binary, indent, true); 1327| 208| } 1328| | 1329| | 1330| | // When merging multiple meshes, we instead use by polygon so the correct material is 1331| | // assigned to each face. Previously, this LayerElementMaterial always had 0 since it 1332| | // assumed there was 1 material for each node for all meshes. 1333| 208| FBX::Node mat("LayerElementMaterial", int32_t(0)); 1334| 208| mat.AddChild("Version", int32_t(101)); 1335| 208| mat.AddChild("Name", ""); 1336| 208| if (node->mNumMeshes == 1) { 1337| 208| mat.AddChild("MappingInformationType", "AllSame"); 1338| 208| mat.AddChild("ReferenceInformationType", "IndexToDirect"); 1339| 208| std::vector mat_indices = {0}; 1340| 208| mat.AddChild("Materials", mat_indices); 1341| 208| } else { 1342| 208| mat.AddChild("MappingInformationType", "ByPolygon"); 1343| 208| mat.AddChild("ReferenceInformationType", "IndexToDirect"); 1344| 208| std::vector mat_indices; 1345| 208| for (uint32_t n_mi = 0; n_mi < node->mNumMeshes; n_mi++) { 1346| 208| const auto mi = node->mMeshes[n_mi]; 1347| 208| const auto *const m = mScene->mMeshes[mi]; 1348| 208| for (size_t fi = 0; fi < m->mNumFaces; fi++) { 1349| 208| mat_indices.push_back(n_mi); 1350| 208| } 1351| 208| } 1352| 208| mat.AddChild("Materials", mat_indices); 1353| 208| } 1354| 208| mat.Dump(outstream, binary, indent); 1355| | 1356| | // finally we have the layer specifications, 1357| | // which select the normals / UV set / etc to use. 1358| | // TODO: handle multiple uv sets correctly? 1359| 208| FBX::Node layer("Layer", int32_t(0)); 1360| 208| layer.AddChild("Version", int32_t(100)); 1361| 208| FBX::Node le; 1362| | 1363| 208| if (!normal_data.empty()) { 1364| 208| le = FBX::Node("LayerElement"); 1365| 208| le.AddChild("Type", "LayerElementNormal"); 1366| 208| le.AddChild("TypedIndex", int32_t(0)); 1367| 208| layer.AddChild(le); 1368| 208| } 1369| | 1370| 208| if (!color_data.empty()) { 1371| 208| le = FBX::Node("LayerElement"); 1372| 208| le.AddChild("Type", "LayerElementColor"); 1373| 208| le.AddChild("TypedIndex", int32_t(0)); 1374| 208| layer.AddChild(le); 1375| 208| } 1376| | 1377| 208| le = FBX::Node("LayerElement"); 1378| 208| le.AddChild("Type", "LayerElementMaterial"); 1379| 208| le.AddChild("TypedIndex", int32_t(0)); 1380| 208| layer.AddChild(le); 1381| 208| le = FBX::Node("LayerElement"); 1382| 208| le.AddChild("Type", "LayerElementUV"); 1383| 208| le.AddChild("TypedIndex", int32_t(0)); 1384| 208| layer.AddChild(le); 1385| 208| layer.Dump(outstream, binary, indent); 1386| | 1387| 208| for(unsigned int lr = 1; lr < uv_data.size(); ++ lr) { 1388| 208| FBX::Node layerExtra("Layer", int32_t(lr)); 1389| 208| layerExtra.AddChild("Version", int32_t(100)); 1390| 208| FBX::Node leExtra("LayerElement"); 1391| 208| leExtra.AddChild("Type", "LayerElementUV"); 1392| 208| leExtra.AddChild("TypedIndex", int32_t(lr)); 1393| 208| layerExtra.AddChild(leExtra); 1394| 208| layerExtra.Dump(outstream, binary, indent); 1395| 208| } 1396| | // finish the node record 1397| 208| indent = 1; 1398| 208| n.End(outstream, binary, indent, true); 1399| | 1400| 208| for (uint32_t ni = 0; ni < node->mNumChildren; ni++) { 1401| 208| visit_node_geo(node->mChildren[ni]); 1402| 208| } 1403| 208| return; 1404| 208| }; 1405| | 1406| 208| visit_node_geo(mScene->mRootNode); 1407| | 1408| | 1409| | // aiMaterial 1410| 208| material_uids.clear(); 1411| 454| for (size_t i = 0; i < mScene->mNumMaterials; ++i) { ------------------ | Branch (1411:24): [True: 246, False: 208] ------------------ 1412| | // it's all about this material 1413| 246| aiMaterial* m = mScene->mMaterials[i]; 1414| | 1415| | // these are used to receive material data 1416| 246| ai_real f; aiColor3D c; 1417| | 1418| | // start the node record 1419| 246| FBX::Node n("Material"); 1420| | 1421| 246| int64_t uid = generate_uid(); 1422| 246| material_uids.push_back(uid); 1423| 246| n.AddProperty(uid); 1424| | 1425| 246| aiString name; 1426| 246| m->Get(AI_MATKEY_NAME, name); 1427| 246| n.AddProperty(name.C_Str() + FBX::SEPARATOR + "Material"); 1428| | 1429| 246| n.AddProperty(""); 1430| | 1431| 246| n.AddChild("Version", int32_t(102)); 1432| 246| f = 0; 1433| 246| m->Get(AI_MATKEY_SHININESS, f); 1434| 246| bool phong = (f > 0); 1435| 246| if (phong) { ------------------ | Branch (1435:13): [True: 92, False: 154] ------------------ 1436| 92| n.AddChild("ShadingModel", "phong"); 1437| 154| } else { 1438| 154| n.AddChild("ShadingModel", "lambert"); 1439| 154| } 1440| 246| n.AddChild("MultiLayer", int32_t(0)); 1441| | 1442| 246| FBX::Node p("Properties70"); 1443| | 1444| | // materials exported using the FBX SDK have two sets of fields. 1445| | // there are the properties specified in the PropertyTemplate, 1446| | // which are those supported by the modernFBX SDK, 1447| | // and an extra set of properties with simpler names. 1448| | // The extra properties are a legacy material system from pre-2009. 1449| | // 1450| | // In the modern system, each property has "color" and "factor". 1451| | // Generally the interpretation of these seems to be 1452| | // that the colour is multiplied by the factor before use, 1453| | // but this is not always clear-cut. 1454| | // 1455| | // Usually assimp only stores the colour, 1456| | // so we can just leave the factors at the default "1.0". 1457| | 1458| | // first we can export the "standard" properties 1459| 246| if (m->Get(AI_MATKEY_COLOR_AMBIENT, c) == aiReturn_SUCCESS) { ------------------ | Branch (1459:13): [True: 204, False: 42] ------------------ 1460| 204| p.AddP70colorA("AmbientColor", c.r, c.g, c.b); 1461| | //p.AddP70numberA("AmbientFactor", 1.0); 1462| 204| } 1463| 246| if (m->Get(AI_MATKEY_COLOR_DIFFUSE, c) == aiReturn_SUCCESS) { ------------------ | Branch (1463:13): [True: 232, False: 14] ------------------ 1464| 232| p.AddP70colorA("DiffuseColor", c.r, c.g, c.b); 1465| | //p.AddP70numberA("DiffuseFactor", 1.0); 1466| 232| } 1467| 246| if (m->Get(AI_MATKEY_COLOR_TRANSPARENT, c) == aiReturn_SUCCESS) { ------------------ | Branch (1467:13): [True: 54, False: 192] ------------------ 1468| | // "TransparentColor" / "TransparencyFactor"... 1469| | // thanks FBX, for your insightful interpretation of consistency 1470| 54| p.AddP70colorA("TransparentColor", c.r, c.g, c.b); 1471| | 1472| 54| if (!bTransparencyFactorReferencedToOpacity) { ------------------ | Branch (1472:17): [True: 54, False: 0] ------------------ 1473| | // TransparencyFactor defaults to 0.0, so set it to 1.0. 1474| | // note: Maya always sets this to 1.0, 1475| | // so we can't use it sensibly as "Opacity". 1476| | // In stead we rely on the legacy "Opacity" value, below. 1477| | // Blender also relies on "Opacity" not "TransparencyFactor", 1478| | // probably for a similar reason. 1479| 54| p.AddP70numberA("TransparencyFactor", 1.0); 1480| 54| } 1481| 54| } 1482| 246| if (bTransparencyFactorReferencedToOpacity) { ------------------ | Branch (1482:13): [True: 0, False: 246] ------------------ 1483| 0| if (m->Get(AI_MATKEY_OPACITY, f) == aiReturn_SUCCESS) { ------------------ | Branch (1483:17): [True: 0, False: 0] ------------------ 1484| 0| p.AddP70numberA("TransparencyFactor", 1.0 - f); 1485| 0| } 1486| 0| } 1487| 246| if (m->Get(AI_MATKEY_COLOR_REFLECTIVE, c) == aiReturn_SUCCESS) { ------------------ | Branch (1487:13): [True: 54, False: 192] ------------------ 1488| 54| p.AddP70colorA("ReflectionColor", c.r, c.g, c.b); 1489| 54| } 1490| 246| if (m->Get(AI_MATKEY_REFLECTIVITY, f) == aiReturn_SUCCESS) { ------------------ | Branch (1490:13): [True: 24, False: 222] ------------------ 1491| 24| p.AddP70numberA("ReflectionFactor", f); 1492| 24| } 1493| 246| if (phong) { ------------------ | Branch (1493:13): [True: 92, False: 154] ------------------ 1494| 92| if (m->Get(AI_MATKEY_COLOR_SPECULAR, c) == aiReturn_SUCCESS) { ------------------ | Branch (1494:17): [True: 92, False: 0] ------------------ 1495| 92| p.AddP70colorA("SpecularColor", c.r, c.g, c.b); 1496| 92| } 1497| 92| if (m->Get(AI_MATKEY_SHININESS_STRENGTH, f) == aiReturn_SUCCESS) { ------------------ | Branch (1497:17): [True: 7, False: 85] ------------------ 1498| 7| p.AddP70numberA("ShininessFactor", f); 1499| 7| } 1500| 92| if (m->Get(AI_MATKEY_SHININESS, f) == aiReturn_SUCCESS) { ------------------ | Branch (1500:17): [True: 92, False: 0] ------------------ 1501| 92| p.AddP70numberA("ShininessExponent", f); 1502| 92| } 1503| 92| if (m->Get(AI_MATKEY_REFLECTIVITY, f) == aiReturn_SUCCESS) { ------------------ | Branch (1503:17): [True: 24, False: 68] ------------------ 1504| 24| p.AddP70numberA("ReflectionFactor", f); 1505| 24| } 1506| 92| } 1507| | 1508| | // Now the legacy system. 1509| | // For safety let's include it. 1510| | // thrse values don't exist in the property template, 1511| | // and usually are completely ignored when loading. 1512| | // One notable exception is the "Opacity" property, 1513| | // which Blender uses as (1.0 - alpha). 1514| 246| c.r = 0.0f; c.g = 0.0f; c.b = 0.0f; 1515| 246| m->Get(AI_MATKEY_COLOR_EMISSIVE, c); 1516| 246| p.AddP70vector("Emissive", c.r, c.g, c.b); 1517| 246| c.r = 0.2f; c.g = 0.2f; c.b = 0.2f; 1518| 246| m->Get(AI_MATKEY_COLOR_AMBIENT, c); 1519| 246| p.AddP70vector("Ambient", c.r, c.g, c.b); 1520| 246| c.r = 0.8f; c.g = 0.8f; c.b = 0.8f; 1521| 246| m->Get(AI_MATKEY_COLOR_DIFFUSE, c); 1522| 246| p.AddP70vector("Diffuse", c.r, c.g, c.b); 1523| | // The FBX SDK determines "Opacity" from transparency colour (RGB) 1524| | // and factor (F) as: O = (1.0 - F * ((R + G + B) / 3)). 1525| | // However we actually have an opacity value, 1526| | // so we should take it from AI_MATKEY_OPACITY if possible. 1527| | // It might make more sense to use TransparencyFactor, 1528| | // but Blender actually loads "Opacity" correctly, so let's use it. 1529| 246| f = 1.0f; 1530| 246| if (m->Get(AI_MATKEY_COLOR_TRANSPARENT, c) == aiReturn_SUCCESS) { ------------------ | Branch (1530:13): [True: 54, False: 192] ------------------ 1531| 54| f = 1.0f - ((c.r + c.g + c.b) / 3.0f); 1532| 54| } 1533| 246| m->Get(AI_MATKEY_OPACITY, f); 1534| 246| p.AddP70double("Opacity", f); 1535| 246| if (phong) { ------------------ | Branch (1535:13): [True: 92, False: 154] ------------------ 1536| | // specular color is multiplied by shininess_strength 1537| 92| c.r = 0.2f; c.g = 0.2f; c.b = 0.2f; 1538| 92| m->Get(AI_MATKEY_COLOR_SPECULAR, c); 1539| 92| f = 1.0f; 1540| 92| m->Get(AI_MATKEY_SHININESS_STRENGTH, f); 1541| 92| p.AddP70vector("Specular", f*c.r, f*c.g, f*c.b); 1542| 92| f = 20.0f; 1543| 92| m->Get(AI_MATKEY_SHININESS, f); 1544| 92| p.AddP70double("Shininess", f); 1545| | // Legacy "Reflectivity" is F*F*((R+G+B)/3), 1546| | // where F is the proportion of light reflected (AKA reflectivity), 1547| | // and RGB is the reflective colour of the material. 1548| | // No idea why, but we might as well set it the same way. 1549| 92| f = 0.0f; 1550| 92| m->Get(AI_MATKEY_REFLECTIVITY, f); 1551| 92| c.r = 1.0f, c.g = 1.0f, c.b = 1.0f; 1552| 92| m->Get(AI_MATKEY_COLOR_REFLECTIVE, c); 1553| 92| p.AddP70double("Reflectivity", f*f*((c.r+c.g+c.b)/3.0)); 1554| 92| } 1555| | 1556| 246| n.AddChild(p); 1557| | 1558| 246| n.Dump(outstream, binary, indent); 1559| 246| } 1560| | 1561| | // we need to look up all the images we're using, 1562| | // so we can generate uids, and eliminate duplicates. 1563| 208| std::map uid_by_image; 1564| 454| for (size_t i = 0; i < mScene->mNumMaterials; ++i) { ------------------ | Branch (1564:24): [True: 246, False: 208] ------------------ 1565| 246| aiString texpath; 1566| 246| aiMaterial* mat = mScene->mMaterials[i]; 1567| 246| for ( 1568| 246| size_t tt = aiTextureType_DIFFUSE; 1569| 4.42k| tt < aiTextureType_UNKNOWN; ------------------ | Branch (1569:13): [True: 4.18k, False: 246] ------------------ 1570| 4.18k| ++tt 1571| 4.18k| ){ 1572| 4.18k| const aiTextureType textype = static_cast(tt); 1573| 4.18k| const size_t texcount = mat->GetTextureCount(textype); 1574| 4.29k| for (size_t j = 0; j < texcount; ++j) { ------------------ | Branch (1574:32): [True: 116, False: 4.18k] ------------------ 1575| 116| mat->GetTexture(textype, (unsigned int)j, &texpath); 1576| 116| const std::string texstring = texpath.C_Str(); 1577| 116| auto elem = uid_by_image.find(texstring); 1578| 116| if (elem == uid_by_image.end()) { ------------------ | Branch (1578:21): [True: 92, False: 24] ------------------ 1579| 92| uid_by_image[texstring] = generate_uid(); 1580| 92| } 1581| 116| } 1582| 4.18k| } 1583| 246| } 1584| | 1585| 208| std::map tpath_by_image; 1586| | // FbxVideo - stores images used by textures. 1587| 208| for (const auto &it : uid_by_image) { ------------------ | Branch (1587:25): [True: 92, False: 208] ------------------ 1588| 92| FBX::Node n("Video"); 1589| 92| const int64_t& uid = it.second; 1590| 92| const std::string name = ""; // TODO: ... name??? 1591| 92| n.AddProperties(uid, name + FBX::SEPARATOR + "Video", "Clip"); 1592| 92| n.AddChild("Type", "Clip"); 1593| 92| FBX::Node p("Properties70"); 1594| | // TODO: get full path... relative path... etc... ugh... 1595| | // for now just use the same path for everything, 1596| | // and hopefully one of them will work out. 1597| 92| std::string path = it.first; 1598| | // try get embedded texture 1599| 92| const aiTexture* embedded_texture = mScene->GetEmbeddedTexture(it.first.c_str()); 1600| 92| if (embedded_texture != nullptr) { ------------------ | Branch (1600:13): [True: 7, False: 85] ------------------ 1601| | // change the path (use original filename, if available. If name is empty, concatenate texture index with file extension) 1602| 7| std::stringstream newPath; 1603| 7| if (embedded_texture->mFilename.length > 0) { ------------------ | Branch (1603:17): [True: 6, False: 1] ------------------ 1604| 6| newPath << embedded_texture->mFilename.C_Str(); 1605| | // If newPath doesn't end in an extension, add extension from embedded_texture->achFormatHint 1606| 6| std::string np = newPath.str(); 1607| 6| size_t dot_pos = np.find_last_of('.'); 1608| 6| if (dot_pos == std::string::npos || dot_pos < np.find_last_of("/\\")) { ------------------ | Branch (1608:21): [True: 1, False: 5] | Branch (1608:53): [True: 3, False: 2] ------------------ 1609| | // No extension found, add one 1610| 4| newPath << "." << embedded_texture->achFormatHint; 1611| 4| } 1612| 6| } else if (embedded_texture->achFormatHint[0]) { ------------------ | Branch (1612:24): [True: 1, False: 0] ------------------ 1613| 1| int texture_index = std::stoi(path.substr(1, path.size() - 1)); 1614| 1| newPath << texture_index << "." << embedded_texture->achFormatHint; 1615| 1| } 1616| 7| auto elem = tpath_by_image.find(path); 1617| 7| if (elem == tpath_by_image.end()) { ------------------ | Branch (1617:17): [True: 7, False: 0] ------------------ 1618| 7| tpath_by_image[path] = newPath.str(); 1619| 7| } 1620| 7| path = newPath.str(); 1621| | // embed the texture 1622| 7| size_t texture_size = static_cast(embedded_texture->mWidth * std::max(embedded_texture->mHeight, 1u)); 1623| 7| if (binary) { ------------------ | Branch (1623:17): [True: 7, False: 0] ------------------ 1624| | // embed texture as binary data 1625| 7| std::vector tex_data; 1626| 7| tex_data.resize(texture_size); 1627| 7| memcpy(&tex_data[0], (char*)embedded_texture->pcData, texture_size); 1628| 7| n.AddChild("Content", tex_data); 1629| 7| } else { 1630| | // embed texture in base64 encoding 1631| 0| std::string encoded_texture = FBX::Util::EncodeBase64((char*)embedded_texture->pcData, texture_size); 1632| 0| n.AddChild("Content", encoded_texture); 1633| 0| } 1634| 7| } 1635| 92| p.AddP70("Path", "KString", "XRefUrl", "", path); 1636| 92| n.AddChild(p); 1637| 92| n.AddChild("UseMipMap", int32_t(0)); 1638| 92| n.AddChild("Filename", path); 1639| 92| n.AddChild("RelativeFilename", path); 1640| 92| n.Dump(outstream, binary, indent); 1641| 92| } 1642| | 1643| | // Textures 1644| | // referenced by material_index/texture_type pairs. 1645| 208| std::map,int64_t> texture_uids; 1646| 208| const std::map prop_name_by_tt = { 1647| 208| {aiTextureType_DIFFUSE, "DiffuseColor"}, 1648| 208| {aiTextureType_SPECULAR, "SpecularColor"}, 1649| 208| {aiTextureType_AMBIENT, "AmbientColor"}, 1650| 208| {aiTextureType_EMISSIVE, "EmissiveColor"}, 1651| 208| {aiTextureType_HEIGHT, "Bump"}, 1652| 208| {aiTextureType_NORMALS, "NormalMap"}, 1653| 208| {aiTextureType_SHININESS, "ShininessExponent"}, 1654| 208| {aiTextureType_OPACITY, "TransparentColor"}, 1655| 208| {aiTextureType_DISPLACEMENT, "DisplacementColor"}, 1656| | //{aiTextureType_LIGHTMAP, "???"}, 1657| 208| {aiTextureType_REFLECTION, "ReflectionColor"} 1658| | //{aiTextureType_UNKNOWN, ""} 1659| 208| }; 1660| 454| for (size_t i = 0; i < mScene->mNumMaterials; ++i) { ------------------ | Branch (1660:24): [True: 246, False: 208] ------------------ 1661| | // textures are attached to materials 1662| 246| aiMaterial* mat = mScene->mMaterials[i]; 1663| 246| int64_t material_uid = material_uids[i]; 1664| | 1665| 246| for ( 1666| 246| size_t j = aiTextureType_DIFFUSE; 1667| 4.42k| j < aiTextureType_UNKNOWN; ------------------ | Branch (1667:13): [True: 4.18k, False: 246] ------------------ 1668| 4.18k| ++j 1669| 4.18k| ) { 1670| 4.18k| const aiTextureType tt = static_cast(j); 1671| 4.18k| size_t n = mat->GetTextureCount(tt); 1672| | 1673| 4.18k| if (n < 1) { // no texture of this type ------------------ | Branch (1673:17): [True: 4.07k, False: 105] ------------------ 1674| 4.07k| continue; 1675| 4.07k| } 1676| | 1677| 105| if (n > 1) { ------------------ | Branch (1677:17): [True: 3, False: 102] ------------------ 1678| | // TODO: multilayer textures 1679| 3| std::stringstream err; 1680| 3| err << "Multilayer textures not supported (for now),"; 1681| 3| err << " skipping texture type " << j; 1682| 3| err << " of material " << i; 1683| 3| ASSIMP_LOG_WARN(err.str()); 1684| 3| } 1685| | 1686| | // get image path for this (single-image) texture 1687| 105| aiString tpath; 1688| 105| if (mat->GetTexture(tt, 0, &tpath) != aiReturn_SUCCESS) { ------------------ | Branch (1688:17): [True: 0, False: 105] ------------------ 1689| 0| std::stringstream err; 1690| 0| err << "Failed to get texture 0 for texture of type " << tt; 1691| 0| err << " on material " << i; 1692| 0| err << ", however GetTextureCount returned 1."; 1693| 0| throw DeadlyExportError(err.str()); 1694| 0| } 1695| 105| const std::string texture_path(tpath.C_Str()); 1696| | 1697| | // get connected image uid 1698| 105| auto elem = uid_by_image.find(texture_path); 1699| 105| if (elem == uid_by_image.end()) { ------------------ | Branch (1699:17): [True: 0, False: 105] ------------------ 1700| | // this should never happen 1701| 0| std::stringstream err; 1702| 0| err << "Failed to find video element for texture with path"; 1703| 0| err << " \"" << texture_path << "\""; 1704| 0| err << ", type " << j << ", material " << i; 1705| 0| throw DeadlyExportError(err.str()); 1706| 0| } 1707| 105| const int64_t image_uid = elem->second; 1708| | 1709| | // get the name of the material property to connect to 1710| 105| auto elem2 = prop_name_by_tt.find(tt); 1711| 105| if (elem2 == prop_name_by_tt.end()) { ------------------ | Branch (1711:17): [True: 7, False: 98] ------------------ 1712| | // don't know how to handle this type of texture, 1713| | // so skip it. 1714| 7| std::stringstream err; 1715| 7| err << "Not sure how to handle texture of type " << j; 1716| 7| err << " on material " << i; 1717| 7| err << ", skipping..."; 1718| 7| ASSIMP_LOG_WARN(err.str()); 1719| 7| continue; 1720| 7| } 1721| 98| const std::string& prop_name = elem2->second; 1722| | 1723| | // generate a uid for this texture 1724| 98| const int64_t texture_uid = generate_uid(); 1725| | 1726| | // link the texture to the material 1727| 98| connections.emplace_back( 1728| 98| "C", "OP", texture_uid, material_uid, prop_name 1729| 98| ); 1730| | 1731| | // link the image data to the texture 1732| 98| connections.emplace_back("C", "OO", image_uid, texture_uid); 1733| | 1734| 98| aiUVTransform trafo; 1735| 98| unsigned int max = sizeof(aiUVTransform); 1736| 98| aiGetMaterialFloatArray(mat, AI_MATKEY_UVTRANSFORM(aiTextureType_DIFFUSE, 0), (ai_real *)&trafo, &max); 1737| | 1738| 98| auto tp_elem = tpath_by_image.find(texture_path); 1739| 98| std::string tfile_path = texture_path; 1740| 98| if (tp_elem != tpath_by_image.end()) { ------------------ | Branch (1740:17): [True: 7, False: 91] ------------------ 1741| 7| tfile_path = tp_elem->second; 1742| 91| } else { 1743| 91| std::stringstream err; 1744| 91| err << "Texture path not found for texure " << texture_path; 1745| 91| err << " on material " << i; 1746| 91| ASSIMP_LOG_WARN(err.str()); 1747| 91| } 1748| | 1749| | // now write the actual texture node 1750| 98| FBX::Node tnode("Texture"); 1751| | // TODO: some way to determine texture name? 1752| 98| const std::string texture_name = "" + FBX::SEPARATOR + "Texture"; 1753| 98| tnode.AddProperties(texture_uid, texture_name, ""); 1754| | // there really doesn't seem to be a better type than this: 1755| 98| tnode.AddChild("Type", "TextureVideoClip"); 1756| 98| tnode.AddChild("Version", int32_t(202)); 1757| 98| tnode.AddChild("TextureName", texture_name); 1758| 98| FBX::Node p("Properties70"); 1759| 98| p.AddP70vectorA("Translation", trafo.mTranslation[0], trafo.mTranslation[1], 0.0); 1760| 98| p.AddP70vectorA("Rotation", 0, 0, trafo.mRotation); 1761| 98| p.AddP70vectorA("Scaling", trafo.mScaling[0], trafo.mScaling[1], 0.0); 1762| 98| p.AddP70enum("CurrentTextureBlendMode", 0); // TODO: verify 1763| | //p.AddP70string("UVSet", ""); // TODO: how should this work? 1764| 98| p.AddP70bool("UseMaterial", true); 1765| 98| tnode.AddChild(p); 1766| | // can't easily determine which texture path will be correct, 1767| | // so just store what we have in every field. 1768| | // these being incorrect is a common problem with FBX anyway. 1769| 98| tnode.AddChild("FileName", tfile_path); 1770| 98| tnode.AddChild("RelativeFilename", tfile_path); 1771| 98| tnode.AddChild("ModelUVTranslation", double(0.0), double(0.0)); 1772| 98| tnode.AddChild("ModelUVScaling", double(1.0), double(1.0)); 1773| 98| tnode.AddChild("Texture_Alpha_Source", "None"); 1774| 98| tnode.AddChild( 1775| 98| "Cropping", int32_t(0), int32_t(0), int32_t(0), int32_t(0) 1776| 98| ); 1777| 98| tnode.Dump(outstream, binary, indent); 1778| 98| } 1779| 246| } 1780| | 1781| | // Blendshapes, if any 1782| 3.78k| for (size_t mi = 0; mi < mScene->mNumMeshes; ++mi) { ------------------ | Branch (1782:25): [True: 3.57k, False: 208] ------------------ 1783| 3.57k| const aiMesh* m = mScene->mMeshes[mi]; 1784| 3.57k| if (m->mNumAnimMeshes == 0) { ------------------ | Branch (1784:11): [True: 3.57k, False: 0] ------------------ 1785| 3.57k| continue; 1786| 3.57k| } 1787| | // make a deformer for this mesh 1788| 0| int64_t deformer_uid = generate_uid(); 1789| 0| FBX::Node dnode("Deformer"); 1790| 0| dnode.AddProperties(deformer_uid, m->mName.data + FBX::SEPARATOR + "Blendshapes", "BlendShape"); 1791| 0| dnode.AddChild("Version", int32_t(101)); 1792| 0| dnode.Dump(outstream, binary, indent); 1793| | // connect it 1794| 0| const auto node = get_node_for_mesh((unsigned int)mi, mScene->mRootNode); 1795| 0| connections.emplace_back("C", "OO", deformer_uid, mesh_uids[node]); 1796| 0| std::vector vertex_indices = vVertexIndice[mi]; 1797| | 1798| 0| for (unsigned int am = 0; am < m->mNumAnimMeshes; ++am) { ------------------ | Branch (1798:33): [True: 0, False: 0] ------------------ 1799| 0| aiAnimMesh *pAnimMesh = m->mAnimMeshes[am]; 1800| 0| std::string blendshape_name = pAnimMesh->mName.data; 1801| | 1802| | // start the node record 1803| 0| FBX::Node bsnode("Geometry"); 1804| 0| int64_t blendshape_uid = generate_uid(); 1805| 0| blendshape_uids.push_back(blendshape_uid); 1806| 0| bsnode.AddProperty(blendshape_uid); 1807| 0| bsnode.AddProperty(blendshape_name + FBX::SEPARATOR + "Geometry"); 1808| 0| bsnode.AddProperty("Shape"); 1809| 0| bsnode.AddChild("Version", int32_t(100)); 1810| 0| bsnode.Begin(outstream, binary, indent); 1811| 0| bsnode.DumpProperties(outstream, binary, indent); 1812| 0| bsnode.EndProperties(outstream, binary, indent); 1813| 0| bsnode.BeginChildren(outstream, binary, indent); 1814| 0| indent++; 1815| 0| if (pAnimMesh->HasPositions()) { ------------------ | Branch (1815:13): [True: 0, False: 0] ------------------ 1816| 0| std::vectorshape_indices; 1817| 0| std::vectorpPositionDiff; 1818| 0| std::vectorpNormalDiff; 1819| | 1820| 0| for (unsigned int vt = 0; vt < vertex_indices.size(); ++vt) { ------------------ | Branch (1820:37): [True: 0, False: 0] ------------------ 1821| 0| aiVector3D pDiff = (pAnimMesh->mVertices[vertex_indices[vt]] - m->mVertices[vertex_indices[vt]]); 1822| 0| shape_indices.push_back(vertex_indices[vt]); 1823| 0| pPositionDiff.push_back(pDiff[0]); 1824| 0| pPositionDiff.push_back(pDiff[1]); 1825| 0| pPositionDiff.push_back(pDiff[2]); 1826| | 1827| 0| if (pAnimMesh->HasNormals()) { ------------------ | Branch (1827:19): [True: 0, False: 0] ------------------ 1828| 0| aiVector3D nDiff = (pAnimMesh->mNormals[vertex_indices[vt]] - m->mNormals[vertex_indices[vt]]); 1829| 0| pNormalDiff.push_back(nDiff[0]); 1830| 0| pNormalDiff.push_back(nDiff[1]); 1831| 0| pNormalDiff.push_back(nDiff[2]); 1832| 0| } else { 1833| 0| pNormalDiff.push_back(0.0); 1834| 0| pNormalDiff.push_back(0.0); 1835| 0| pNormalDiff.push_back(0.0); 1836| 0| } 1837| 0| } 1838| | 1839| 0| FBX::Node::WritePropertyNode( 1840| 0| "Indexes", shape_indices, outstream, binary, indent 1841| 0| ); 1842| | 1843| 0| FBX::Node::WritePropertyNode( 1844| 0| "Vertices", pPositionDiff, outstream, binary, indent 1845| 0| ); 1846| | 1847| 0| if (pNormalDiff.size()>0) { ------------------ | Branch (1847:15): [True: 0, False: 0] ------------------ 1848| 0| FBX::Node::WritePropertyNode( 1849| 0| "Normals", pNormalDiff, outstream, binary, indent 1850| 0| ); 1851| 0| } 1852| 0| } 1853| 0| indent--; 1854| 0| bsnode.End(outstream, binary, indent, true); 1855| | 1856| | // Add blendshape Channel Deformer 1857| 0| FBX::Node sdnode("Deformer"); 1858| 0| const int64_t blendchannel_uid = generate_uid(); 1859| 0| sdnode.AddProperties( 1860| 0| blendchannel_uid, blendshape_name + FBX::SEPARATOR + "SubDeformer", "BlendShapeChannel" 1861| 0| ); 1862| 0| sdnode.AddChild("Version", int32_t(100)); 1863| 0| sdnode.AddChild("DeformPercent", float(0.0)); 1864| 0| FBX::Node p("Properties70"); 1865| 0| p.AddP70numberA("DeformPercent", 0.0); 1866| 0| sdnode.AddChild(p); 1867| | // TODO: Normally just one weight per channel, adding stub for later development 1868| 0| std::vectorfFullWeights; 1869| 0| fFullWeights.push_back(100.); 1870| 0| sdnode.AddChild("FullWeights", fFullWeights); 1871| 0| sdnode.Dump(outstream, binary, indent); 1872| | 1873| 0| connections.emplace_back("C", "OO", blendchannel_uid, deformer_uid); 1874| 0| connections.emplace_back("C", "OO", blendshape_uid, blendchannel_uid); 1875| 0| } 1876| 0| } 1877| | 1878| | // bones. 1879| | // 1880| | // output structure: 1881| | // subset of node hierarchy that are "skeleton", 1882| | // i.e. do not have meshes but only bones. 1883| | // but.. i'm not sure how anyone could guarantee that... 1884| | // 1885| | // input... 1886| | // well, for each mesh it has "bones", 1887| | // and the bone names correspond to nodes. 1888| | // of course we also need the parent nodes, 1889| | // as they give some of the transform........ 1890| | // 1891| | // well. we can assume a sane input, i suppose. 1892| | // 1893| | // so input is the bone node hierarchy, 1894| | // with an extra thing for the transformation of the MESH in BONE space. 1895| | // 1896| | // output is a set of bone nodes, 1897| | // a "bindpose" which indicates the default local transform of all bones, 1898| | // and a set of "deformers". 1899| | // each deformer is parented to a mesh geometry, 1900| | // and has one or more "subdeformer"s as children. 1901| | // each subdeformer has one bone node as a child, 1902| | // and represents the influence of that bone on the grandparent mesh. 1903| | // the subdeformer has a list of indices, and weights, 1904| | // with indices specifying vertex indices, 1905| | // and weights specifying the corresponding influence of this bone. 1906| | // it also has Transform and TransformLink elements, 1907| | // specifying the transform of the MESH in BONE space, 1908| | // and the transformation of the BONE in WORLD space, 1909| | // likely in the bindpose. 1910| | // 1911| | // the input bone structure is different but similar, 1912| | // storing the number of weights for this bone, 1913| | // and an array of (vertex index, weight) pairs. 1914| | // 1915| | // one sticky point is that the number of vertices may not match, 1916| | // because assimp splits vertices by normal, uv, etc. 1917| | 1918| | 1919| | // first we should mark the skeleton for each mesh. 1920| | // the skeleton must include not only the aiBones, 1921| | // but also all their parent nodes. 1922| | // anything that affects the position of any bone node must be included. 1923| | 1924| | // note that we want to preserve input order as much as possible here. 1925| | // previously, sorting by name lead to consistent output across systems, but was not 1926| | // suitable for downstream consumption by some applications. 1927| 208| std::vector> skeleton_by_mesh(mScene->mNumMeshes); 1928| | // at the same time we can build a list of all the skeleton nodes, 1929| | // which will be used later to mark them as type "limbNode". 1930| 208| std::unordered_set limbnodes; 1931| | 1932| | //actual bone nodes in fbx, without parenting-up 1933| 208| std::vector allBoneNames; 1934| 3.78k| for(unsigned int m = 0; m < mScene->mNumMeshes; ++ m) { ------------------ | Branch (1934:29): [True: 3.57k, False: 208] ------------------ 1935| 3.57k| aiMesh* pMesh = mScene->mMeshes[m]; 1936| 6.66k| for(unsigned int b = 0; b < pMesh->mNumBones; ++ b) ------------------ | Branch (1936:33): [True: 3.08k, False: 3.57k] ------------------ 1937| 3.08k| allBoneNames.push_back(pMesh->mBones[b]->mName.data); 1938| 3.57k| } 1939| 208| aiMatrix4x4 mxTransIdentity; 1940| | 1941| | // and a map of nodes by bone name, as finding them is annoying. 1942| 208| std::map node_by_bone; 1943| 3.77k| for (size_t mi = 0; mi < mScene->mNumMeshes; ++mi) { ------------------ | Branch (1943:25): [True: 3.57k, False: 207] ------------------ 1944| 3.57k| const aiMesh* m = mScene->mMeshes[mi]; 1945| 3.57k| std::vector skeleton; 1946| 6.65k| for (size_t bi =0; bi < m->mNumBones; ++bi) { ------------------ | Branch (1946:28): [True: 3.08k, False: 3.57k] ------------------ 1947| 3.08k| const aiBone* b = m->mBones[bi]; 1948| 3.08k| const std::string name(b->mName.C_Str()); 1949| 3.08k| auto elem = node_by_bone.find(name); 1950| 3.08k| aiNode* n; 1951| 3.08k| if (elem != node_by_bone.end()) { ------------------ | Branch (1951:17): [True: 0, False: 3.08k] ------------------ 1952| 0| n = elem->second; 1953| 3.08k| } else { 1954| 3.08k| n = mScene->mRootNode->FindNode(b->mName); 1955| 3.08k| if (!n) { ------------------ | Branch (1955:21): [True: 1, False: 3.08k] ------------------ 1956| | // this should never happen 1957| 1| std::stringstream err; 1958| 1| err << "Failed to find node for bone: \"" << name << "\""; 1959| 1| throw DeadlyExportError(err.str()); 1960| 1| } 1961| 3.08k| node_by_bone[name] = n; 1962| 3.08k| limbnodes.insert(n); 1963| 3.08k| } 1964| 3.08k| skeleton.push_back(n); 1965| | // mark all parent nodes as skeleton as well, 1966| | // up until we find the root node, 1967| | // or else the node containing the mesh, 1968| | // or else the parent of a node containing the mesh. 1969| 3.08k| for ( 1970| 3.08k| const aiNode* parent = n->mParent; 1971| 6.45k| parent && parent != mScene->mRootNode; ------------------ | Branch (1971:17): [True: 6.44k, False: 6] | Branch (1971:27): [True: 3.46k, False: 2.98k] ------------------ 1972| 3.36k| parent = parent->mParent 1973| 3.46k| ) { 1974| | // if we've already done this node we can skip it all 1975| 3.46k| if (std::find(skeleton.begin(), skeleton.end(), parent) != skeleton.end()) { ------------------ | Branch (1975:21): [True: 96, False: 3.36k] ------------------ 1976| 96| break; 1977| 96| } 1978| | // ignore fbx transform nodes as these will be collapsed later 1979| | // TODO: cache this by aiNode* 1980| 3.36k| const std::string node_name(parent->mName.C_Str()); 1981| 3.36k| if (node_name.find(MAGIC_NODE_TAG) != std::string::npos) { ------------------ | Branch (1981:21): [True: 0, False: 3.36k] ------------------ 1982| 0| continue; 1983| 0| } 1984| | //not a bone in scene && no effect in transform 1985| 3.36k| if (std::find(allBoneNames.begin(), allBoneNames.end(), node_name) == allBoneNames.end() ------------------ | Branch (1985:21): [True: 2.93k, False: 430] | Branch (1985:21): [True: 2.63k, False: 727] ------------------ 1986| 2.93k| && parent->mTransformation == mxTransIdentity) { ------------------ | Branch (1986:23): [True: 2.63k, False: 297] ------------------ 1987| 2.63k| continue; 1988| 2.63k| } 1989| | // otherwise check if this is the root of the skeleton 1990| 727| bool end = false; 1991| | // is the mesh part of this node? 1992| 727| for (size_t i = 0; i < parent->mNumMeshes && !end; ++i) { ------------------ | Branch (1992:36): [True: 0, False: 727] | Branch (1992:62): [True: 0, False: 0] ------------------ 1993| 0| end |= parent->mMeshes[i] == mi; 1994| 0| } 1995| | // is the mesh in one of the children of this node? 1996| 1.87k| for (size_t j = 0; j < parent->mNumChildren && !end; ++j) { ------------------ | Branch (1996:36): [True: 1.14k, False: 727] | Branch (1996:64): [True: 1.14k, False: 0] ------------------ 1997| 1.14k| aiNode* child = parent->mChildren[j]; 1998| 1.14k| for (size_t i = 0; i < child->mNumMeshes && !end; ++i) { ------------------ | Branch (1998:40): [True: 0, False: 1.14k] | Branch (1998:65): [True: 0, False: 0] ------------------ 1999| 0| end |= child->mMeshes[i] == mi; 2000| 0| } 2001| 1.14k| } 2002| | 2003| | // if it was the skeleton root we can finish here 2004| 727| if (end) { break; } ------------------ | Branch (2004:21): [True: 0, False: 727] ------------------ 2005| 727| } 2006| 3.08k| } 2007| 3.57k| skeleton_by_mesh[mi] = skeleton; 2008| 3.57k| } 2009| | 2010| | // we'll need the uids for the bone nodes, so generate them now 2011| 3.77k| for (size_t i = 0; i < mScene->mNumMeshes; ++i) { ------------------ | Branch (2011:24): [True: 3.57k, False: 207] ------------------ 2012| 3.57k| auto &s = skeleton_by_mesh[i]; 2013| 3.57k| for (const aiNode* n : s) { ------------------ | Branch (2013:30): [True: 3.08k, False: 3.57k] ------------------ 2014| 3.08k| if (node_uids.find(n) == node_uids.end()) { ------------------ | Branch (2014:17): [True: 3.08k, False: 0] ------------------ 2015| 3.08k| node_uids[n] = generate_uid(); 2016| 3.08k| } 2017| 3.08k| } 2018| 3.57k| } 2019| | 2020| | // now, for each aiMesh, we need to export a deformer, 2021| | // and for each aiBone a subdeformer, 2022| | // which should have all the skinning info. 2023| | // these will need to be connected properly to the mesh, 2024| | // and we can do that all now. 2025| 3.77k| for (size_t mi = 0; mi < mScene->mNumMeshes; ++mi) { ------------------ | Branch (2025:25): [True: 3.57k, False: 207] ------------------ 2026| 3.57k| const aiMesh* m = mScene->mMeshes[mi]; 2027| 3.57k| if (!m->HasBones()) { ------------------ | Branch (2027:13): [True: 3.54k, False: 26] ------------------ 2028| 3.54k| continue; 2029| 3.54k| } 2030| | 2031| 26| const aiNode *mesh_node = get_node_for_mesh((uint32_t)mi, mScene->mRootNode); 2032| | // make a deformer for this mesh 2033| 26| int64_t deformer_uid = generate_uid(); 2034| 26| FBX::Node dnode("Deformer"); 2035| 26| dnode.AddProperties(deformer_uid, FBX::SEPARATOR + "Deformer", "Skin"); 2036| 26| dnode.AddChild("Version", int32_t(101)); 2037| | // "acuracy"... this is not a typo.... 2038| 26| dnode.AddChild("Link_DeformAcuracy", double(50)); 2039| 26| dnode.AddChild("SkinningType", "Linear"); // TODO: other modes? 2040| 26| dnode.Dump(outstream, binary, indent); 2041| | 2042| | // connect it 2043| 26| connections.emplace_back("C", "OO", deformer_uid, mesh_uids[mesh_node]); 2044| | 2045| | // TODO, FIXME: this won't work if anything is not in the bind pose. 2046| | // for now if such a situation is detected, we throw an exception. 2047| 26| std::set not_in_bind_pose; 2048| 26| std::set no_offset_matrix; 2049| | 2050| | // first get this mesh's position in world space, 2051| | // as we'll need it for each subdeformer. 2052| | // 2053| | // ...of course taking the position of the MESH doesn't make sense, 2054| | // as it can be instanced to many nodes. 2055| | // All we can do is assume no instancing, 2056| | // and take the first node we find that contains the mesh. 2057| 26| aiMatrix4x4 mesh_xform = get_world_transform(mesh_node, mScene); 2058| | 2059| | // now make a subdeformer for each bone in the skeleton 2060| 26| const auto & skeleton= skeleton_by_mesh[mi]; 2061| 3.08k| for (const aiNode* bone_node : skeleton) { ------------------ | Branch (2061:38): [True: 3.08k, False: 26] ------------------ 2062| | // if there's a bone for this node, find it 2063| 3.08k| const aiBone* b = nullptr; 2064| 970k| for (size_t bi = 0; bi < m->mNumBones; ++bi) { ------------------ | Branch (2064:33): [True: 970k, False: 0] ------------------ 2065| | // TODO: this probably should index by something else 2066| 970k| const std::string name(m->mBones[bi]->mName.C_Str()); 2067| 970k| if (node_by_bone[name] == bone_node) { ------------------ | Branch (2067:21): [True: 3.08k, False: 967k] ------------------ 2068| 3.08k| b = m->mBones[bi]; 2069| 3.08k| break; 2070| 3.08k| } 2071| 970k| } 2072| 3.08k| if (!b) { ------------------ | Branch (2072:17): [True: 0, False: 3.08k] ------------------ 2073| 0| no_offset_matrix.insert(bone_node); 2074| 0| } 2075| | 2076| | // start the subdeformer node 2077| 3.08k| const int64_t subdeformer_uid = generate_uid(); 2078| 3.08k| FBX::Node sdnode("Deformer"); 2079| 3.08k| sdnode.AddProperties( 2080| 3.08k| subdeformer_uid, FBX::SEPARATOR + "SubDeformer", "Cluster" 2081| 3.08k| ); 2082| 3.08k| sdnode.AddChild("Version", int32_t(100)); 2083| 3.08k| sdnode.AddChild("UserData", "", ""); 2084| | 2085| | // add indices and weights, if any 2086| 3.08k| if (b) { ------------------ | Branch (2086:17): [True: 3.08k, False: 0] ------------------ 2087| 3.08k| std::set setWeightedVertex; 2088| 3.08k| std::vector subdef_indices; 2089| 3.08k| std::vector subdef_weights; 2090| 3.08k| int32_t last_index = -1; 2091| 42.8k| for (size_t wi = 0; wi < b->mNumWeights; ++wi) { ------------------ | Branch (2091:37): [True: 39.8k, False: 3.08k] ------------------ 2092| 39.8k| if (b->mWeights[wi].mVertexId >= vVertexIndice[mi].size()) { ------------------ | Branch (2092:25): [True: 23.1k, False: 16.6k] ------------------ 2093| 23.1k| ASSIMP_LOG_ERROR("UNREAL: Skipping vertex index to prevent buffer overflow."); 2094| 23.1k| continue; 2095| 23.1k| } 2096| 16.6k| int32_t vi = vVertexIndice[mi][b->mWeights[wi].mVertexId] 2097| 16.6k| + uniq_v_before_mi[mi]; 2098| 16.6k| bool bIsWeightedAlready = (setWeightedVertex.find(vi) != setWeightedVertex.end()); 2099| 16.6k| if (vi == last_index || bIsWeightedAlready) { ------------------ | Branch (2099:25): [True: 0, False: 16.6k] | Branch (2099:45): [True: 0, False: 16.6k] ------------------ 2100| | // only for vertices we exported to fbx 2101| | // TODO, FIXME: this assumes identically-located vertices 2102| | // will always deform in the same way. 2103| | // as assimp doesn't store a separate list of "positions", 2104| | // there's not much that can be done about this 2105| | // other than assuming that identical position means 2106| | // identical vertex. 2107| 0| continue; 2108| 0| } 2109| 16.6k| setWeightedVertex.insert(vi); 2110| 16.6k| subdef_indices.push_back(vi); 2111| 16.6k| subdef_weights.push_back(b->mWeights[wi].mWeight); 2112| 16.6k| last_index = vi; 2113| 16.6k| } 2114| | // yes, "indexes" 2115| 3.08k| sdnode.AddChild("Indexes", subdef_indices); 2116| 3.08k| sdnode.AddChild("Weights", subdef_weights); 2117| 3.08k| } 2118| | 2119| | // transform is the transform of the mesh, but in bone space. 2120| | // if the skeleton is in the bind pose, 2121| | // we can take the inverse of the world-space bone transform 2122| | // and multiply by the world-space transform of the mesh. 2123| 3.08k| aiMatrix4x4 bone_xform = get_world_transform(bone_node, mScene); 2124| 3.08k| aiMatrix4x4 inverse_bone_xform = bone_xform; 2125| 3.08k| inverse_bone_xform.Inverse(); 2126| 3.08k| aiMatrix4x4 tr = inverse_bone_xform * mesh_xform; 2127| | 2128| 3.08k| sdnode.AddChild("Transform", tr); 2129| | 2130| | 2131| 3.08k| sdnode.AddChild("TransformLink", bone_xform); 2132| | // note: this means we ALWAYS rely on the mesh node transform 2133| | // being unchanged from the time the skeleton was bound. 2134| | // there's not really any way around this at the moment. 2135| | 2136| | // done 2137| 3.08k| sdnode.Dump(outstream, binary, indent); 2138| | 2139| | // lastly, connect to the parent deformer 2140| 3.08k| connections.emplace_back( 2141| 3.08k| "C", "OO", subdeformer_uid, deformer_uid 2142| 3.08k| ); 2143| | 2144| | // we also need to connect the limb node to the subdeformer. 2145| 3.08k| connections.emplace_back( 2146| 3.08k| "C", "OO", node_uids[bone_node], subdeformer_uid 2147| 3.08k| ); 2148| 3.08k| } 2149| | 2150| | // if we cannot create a valid FBX file, simply die. 2151| | // this will both prevent unnecessary bug reports, 2152| | // and tell the user what they can do to fix the situation 2153| | // (i.e. export their model in the bind pose). 2154| 26| if (no_offset_matrix.size() && not_in_bind_pose.size()) { ------------------ | Branch (2154:13): [True: 0, False: 26] | Branch (2154:40): [True: 0, False: 0] ------------------ 2155| 0| std::stringstream err; 2156| 0| err << "Not enough information to construct bind pose"; 2157| 0| err << " for mesh " << mi << "!"; 2158| 0| err << " Transform matrix for bone \""; 2159| 0| err << (*not_in_bind_pose.begin())->mName.C_Str() << "\""; 2160| 0| if (not_in_bind_pose.size() > 1) { ------------------ | Branch (2160:17): [True: 0, False: 0] ------------------ 2161| 0| err << " (and " << not_in_bind_pose.size() - 1 << " more)"; 2162| 0| } 2163| 0| err << " does not match mOffsetMatrix,"; 2164| 0| err << " and node \""; 2165| 0| err << (*no_offset_matrix.begin())->mName.C_Str() << "\""; 2166| 0| if (no_offset_matrix.size() > 1) { ------------------ | Branch (2166:17): [True: 0, False: 0] ------------------ 2167| 0| err << " (and " << no_offset_matrix.size() - 1 << " more)"; 2168| 0| } 2169| 0| err << " has no offset matrix to rely on."; 2170| 0| err << " Please ensure bones are in the bind pose to export."; 2171| 0| throw DeadlyExportError(err.str()); 2172| 0| } 2173| | 2174| 26| } 2175| | 2176| | // BindPose 2177| | // 2178| | // This is a legacy system, which should be unnecessary. 2179| | // 2180| | // Somehow including it slows file loading by the official FBX SDK, 2181| | // and as it can reconstruct it from the deformers anyway, 2182| | // this is not currently included. 2183| | // 2184| | // The code is kept here in case it's useful in the future, 2185| | // but it's pretty much a hack anyway, 2186| | // as assimp doesn't store bindpose information for full skeletons. 2187| | // 2188| | /*for (size_t mi = 0; mi < mScene->mNumMeshes; ++mi) { 2189| | aiMesh* mesh = mScene->mMeshes[mi]; 2190| | if (! mesh->HasBones()) { continue; } 2191| | int64_t bindpose_uid = generate_uid(); 2192| | FBX::Node bpnode("Pose"); 2193| | bpnode.AddProperty(bindpose_uid); 2194| | // note: this uid is never linked or connected to anything. 2195| | bpnode.AddProperty(FBX::SEPARATOR + "Pose"); // blank name 2196| | bpnode.AddProperty("BindPose"); 2197| | 2198| | bpnode.AddChild("Type", "BindPose"); 2199| | bpnode.AddChild("Version", int32_t(100)); 2200| | 2201| | aiNode* mesh_node = get_node_for_mesh(mi, mScene->mRootNode); 2202| | 2203| | // next get the whole skeleton for this mesh. 2204| | // we need it all to define the bindpose section. 2205| | // the FBX SDK will complain if it's missing, 2206| | // and also if parents of used bones don't have a subdeformer. 2207| | // order shouldn't matter. 2208| | std::set skeleton; 2209| | for (size_t bi = 0; bi < mesh->mNumBones; ++bi) { 2210| | // bone node should have already been indexed 2211| | const aiBone* b = mesh->mBones[bi]; 2212| | const std::string bone_name(b->mName.C_Str()); 2213| | aiNode* parent = node_by_bone[bone_name]; 2214| | // insert all nodes down to the root or mesh node 2215| | while ( 2216| | parent 2217| | && parent != mScene->mRootNode 2218| | && parent != mesh_node 2219| | ) { 2220| | skeleton.insert(parent); 2221| | parent = parent->mParent; 2222| | } 2223| | } 2224| | 2225| | // number of pose nodes. includes one for the mesh itself. 2226| | bpnode.AddChild("NbPoseNodes", int32_t(1 + skeleton.size())); 2227| | 2228| | // the first pose node is always the mesh itself 2229| | FBX::Node pose("PoseNode"); 2230| | pose.AddChild("Node", mesh_uids[mi]); 2231| | aiMatrix4x4 mesh_node_xform = get_world_transform(mesh_node, mScene); 2232| | pose.AddChild("Matrix", mesh_node_xform); 2233| | bpnode.AddChild(pose); 2234| | 2235| | for (aiNode* bonenode : skeleton) { 2236| | // does this node have a uid yet? 2237| | int64_t node_uid; 2238| | auto node_uid_iter = node_uids.find(bonenode); 2239| | if (node_uid_iter != node_uids.end()) { 2240| | node_uid = node_uid_iter->second; 2241| | } else { 2242| | node_uid = generate_uid(); 2243| | node_uids[bonenode] = node_uid; 2244| | } 2245| | 2246| | // make a pose thingy 2247| | pose = FBX::Node("PoseNode"); 2248| | pose.AddChild("Node", node_uid); 2249| | aiMatrix4x4 node_xform = get_world_transform(bonenode, mScene); 2250| | pose.AddChild("Matrix", node_xform); 2251| | bpnode.AddChild(pose); 2252| | } 2253| | 2254| | // now write it 2255| | bpnode.Dump(outstream, binary, indent); 2256| | }*/ 2257| | 2258| | // lights 2259| 207| indent = 1; 2260| 207| lights_uids.clear(); 2261| 264| for (size_t li = 0; li < mScene->mNumLights; ++li) { ------------------ | Branch (2261:25): [True: 57, False: 207] ------------------ 2262| 57| aiLight* l = mScene->mLights[li]; 2263| | 2264| 57| int64_t uid = generate_uid(); 2265| 57| const std::string lightNodeAttributeName = l->mName.C_Str() + FBX::SEPARATOR + "NodeAttribute"; 2266| | 2267| 57| FBX::Node lna("NodeAttribute"); 2268| 57| lna.AddProperties(uid, lightNodeAttributeName, "Light"); 2269| 57| FBX::Node lnap("Properties70"); 2270| | 2271| | // Light color. 2272| 57| lnap.AddP70colorA("Color", l->mColorDiffuse.r, l->mColorDiffuse.g, l->mColorDiffuse.b); 2273| | 2274| | // TODO Assimp light description is quite concise and do not handle light intensity. 2275| | // Default value to 1000W. 2276| 57| lnap.AddP70numberA("Intensity", 1000); 2277| | 2278| | // FBXLight::EType conversion 2279| 57| switch (l->mType) { 2280| 45| case aiLightSource_POINT: ------------------ | Branch (2280:9): [True: 45, False: 12] ------------------ 2281| 45| lnap.AddP70enum("LightType", 0); 2282| 45| break; 2283| 7| case aiLightSource_DIRECTIONAL: ------------------ | Branch (2283:9): [True: 7, False: 50] ------------------ 2284| 7| lnap.AddP70enum("LightType", 1); 2285| 7| break; 2286| 2| case aiLightSource_SPOT: ------------------ | Branch (2286:9): [True: 2, False: 55] ------------------ 2287| 2| lnap.AddP70enum("LightType", 2); 2288| 2| lnap.AddP70numberA("InnerAngle", AI_RAD_TO_DEG(l->mAngleInnerCone)); 2289| 2| lnap.AddP70numberA("OuterAngle", AI_RAD_TO_DEG(l->mAngleOuterCone)); 2290| 2| break; 2291| | // TODO Assimp do not handle 'area' nor 'volume' lights, but FBX does. 2292| | /*case aiLightSource_AREA: 2293| | lnap.AddP70enum("LightType", 3); 2294| | lnap.AddP70enum("AreaLightShape", 0); // 0=Rectangle, 1=Sphere 2295| | break; 2296| | case aiLightSource_VOLUME: 2297| | lnap.AddP70enum("LightType", 4); 2298| | break;*/ 2299| 3| default: ------------------ | Branch (2299:9): [True: 3, False: 54] ------------------ 2300| 3| break; 2301| 57| } 2302| | 2303| | // Did not understood how to configure the decay so disabling attenuation. 2304| 57| lnap.AddP70enum("DecayType", 0); 2305| | 2306| | // Dump to FBX stream 2307| 57| lna.AddChild(lnap); 2308| 57| lna.AddChild("TypeFlags", FBX::FBXExportProperty("Light")); 2309| 57| lna.AddChild("GeometryVersion", FBX::FBXExportProperty(int32_t(124))); 2310| 57| lna.Dump(outstream, binary, indent); 2311| | 2312| | // Store name and uid (will be used later when parsing scene nodes) 2313| 57| lights_uids[l->mName.C_Str()] = uid; 2314| 57| } 2315| | 2316| | // TODO: cameras 2317| | 2318| | // write nodes (i.e. model hierarchy) 2319| | // start at root node 2320| 207| WriteModelNodes( 2321| 207| outstream, mScene->mRootNode, 0, limbnodes 2322| 207| ); 2323| | 2324| | // animations 2325| | // 2326| | // in FBX there are: 2327| | // * AnimationStack - corresponds to an aiAnimation 2328| | // * AnimationLayer - a combinable animation component 2329| | // * AnimationCurveNode - links the property to be animated 2330| | // * AnimationCurve - defines animation data for a single property value 2331| | // 2332| | // the CurveNode also provides the default value for a property, 2333| | // such as the X, Y, Z coordinates for animatable translation. 2334| | // 2335| | // the Curve only specifies values for one component of the property, 2336| | // so there will be a separate AnimationCurve for X, Y, and Z. 2337| | // 2338| | // Assimp has: 2339| | // * aiAnimation - basically corresponds to an AnimationStack 2340| | // * aiNodeAnim - defines all animation for one aiNode 2341| | // * aiVectorKey/aiQuatKey - define the keyframe data for T/R/S 2342| | // 2343| | // assimp has no equivalent for AnimationLayer, 2344| | // and these are flattened on FBX import. 2345| | // we can assume there will be one per AnimationStack. 2346| | // 2347| | // the aiNodeAnim contains all animation data for a single aiNode, 2348| | // which will correspond to three AnimationCurveNode's: 2349| | // one each for translation, rotation and scale. 2350| | // The data for each of these will be put in 9 AnimationCurve's, 2351| | // T.X, T.Y, T.Z, R.X, R.Y, R.Z, etc. 2352| | 2353| | // AnimationStack / aiAnimation 2354| 207| std::vector animation_stack_uids(mScene->mNumAnimations); 2355| 235| for (size_t ai = 0; ai < mScene->mNumAnimations; ++ai) { ------------------ | Branch (2355:25): [True: 28, False: 207] ------------------ 2356| 28| int64_t animstack_uid = generate_uid(); 2357| 28| animation_stack_uids[ai] = animstack_uid; 2358| 28| const aiAnimation* anim = mScene->mAnimations[ai]; 2359| | 2360| 28| FBX::Node asnode("AnimationStack"); 2361| 28| std::string name = anim->mName.C_Str() + FBX::SEPARATOR + "AnimStack"; 2362| 28| asnode.AddProperties(animstack_uid, name, ""); 2363| 28| FBX::Node p("Properties70"); 2364| 28| p.AddP70time("LocalStart", 0); // assimp doesn't store this 2365| 28| p.AddP70time("LocalStop", to_ktime(anim->mDuration, anim)); 2366| 28| p.AddP70time("ReferenceStart", 0); 2367| 28| p.AddP70time("ReferenceStop", to_ktime(anim->mDuration, anim)); 2368| 28| asnode.AddChild(p); 2369| | 2370| | // this node absurdly always pretends it has children 2371| | // (in this case it does, but just in case...) 2372| 28| asnode.force_has_children = true; 2373| 28| asnode.Dump(outstream, binary, indent); 2374| | 2375| | // note: animation stacks are not connected to anything 2376| 28| } 2377| | 2378| | // AnimationLayer - one per aiAnimation 2379| 207| std::vector animation_layer_uids(mScene->mNumAnimations); 2380| 235| for (size_t ai = 0; ai < mScene->mNumAnimations; ++ai) { ------------------ | Branch (2380:25): [True: 28, False: 207] ------------------ 2381| 28| int64_t animlayer_uid = generate_uid(); 2382| 28| animation_layer_uids[ai] = animlayer_uid; 2383| 28| FBX::Node alnode("AnimationLayer"); 2384| 28| alnode.AddProperties(animlayer_uid, FBX::SEPARATOR + "AnimLayer", ""); 2385| | 2386| | // this node absurdly always pretends it has children 2387| 28| alnode.force_has_children = true; 2388| 28| alnode.Dump(outstream, binary, indent); 2389| | 2390| | // connect to the relevant animstack 2391| 28| connections.emplace_back( 2392| 28| "C", "OO", animlayer_uid, animation_stack_uids[ai] 2393| 28| ); 2394| 28| } 2395| | 2396| | // AnimCurveNode - three per aiNodeAnim 2397| 207| std::vector>> curve_node_uids; 2398| 235| for (size_t ai = 0; ai < mScene->mNumAnimations; ++ai) { ------------------ | Branch (2398:25): [True: 28, False: 207] ------------------ 2399| 28| const aiAnimation* anim = mScene->mAnimations[ai]; 2400| 28| const int64_t layer_uid = animation_layer_uids[ai]; 2401| 28| std::vector> nodeanim_uids; 2402| 637| for (size_t nai = 0; nai < anim->mNumChannels; ++nai) { ------------------ | Branch (2402:30): [True: 609, False: 28] ------------------ 2403| 609| const aiNodeAnim* na = anim->mChannels[nai]; 2404| | // get the corresponding aiNode 2405| 609| const aiNode* node = mScene->mRootNode->FindNode(na->mNodeName); 2406| | // and its transform 2407| 609| const aiMatrix4x4 node_xfm = get_world_transform(node, mScene); 2408| 609| aiVector3D T, R, S; 2409| 609| node_xfm.Decompose(S, R, T); 2410| | 2411| | // AnimationCurveNode uids 2412| 609| std::array ids; 2413| 609| ids[0] = generate_uid(); // T 2414| 609| ids[1] = generate_uid(); // R 2415| 609| ids[2] = generate_uid(); // S 2416| | 2417| | // translation 2418| 609| WriteAnimationCurveNode(outstream, 2419| 609| ids[0], "T", T, "Lcl Translation", 2420| 609| layer_uid, node_uids[node] 2421| 609| ); 2422| | 2423| | // rotation 2424| 609| WriteAnimationCurveNode(outstream, 2425| 609| ids[1], "R", R, "Lcl Rotation", 2426| 609| layer_uid, node_uids[node] 2427| 609| ); 2428| | 2429| | // scale 2430| 609| WriteAnimationCurveNode(outstream, 2431| 609| ids[2], "S", S, "Lcl Scale", 2432| 609| layer_uid, node_uids[node] 2433| 609| ); 2434| | 2435| | // store the uids for later use 2436| 609| nodeanim_uids.push_back(ids); 2437| 609| } 2438| 28| curve_node_uids.push_back(nodeanim_uids); 2439| 28| } 2440| | 2441| | // AnimCurve - defines actual keyframe data. 2442| | // there's a separate curve for every component of every vector, 2443| | // for example a transform curvenode will have separate X/Y/Z AnimCurve's 2444| 235| for (size_t ai = 0; ai < mScene->mNumAnimations; ++ai) { ------------------ | Branch (2444:25): [True: 28, False: 207] ------------------ 2445| 28| const aiAnimation* anim = mScene->mAnimations[ai]; 2446| 637| for (size_t nai = 0; nai < anim->mNumChannels; ++nai) { ------------------ | Branch (2446:30): [True: 609, False: 28] ------------------ 2447| 609| const aiNodeAnim* na = anim->mChannels[nai]; 2448| | // get the corresponding aiNode 2449| 609| const aiNode* node = mScene->mRootNode->FindNode(na->mNodeName); 2450| | // and its transform 2451| 609| const aiMatrix4x4 node_xfm = get_world_transform(node, mScene); 2452| 609| aiVector3D T, R, S; 2453| 609| node_xfm.Decompose(S, R, T); 2454| 609| const std::array& ids = curve_node_uids[ai][nai]; 2455| | 2456| 609| std::vector times; 2457| 609| std::vector xval, yval, zval; 2458| | 2459| | // position/translation 2460| 4.05k| for (size_t ki = 0; ki < na->mNumPositionKeys; ++ki) { ------------------ | Branch (2460:33): [True: 3.44k, False: 609] ------------------ 2461| 3.44k| const aiVectorKey& k = na->mPositionKeys[ki]; 2462| 3.44k| times.push_back(to_ktime(k.mTime, anim)); 2463| 3.44k| xval.push_back(k.mValue.x); 2464| 3.44k| yval.push_back(k.mValue.y); 2465| 3.44k| zval.push_back(k.mValue.z); 2466| 3.44k| } 2467| | // one curve each for X, Y, Z 2468| 609| WriteAnimationCurve(outstream, T.x, times, xval, ids[0], "d|X"); 2469| 609| WriteAnimationCurve(outstream, T.y, times, yval, ids[0], "d|Y"); 2470| 609| WriteAnimationCurve(outstream, T.z, times, zval, ids[0], "d|Z"); 2471| | 2472| | // rotation 2473| 609| times.clear(); xval.clear(); yval.clear(); zval.clear(); 2474| 9.14k| for (size_t ki = 0; ki < na->mNumRotationKeys; ++ki) { ------------------ | Branch (2474:33): [True: 8.53k, False: 609] ------------------ 2475| 8.53k| const aiQuatKey& k = na->mRotationKeys[ki]; 2476| 8.53k| times.push_back(to_ktime(k.mTime, anim)); 2477| | // TODO: aiQuaternion method to convert to Euler... 2478| 8.53k| aiMatrix4x4 m(k.mValue.GetMatrix()); 2479| 8.53k| aiVector3D qs, qr, qt; 2480| 8.53k| m.Decompose(qs, qr, qt); 2481| 8.53k| qr = AI_RAD_TO_DEG(qr); 2482| 8.53k| xval.push_back(qr.x); 2483| 8.53k| yval.push_back(qr.y); 2484| 8.53k| zval.push_back(qr.z); 2485| 8.53k| } 2486| 609| WriteAnimationCurve(outstream, R.x, times, xval, ids[1], "d|X"); 2487| 609| WriteAnimationCurve(outstream, R.y, times, yval, ids[1], "d|Y"); 2488| 609| WriteAnimationCurve(outstream, R.z, times, zval, ids[1], "d|Z"); 2489| | 2490| | // scaling/scale 2491| 609| times.clear(); xval.clear(); yval.clear(); zval.clear(); 2492| 1.43k| for (size_t ki = 0; ki < na->mNumScalingKeys; ++ki) { ------------------ | Branch (2492:33): [True: 823, False: 609] ------------------ 2493| 823| const aiVectorKey& k = na->mScalingKeys[ki]; 2494| 823| times.push_back(to_ktime(k.mTime, anim)); 2495| 823| xval.push_back(k.mValue.x); 2496| 823| yval.push_back(k.mValue.y); 2497| 823| zval.push_back(k.mValue.z); 2498| 823| } 2499| 609| WriteAnimationCurve(outstream, S.x, times, xval, ids[2], "d|X"); 2500| 609| WriteAnimationCurve(outstream, S.y, times, yval, ids[2], "d|Y"); 2501| 609| WriteAnimationCurve(outstream, S.z, times, zval, ids[2], "d|Z"); 2502| 609| } 2503| 28| } 2504| | 2505| 207| indent = 0; 2506| 207| object_node.End(outstream, binary, indent, true); 2507| 207|} _Z8add_metaRN6Assimp3FBX4NodeEPK6aiNode: 2532| 37.1k|void add_meta(FBX::Node& fbx_node, const aiNode* node){ 2533| 37.1k| if(node->mMetaData == nullptr) return; ------------------ | Branch (2533:8): [True: 37.1k, False: 14] ------------------ 2534| 14| aiMetadata* meta = node->mMetaData; 2535| 124| for (unsigned int i = 0; i < meta->mNumProperties; ++i) { ------------------ | Branch (2535:30): [True: 110, False: 14] ------------------ 2536| 110| aiString key = meta->mKeys[i]; 2537| 110| aiMetadataEntry* entry = &meta->mValues[i]; 2538| 110| switch (entry->mType) { 2539| 0| case AI_BOOL:{ ------------------ | Branch (2539:9): [True: 0, False: 110] ------------------ 2540| 0| bool val = *static_cast(entry->mData); 2541| 0| fbx_node.AddP70bool(key.C_Str(), val); 2542| 0| break; 2543| 0| } 2544| 68| case AI_INT32:{ ------------------ | Branch (2544:9): [True: 68, False: 42] ------------------ 2545| 68| int32_t val = *static_cast(entry->mData); 2546| 68| fbx_node.AddP70int(key.C_Str(), val); 2547| 68| break; 2548| 0| } 2549| 0| case AI_UINT64:{ ------------------ | Branch (2549:9): [True: 0, False: 110] ------------------ 2550| | //use string to add uint64 2551| 0| uint64_t val = *static_cast(entry->mData); 2552| 0| fbx_node.AddP70string(key.C_Str(), std::to_string(val).c_str()); 2553| 0| break; 2554| 0| } 2555| 3| case AI_FLOAT:{ ------------------ | Branch (2555:9): [True: 3, False: 107] ------------------ 2556| 3| float val = *static_cast(entry->mData); 2557| 3| fbx_node.AddP70double(key.C_Str(), val); 2558| 3| break; 2559| 0| } 2560| 0| case AI_DOUBLE:{ ------------------ | Branch (2560:9): [True: 0, False: 110] ------------------ 2561| 0| double val = *static_cast(entry->mData); 2562| 0| fbx_node.AddP70double(key.C_Str(), val); 2563| 0| break; 2564| 0| } 2565| 11| case AI_AISTRING:{ ------------------ | Branch (2565:9): [True: 11, False: 99] ------------------ 2566| 11| aiString val = *static_cast(entry->mData); 2567| 11| fbx_node.AddP70string(key.C_Str(), val.C_Str()); 2568| 11| break; 2569| 0| } 2570| 0| case AI_AIMETADATA: { ------------------ | Branch (2570:9): [True: 0, False: 110] ------------------ 2571| | //ignore 2572| 0| break; 2573| 0| } 2574| 28| default: ------------------ | Branch (2574:9): [True: 28, False: 82] ------------------ 2575| 28| break; 2576| 110| } 2577| | 2578| 110| } 2579| | 2580| 14|} _ZN6Assimp11FBXExporter14WriteModelNodeERNS_12StreamWriterILb0ELb0EEEbPK6aiNodelRKNSt3__112basic_stringIcNS7_11char_traitsIcEENS7_9allocatorIcEEEERKNS7_6vectorINS7_4pairISD_10aiVector3tIfEEENSB_ISK_EEEENS_3FBX20TransformInheritanceE: 2591| 37.1k|){ 2592| 37.1k| const aiVector3D zero = {0, 0, 0}; 2593| 37.1k| const aiVector3D one = {1, 1, 1}; 2594| 37.1k| FBX::Node m("Model"); 2595| 37.1k| std::string name = node->mName.C_Str() + FBX::SEPARATOR + "Model"; 2596| 37.1k| m.AddProperties(node_uid, std::move(name), type); 2597| 37.1k| m.AddChild("Version", int32_t(232)); 2598| 37.1k| FBX::Node p("Properties70"); 2599| 37.1k| p.AddP70bool("RotationActive", true); 2600| 37.1k| p.AddP70int("DefaultAttributeIndex", 0); 2601| 37.1k| p.AddP70enum("InheritType", inherit_type); 2602| 37.1k| if (transform_chain.empty()) { ------------------ | Branch (2602:9): [True: 37.1k, False: 0] ------------------ 2603| | // decompose 4x4 transform matrix into TRS 2604| 37.1k| aiVector3D t, r, s; 2605| 37.1k| node->mTransformation.Decompose(s, r, t); 2606| 37.1k| if (t != zero) { ------------------ | Branch (2606:13): [True: 709, False: 36.4k] ------------------ 2607| 709| p.AddP70( 2608| 709| "Lcl Translation", "Lcl Translation", "", "A", 2609| 709| double(t.x), double(t.y), double(t.z) 2610| 709| ); 2611| 709| } 2612| 37.1k| if (r != zero) { ------------------ | Branch (2612:13): [True: 304, False: 36.8k] ------------------ 2613| 304| r = AI_RAD_TO_DEG(r); 2614| 304| p.AddP70( 2615| 304| "Lcl Rotation", "Lcl Rotation", "", "A", 2616| 304| double(r.x), double(r.y), double(r.z) 2617| 304| ); 2618| 304| } 2619| 37.1k| if (s != one) { ------------------ | Branch (2619:13): [True: 198, False: 36.9k] ------------------ 2620| 198| p.AddP70( 2621| 198| "Lcl Scaling", "Lcl Scaling", "", "A", 2622| 198| double(s.x), double(s.y), double(s.z) 2623| 198| ); 2624| 198| } 2625| 37.1k| } else { 2626| | // apply the transformation chain. 2627| | // these transformation elements are created when importing FBX, 2628| | // which has a complex transformation hierarchy for each node. 2629| | // as such we can bake the hierarchy back into the node on export. 2630| 0| for (auto &item : transform_chain) { ------------------ | Branch (2630:25): [True: 0, False: 0] ------------------ 2631| 0| auto elem = transform_types.find(item.first); 2632| 0| if (elem == transform_types.end()) { ------------------ | Branch (2632:17): [True: 0, False: 0] ------------------ 2633| | // then this is a bug 2634| 0| std::stringstream err; 2635| 0| err << "unrecognized FBX transformation type: "; 2636| 0| err << item.first; 2637| 0| throw DeadlyExportError(err.str()); 2638| 0| } 2639| 0| const std::string &cur_name = elem->second.first; 2640| 0| const aiVector3D &v = item.second; 2641| 0| if (cur_name.compare(0, 4, "Lcl ") == 0) { ------------------ | Branch (2641:17): [True: 0, False: 0] ------------------ 2642| | // special handling for animatable properties 2643| 0| p.AddP70( cur_name, cur_name, "", "A", double(v.x), double(v.y), double(v.z) ); 2644| 0| } else { 2645| 0| p.AddP70vector(cur_name, v.x, v.y, v.z); 2646| 0| } 2647| 0| } 2648| 0| } 2649| 37.1k| add_meta(p, node); 2650| 37.1k| m.AddChild(p); 2651| | 2652| | // not sure what these are for, 2653| | // but they seem to be omnipresent 2654| 37.1k| m.AddChild("Shading", FBXExportProperty(true)); 2655| 37.1k| m.AddChild("Culling", FBXExportProperty("CullingOff")); 2656| | 2657| 37.1k| m.Dump(outstream, binary, 1); 2658| 37.1k|} _ZN6Assimp11FBXExporter15WriteModelNodesERNS_12StreamWriterILb0ELb0EEEPK6aiNodelRKNSt3__113unordered_setIS6_NS7_4hashIS6_EENS7_8equal_toIS6_EENS7_9allocatorIS6_EEEE: 2666| 37.2k|) { 2667| 37.2k| std::vector> chain; 2668| 37.2k| WriteModelNodes(s, node, parent_uid, limbnodes, chain); 2669| 37.2k|} _ZN6Assimp11FBXExporter15WriteModelNodesERNS_12StreamWriterILb0ELb0EEEPK6aiNodelRKNSt3__113unordered_setIS6_NS7_4hashIS6_EENS7_8equal_toIS6_EENS7_9allocatorIS6_EEEERNS7_6vectorINS7_4pairINS7_12basic_stringIcNS7_11char_traitsIcEENSD_IcEEEE10aiVector3tIfEEENSD_ISR_EEEE: 2677| 37.2k|) { 2678| | // first collapse any expanded transformation chains created by FBX import. 2679| 37.2k| std::string node_name(node->mName.C_Str()); 2680| 37.2k| if (node_name.find(MAGIC_NODE_TAG) != std::string::npos) { ------------------ | Branch (2680:9): [True: 0, False: 37.2k] ------------------ 2681| 0| auto pos = node_name.find(MAGIC_NODE_TAG) + MAGIC_NODE_TAG.size() + 1; 2682| 0| std::string type_name = node_name.substr(pos); 2683| 0| auto elem = transform_types.find(type_name); 2684| 0| if (elem == transform_types.end()) { ------------------ | Branch (2684:13): [True: 0, False: 0] ------------------ 2685| | // then this is a bug and should be fixed 2686| 0| std::stringstream err; 2687| 0| err << "unrecognized FBX transformation node"; 2688| 0| err << " of type " << type_name << " in node " << node_name; 2689| 0| throw DeadlyExportError(err.str()); 2690| 0| } 2691| 0| aiVector3D t, r, s; 2692| 0| node->mTransformation.Decompose(s, r, t); 2693| 0| switch (elem->second.second) { 2694| 0| case 'i': // inverse ------------------ | Branch (2694:9): [True: 0, False: 0] ------------------ 2695| | // we don't need to worry about the inverse matrices 2696| 0| break; 2697| 0| case 't': // translation ------------------ | Branch (2697:9): [True: 0, False: 0] ------------------ 2698| 0| transform_chain.emplace_back(elem->first, t); 2699| 0| break; 2700| 0| case 'r': // rotation ------------------ | Branch (2700:9): [True: 0, False: 0] ------------------ 2701| 0| transform_chain.emplace_back(elem->first, AI_RAD_TO_DEG(r)); 2702| 0| break; 2703| 0| case 's': // scale ------------------ | Branch (2703:9): [True: 0, False: 0] ------------------ 2704| 0| transform_chain.emplace_back(elem->first, s); 2705| 0| break; 2706| 0| default: ------------------ | Branch (2706:9): [True: 0, False: 0] ------------------ 2707| | // this should never happen 2708| 0| std::stringstream err; 2709| 0| err << "unrecognized FBX transformation type code: "; 2710| 0| err << elem->second.second; 2711| 0| throw DeadlyExportError(err.str()); 2712| 0| } 2713| | // now continue on to any child nodes 2714| 0| for (unsigned i = 0; i < node->mNumChildren; ++i) { ------------------ | Branch (2714:30): [True: 0, False: 0] ------------------ 2715| 0| WriteModelNodes( 2716| 0| outstream, 2717| 0| node->mChildren[i], 2718| 0| parent_uid, 2719| 0| limbnodes, 2720| 0| transform_chain 2721| 0| ); 2722| 0| } 2723| 0| return; 2724| 0| } 2725| | 2726| 37.2k| int64_t node_uid = 0; 2727| | // generate uid and connect to parent, if not the root node, 2728| 37.2k| if (node != mScene->mRootNode) { ------------------ | Branch (2728:9): [True: 37.0k, False: 207] ------------------ 2729| 37.0k| auto elem = node_uids.find(node); 2730| 37.0k| if (elem != node_uids.end()) { ------------------ | Branch (2730:13): [True: 3.07k, False: 34.0k] ------------------ 2731| 3.07k| node_uid = elem->second; 2732| 34.0k| } else { 2733| 34.0k| node_uid = generate_uid(); 2734| 34.0k| node_uids[node] = node_uid; 2735| 34.0k| } 2736| 37.0k| connections.emplace_back("C", "OO", node_uid, parent_uid); 2737| 37.0k| } 2738| | 2739| | // what type of node is this? 2740| 37.2k| if (node == mScene->mRootNode) { ------------------ | Branch (2740:9): [True: 207, False: 37.0k] ------------------ 2741| | // handled later 2742| 37.0k| } else if (node->mNumMeshes == 1) { ------------------ | Branch (2742:16): [True: 12.3k, False: 24.7k] ------------------ 2743| | // connect to child mesh, which should have been written previously 2744| | // TODO double check this line 2745| 12.3k| connections.emplace_back("C", "OO", mesh_uids[node], node_uid); 2746| | // also connect to the material for the child mesh 2747| 12.3k| connections.emplace_back( 2748| 12.3k| "C", "OO", 2749| 12.3k| material_uids[mScene->mMeshes[node->mMeshes[0]]->mMaterialIndex], 2750| 12.3k| node_uid 2751| 12.3k| ); 2752| | // write model node 2753| 12.3k| WriteModelNode( 2754| 12.3k| outstream, binary, node, node_uid, "Mesh", transform_chain 2755| 12.3k| ); 2756| 24.7k| } else if (limbnodes.count(node)) { ------------------ | Branch (2756:16): [True: 3.07k, False: 21.7k] ------------------ 2757| 3.07k| WriteModelNode( 2758| 3.07k| outstream, binary, node, node_uid, "LimbNode", transform_chain 2759| 3.07k| ); 2760| | // we also need to write a nodeattribute to mark it as a skeleton 2761| 3.07k| int64_t node_attribute_uid = generate_uid(); 2762| 3.07k| FBX::Node na("NodeAttribute"); 2763| 3.07k| na.AddProperties( 2764| 3.07k| node_attribute_uid, FBX::SEPARATOR + "NodeAttribute", "LimbNode" 2765| 3.07k| ); 2766| 3.07k| na.AddChild("TypeFlags", FBXExportProperty("Skeleton")); 2767| 3.07k| na.Dump(outstream, binary, 1); 2768| | // and connect them 2769| 3.07k| connections.emplace_back("C", "OO", node_attribute_uid, node_uid); 2770| 21.7k| } else if (node->mNumMeshes >= 1) { ------------------ | Branch (2770:16): [True: 267, False: 21.4k] ------------------ 2771| 267| connections.emplace_back("C", "OO", mesh_uids[node], node_uid); 2772| 1.50k| for (size_t i = 0; i < node->mNumMeshes; i++) { ------------------ | Branch (2772:26): [True: 1.23k, False: 267] ------------------ 2773| 1.23k| connections.emplace_back( 2774| 1.23k| "C", "OO", 2775| 1.23k| material_uids[mScene->mMeshes[node->mMeshes[i]]->mMaterialIndex], 2776| 1.23k| node_uid 2777| 1.23k| ); 2778| 1.23k| } 2779| 267| WriteModelNode(outstream, binary, node, node_uid, "Mesh", transform_chain); 2780| 21.4k| } else { 2781| 21.4k| const auto& lightIt = lights_uids.find(node->mName.C_Str()); 2782| 21.4k| if(lightIt != lights_uids.end()) { ------------------ | Branch (2782:12): [True: 52, False: 21.3k] ------------------ 2783| | // Node has a light connected to it. 2784| 52| WriteModelNode( 2785| 52| outstream, binary, node, node_uid, "Light", transform_chain 2786| 52| ); 2787| 52| connections.emplace_back("C", "OO", lightIt->second, node_uid); 2788| 21.3k| } else { 2789| | // generate a null node so we can add children to it 2790| 21.3k| WriteModelNode( 2791| 21.3k| outstream, binary, node, node_uid, "Null", transform_chain 2792| 21.3k| ); 2793| 21.3k| } 2794| 21.4k| } 2795| | 2796| 37.2k| if (node == mScene->mRootNode && node->mNumMeshes > 0) { ------------------ | Branch (2796:9): [True: 207, False: 37.0k] | Branch (2796:38): [True: 47, False: 160] ------------------ 2797| 47| int64_t new_node_uid = generate_uid(); 2798| 47| connections.emplace_back("C", "OO", new_node_uid, node_uid); 2799| 47| connections.emplace_back("C", "OO", mesh_uids[node], new_node_uid); 2800| 142| for (size_t i = 0; i < node->mNumMeshes; ++i) { ------------------ | Branch (2800:26): [True: 95, False: 47] ------------------ 2801| 95| connections.emplace_back( 2802| 95| "C", "OO", 2803| 95| material_uids[mScene->mMeshes[node->mMeshes[i]]->mMaterialIndex], 2804| 95| new_node_uid 2805| 95| ); 2806| 95| } 2807| 47| aiNode new_node; 2808| 47| new_node.mName = mScene->mMeshes[0]->mName; 2809| 47| WriteModelNode(outstream, binary, &new_node, new_node_uid, "Mesh", {}); 2810| 47| } 2811| | 2812| | // now recurse into children 2813| 74.3k| for (size_t i = 0; i < node->mNumChildren; ++i) { ------------------ | Branch (2813:24): [True: 37.0k, False: 37.2k] ------------------ 2814| 37.0k| WriteModelNodes( 2815| 37.0k| outstream, node->mChildren[i], node_uid, limbnodes 2816| 37.0k| ); 2817| 37.0k| } 2818| 37.2k|} _ZN6Assimp11FBXExporter23WriteAnimationCurveNodeERNS_12StreamWriterILb0ELb0EEElRKNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE10aiVector3tIfESC_ll: 2827| 1.82k| int64_t node_uid) { 2828| 1.82k| FBX::Node n("AnimationCurveNode"); 2829| 1.82k| n.AddProperties(uid, name + FBX::SEPARATOR + "AnimCurveNode", ""); 2830| 1.82k| FBX::Node p("Properties70"); 2831| 1.82k| p.AddP70numberA("d|X", default_value.x); 2832| 1.82k| p.AddP70numberA("d|Y", default_value.y); 2833| 1.82k| p.AddP70numberA("d|Z", default_value.z); 2834| 1.82k| n.AddChild(p); 2835| 1.82k| n.Dump(outstream, binary, 1); 2836| | // connect to layer 2837| 1.82k| this->connections.emplace_back("C", "OO", uid, layer_uid); 2838| | // connect to bone 2839| 1.82k| this->connections.emplace_back("C", "OP", uid, node_uid, property_name); 2840| 1.82k|} _ZN6Assimp11FBXExporter19WriteAnimationCurveERNS_12StreamWriterILb0ELb0EEEdRKNSt3__16vectorIlNS4_9allocatorIlEEEERKNS5_IfNS6_IfEEEElRKNS4_12basic_stringIcNS4_11char_traitsIcEENS6_IcEEEE: 2849| 5.48k|) { 2850| 5.48k| FBX::Node n("AnimationCurve"); 2851| 5.48k| int64_t curve_uid = generate_uid(); 2852| 5.48k| n.AddProperties(curve_uid, FBX::SEPARATOR + "AnimCurve", ""); 2853| 5.48k| n.AddChild("Default", default_value); 2854| 5.48k| n.AddChild("KeyVer", int32_t(4009)); 2855| 5.48k| n.AddChild("KeyTime", times); 2856| 5.48k| n.AddChild("KeyValueFloat", values); 2857| | // TODO: keyattr flags and data (STUB for now) 2858| 5.48k| n.AddChild("KeyAttrFlags", std::vector{0}); 2859| 5.48k| n.AddChild("KeyAttrDataFloat", std::vector{0,0,0,0}); 2860| 5.48k| n.AddChild( 2861| 5.48k| "KeyAttrRefCount", 2862| 5.48k| std::vector{static_cast(times.size())} 2863| 5.48k| ); 2864| 5.48k| n.Dump(outstream, binary, 1); 2865| 5.48k| this->connections.emplace_back( 2866| 5.48k| "C", "OP", curve_uid, curvenode_uid, property_link 2867| 5.48k| ); 2868| 5.48k|} _ZN6Assimp11FBXExporter16WriteConnectionsEv: 2872| 207|{ 2873| | // we should have completed the connection graph already, 2874| | // so basically just dump it here 2875| 207| if (!binary) { ------------------ | Branch (2875:9): [True: 0, False: 207] ------------------ 2876| 0| WriteAsciiSectionHeader("Object connections"); 2877| 0| } 2878| | // TODO: comments with names in the ascii version 2879| 207| FBX::Node conn("Connections"); 2880| 207| StreamWriterLE outstream(outfile); 2881| 207| conn.Begin(outstream, binary, 0); 2882| 207| conn.BeginChildren(outstream, binary, 0); 2883| 82.0k| for (auto &n : connections) { ------------------ | Branch (2883:18): [True: 82.0k, False: 207] ------------------ 2884| 82.0k| n.Dump(outstream, binary, 1); 2885| 82.0k| } 2886| 207| conn.End(outstream, binary, 0, !connections.empty()); 2887| 207| connections.clear(); 2888| 207|} FBXExporter.cpp:_ZL13has_phong_matPK7aiScene: 547| 174|static bool has_phong_mat(const aiScene* scene) { 548| | // just search for any material with a shininess exponent 549| 327| for (size_t i = 0; i < scene->mNumMaterials; ++i) { ------------------ | Branch (549:24): [True: 210, False: 117] ------------------ 550| 210| aiMaterial* mat = scene->mMaterials[i]; 551| 210| float shininess = 0; 552| 210| mat->Get(AI_MATKEY_SHININESS, shininess); 553| 210| if (shininess > 0) { ------------------ | Branch (553:13): [True: 57, False: 153] ------------------ 554| 57| return true; 555| 57| } 556| 210| } 557| 117| return false; 558| 174|} FBXExporter.cpp:_ZL12count_imagesPK7aiScene: 560| 208|static size_t count_images(const aiScene* scene) { 561| 208| std::unordered_set images; 562| 208| aiString texpath; 563| 454| for (size_t i = 0; i < scene->mNumMaterials; ++i) { ------------------ | Branch (563:24): [True: 246, False: 208] ------------------ 564| 246| aiMaterial *mat = scene->mMaterials[i]; 565| 4.42k| for (size_t tt = aiTextureType_DIFFUSE; tt < aiTextureType_UNKNOWN; ++tt) { ------------------ | Branch (565:49): [True: 4.18k, False: 246] ------------------ 566| 4.18k| const aiTextureType textype = static_cast(tt); 567| 4.18k| const size_t texcount = mat->GetTextureCount(textype); 568| 4.29k| for (unsigned int j = 0; j < texcount; ++j) { ------------------ | Branch (568:38): [True: 116, False: 4.18k] ------------------ 569| 116| mat->GetTexture(textype, j, &texpath); 570| 116| images.insert(std::string(texpath.C_Str())); 571| 116| } 572| 4.18k| } 573| 246| } 574| | 575| 208| return images.size(); 576| 208|} FBXExporter.cpp:_ZL14count_texturesPK7aiScene: 578| 208|static size_t count_textures(const aiScene* scene) { 579| 208| size_t count = 0; 580| 454| for (size_t i = 0; i < scene->mNumMaterials; ++i) { ------------------ | Branch (580:24): [True: 246, False: 208] ------------------ 581| 246| aiMaterial* mat = scene->mMaterials[i]; 582| 246| for ( 583| 246| size_t tt = aiTextureType_DIFFUSE; 584| 4.42k| tt < aiTextureType_UNKNOWN; ------------------ | Branch (584:13): [True: 4.18k, False: 246] ------------------ 585| 4.18k| ++tt 586| 4.18k| ){ 587| | // TODO: handle layered textures 588| 4.18k| if (mat->GetTextureCount(static_cast(tt)) > 0) { ------------------ | Branch (588:17): [True: 105, False: 4.07k] ------------------ 589| 105| count += 1; 590| 105| } 591| 4.18k| } 592| 246| } 593| 208| return count; 594| 208|} FBXExporter.cpp:_ZL15count_deformersPK7aiScene: 596| 208|static size_t count_deformers(const aiScene* scene) { 597| 208| size_t count = 0; 598| 3.78k| for (size_t i = 0; i < scene->mNumMeshes; ++i) { ------------------ | Branch (598:24): [True: 3.57k, False: 208] ------------------ 599| 3.57k| const size_t n = scene->mMeshes[i]->mNumBones; 600| 3.57k| if (n) { ------------------ | Branch (600:13): [True: 27, False: 3.54k] ------------------ 601| | // 1 main deformer, 1 subdeformer per bone 602| 27| count += n + 1; 603| 27| } 604| 3.57k| } 605| 208| return count; 606| 208|} FBXExporter.cpp:_ZL17get_node_for_meshjP6aiNode: 1019| 271|static aiNode* get_node_for_mesh(unsigned int meshIndex, aiNode* node) { 1020| 280| for (size_t i = 0; i < node->mNumMeshes; ++i) { ------------------ | Branch (1020:24): [True: 35, False: 245] ------------------ 1021| 35| if (node->mMeshes[i] == meshIndex) { ------------------ | Branch (1021:13): [True: 26, False: 9] ------------------ 1022| 26| return node; 1023| 26| } 1024| 35| } 1025| 473| for (size_t i = 0; i < node->mNumChildren; ++i) { ------------------ | Branch (1025:24): [True: 245, False: 228] ------------------ 1026| 245| aiNode* ret = get_node_for_mesh(meshIndex, node->mChildren[i]); 1027| 245| if (ret) { return ret; } ------------------ | Branch (1027:13): [True: 17, False: 228] ------------------ 1028| 245| } 1029| 228| return nullptr; 1030| 245|} _Z8to_ktimedPK11aiAnimation: 1045| 12.8k|inline int64_t to_ktime(double ticks, const aiAnimation* anim) { 1046| 12.8k| if (FP_ZERO == std::fpclassify(anim->mTicksPerSecond)) { ------------------ | Branch (1046:9): [True: 2.47k, False: 10.3k] ------------------ 1047| 2.47k| return static_cast(ticks * FBX::SECOND); 1048| 2.47k| } 1049| | 1050| | // Defensive: handle zero or near-zero mTicksPerSecond 1051| 10.3k| double tps = anim->mTicksPerSecond; 1052| 10.3k| double timeVal; 1053| 10.3k| if (FP_ZERO == std::fpclassify(tps)) { ------------------ | Branch (1053:9): [True: 0, False: 10.3k] ------------------ 1054| 0| timeVal = ticks; 1055| 10.3k| } else { 1056| 10.3k| timeVal = ticks / tps; 1057| 10.3k| } 1058| | 1059| | // Clamp to prevent overflow 1060| 10.3k| const double kMax = static_cast(INT64_MAX) / static_cast(FBX::SECOND); 1061| 10.3k| const double kMin = static_cast(INT64_MIN) / static_cast(FBX::SECOND); 1062| | 1063| 10.3k| if (timeVal > kMax) { ------------------ | Branch (1063:9): [True: 0, False: 10.3k] ------------------ 1064| 0| return INT64_MAX; 1065| 0| } 1066| 10.3k| if (timeVal < kMin) { ------------------ | Branch (1066:9): [True: 0, False: 10.3k] ------------------ 1067| 0| return INT64_MIN; 1068| 0| } 1069| 10.3k| return static_cast((ticks / anim->mTicksPerSecond) * FBX::SECOND); 1070| 10.3k|} FBXExporter.cpp:_ZZN6Assimp11FBXExporter12WriteObjectsEvENK3$_0clEPK6aiNode: 1108| 37.2k| std::function visit_node_geo = [&](const aiNode *node) { 1109| 37.2k| if (node->mNumMeshes == 0) { ------------------ | Branch (1109:13): [True: 24.6k, False: 12.6k] ------------------ 1110| 58.8k| for (uint32_t ni = 0; ni < node->mNumChildren; ni++) { ------------------ | Branch (1110:33): [True: 34.1k, False: 24.6k] ------------------ 1111| 34.1k| visit_node_geo(node->mChildren[ni]); 1112| 34.1k| } 1113| 24.6k| return; 1114| 24.6k| } 1115| | 1116| | // start the node record 1117| 12.6k| FBX::Node n("Geometry"); 1118| 12.6k| int64_t uid = generate_uid(); 1119| 12.6k| mesh_uids[node] = uid; 1120| 12.6k| n.AddProperty(uid); 1121| 12.6k| n.AddProperty(FBX::SEPARATOR + "Geometry"); 1122| 12.6k| n.AddProperty("Mesh"); 1123| 12.6k| n.Begin(outstream, binary, indent); 1124| 12.6k| n.DumpProperties(outstream, binary, indent); 1125| 12.6k| n.EndProperties(outstream, binary, indent); 1126| 12.6k| n.BeginChildren(outstream, binary, indent); 1127| | 1128| | // output vertex data - each vertex should be unique (probably) 1129| 12.6k| std::vector flattened_vertices; 1130| | // index of original vertex in vertex data vector 1131| 12.6k| std::vector vertex_indices; 1132| | 1133| 12.6k| std::vector normal_data; 1134| 12.6k| std::vector color_data; 1135| | 1136| 12.6k| std::vector polygon_data; 1137| | 1138| 12.6k| std::vector> uv_data; 1139| 12.6k| std::vector> uv_indices; 1140| | 1141| 12.6k| indent = 2; 1142| | 1143| 26.2k| for (uint32_t n_mi = 0; n_mi < node->mNumMeshes; n_mi++) { ------------------ | Branch (1143:33): [True: 13.6k, False: 12.6k] ------------------ 1144| 13.6k| const auto mi = node->mMeshes[n_mi]; 1145| 13.6k| const aiMesh *m = mScene->mMeshes[mi]; 1146| | 1147| 13.6k| size_t v_offset = vertex_indices.size(); 1148| 13.6k| size_t uniq_v_before = flattened_vertices.size() / 3; 1149| | 1150| | // map of vertex value to its index in the data vector 1151| 13.6k| std::map index_by_vertex_value; 1152| 13.6k| if (bJoinIdenticalVertices) { ------------------ | Branch (1152:15): [True: 0, False: 13.6k] ------------------ 1153| 0| int32_t index = 0; 1154| 0| for (size_t vi = 0; vi < m->mNumVertices; ++vi) { ------------------ | Branch (1154:35): [True: 0, False: 0] ------------------ 1155| 0| aiVector3D vtx = m->mVertices[vi]; 1156| 0| auto elem = index_by_vertex_value.find(vtx); 1157| 0| if (elem == index_by_vertex_value.end()) { ------------------ | Branch (1157:23): [True: 0, False: 0] ------------------ 1158| 0| vertex_indices.push_back(index); 1159| 0| index_by_vertex_value[vtx] = index; 1160| 0| flattened_vertices.insert(flattened_vertices.end(), { vtx.x, vtx.y, vtx.z }); 1161| 0| ++index; 1162| 0| } else { 1163| 0| vertex_indices.push_back(int32_t(elem->second)); 1164| 0| } 1165| 0| } 1166| 13.6k| } else { // do not join vertex, respect the export flag 1167| 13.6k| vertex_indices.resize(v_offset + m->mNumVertices); 1168| 13.6k| std::iota(vertex_indices.begin() + v_offset, vertex_indices.end(), 0); 1169| 959k| for(unsigned int v = 0; v < m->mNumVertices; ++ v) { ------------------ | Branch (1169:39): [True: 946k, False: 13.6k] ------------------ 1170| 946k| aiVector3D vtx = m->mVertices[v]; 1171| 946k| flattened_vertices.insert(flattened_vertices.end(), {vtx.x, vtx.y, vtx.z}); 1172| 946k| } 1173| 13.6k| } 1174| 13.6k| vVertexIndice[mi].insert( 1175| | // TODO test whether this can be end or not 1176| 13.6k| vVertexIndice[mi].end(), 1177| 13.6k| vertex_indices.begin() + v_offset, 1178| 13.6k| vertex_indices.end() 1179| 13.6k| ); 1180| | 1181| | // here could be edges but they're insane. 1182| | // it's optional anyway, so let's ignore it. 1183| | 1184| | // output polygon data as a flattened array of vertex indices. 1185| | // the last vertex index of each polygon is negated and - 1 1186| 1.78M| for (size_t fi = 0; fi < m->mNumFaces; fi++) { ------------------ | Branch (1186:31): [True: 1.77M, False: 13.6k] ------------------ 1187| 1.77M| const aiFace &f = m->mFaces[fi]; 1188| 1.77M| if (f.mNumIndices == 0) continue; ------------------ | Branch (1188:17): [True: 0, False: 1.77M] ------------------ 1189| 1.77M| size_t pvi = 0; 1190| 5.27M| for (; pvi < f.mNumIndices - 1; pvi++) { ------------------ | Branch (1190:20): [True: 3.49M, False: 1.77M] ------------------ 1191| 3.49M| polygon_data.push_back( 1192| 3.49M| static_cast(uniq_v_before + vertex_indices[v_offset + f.mIndices[pvi]]) 1193| 3.49M| ); 1194| 3.49M| } 1195| 1.77M| polygon_data.push_back( 1196| 1.77M| static_cast(-1 ^ (uniq_v_before + vertex_indices[v_offset+f.mIndices[pvi]])) 1197| 1.77M| ); 1198| 1.77M| } 1199| | 1200| 13.6k| uniq_v_before_mi.push_back(static_cast(uniq_v_before)); 1201| | 1202| 13.6k| if (m->HasNormals()) { ------------------ | Branch (1202:15): [True: 12.6k, False: 1.02k] ------------------ 1203| 12.6k| normal_data.reserve(3 * polygon_data.size()); 1204| 1.78M| for (size_t fi = 0; fi < m->mNumFaces; fi++) { ------------------ | Branch (1204:33): [True: 1.77M, False: 12.6k] ------------------ 1205| 1.77M| const aiFace & f = m->mFaces[fi]; 1206| 7.03M| for (size_t pvi = 0; pvi < f.mNumIndices; pvi++) { ------------------ | Branch (1206:36): [True: 5.26M, False: 1.77M] ------------------ 1207| 5.26M| const aiVector3D &curN = m->mNormals[f.mIndices[pvi]]; 1208| 5.26M| normal_data.insert(normal_data.end(), { curN.x, curN.y, curN.z }); 1209| 5.26M| } 1210| 1.77M| } 1211| 12.6k| } 1212| | 1213| 13.6k| const int32_t colorChannelIndex = 0; 1214| 13.6k| if (m->HasVertexColors(colorChannelIndex)) { ------------------ | Branch (1214:15): [True: 214, False: 13.4k] ------------------ 1215| 214| color_data.reserve(4 * polygon_data.size()); 1216| 33.6k| for (size_t fi = 0; fi < m->mNumFaces; fi++) { ------------------ | Branch (1216:33): [True: 33.4k, False: 214] ------------------ 1217| 33.4k| const aiFace &f = m->mFaces[fi]; 1218| 133k| for (size_t pvi = 0; pvi < f.mNumIndices; pvi++) { ------------------ | Branch (1218:36): [True: 99.5k, False: 33.4k] ------------------ 1219| 99.5k| const aiColor4D &c = m->mColors[colorChannelIndex][f.mIndices[pvi]]; 1220| 99.5k| color_data.insert(color_data.end(), { c.r, c.g, c.b, c.a }); 1221| 99.5k| } 1222| 33.4k| } 1223| 214| } 1224| | 1225| 13.6k| const auto num_uv = static_cast(m->GetNumUVChannels()); 1226| 13.6k| uv_indices.resize(std::max(num_uv, uv_indices.size())); 1227| 13.6k| uv_data.resize(std::max(num_uv, uv_data.size())); 1228| 13.6k| std::map index_by_uv; 1229| | 1230| | // uvs, if any 1231| 13.9k| for (size_t uvi = 0; uvi < m->GetNumUVChannels(); uvi++) { ------------------ | Branch (1231:32): [True: 276, False: 13.6k] ------------------ 1232| 276| const auto nc = m->mNumUVComponents[uvi]; 1233| 276| if (nc > 2) { ------------------ | Branch (1233:17): [True: 1, False: 275] ------------------ 1234| | // FBX only supports 2-channel UV maps... 1235| | // or at least i'm not sure how to indicate a different number 1236| 1| std::stringstream err; 1237| 1| err << "Only 2-channel UV maps supported by FBX,"; 1238| 1| err << " but mesh " << mi; 1239| 1| if (m->mName.length) { ------------------ | Branch (1239:21): [True: 1, False: 0] ------------------ 1240| 1| err << " (" << m->mName.C_Str() << ")"; 1241| 1| } 1242| 1| err << " UV map " << uvi; 1243| 1| err << " has " << m->mNumUVComponents[uvi]; 1244| 1| err << " components! Data will be preserved,"; 1245| 1| err << " but may be incorrectly interpreted on load."; 1246| 1| ASSIMP_LOG_WARN(err.str()); 1247| 1| } 1248| | 1249| 276| int32_t index = static_cast(uv_data[uvi].size()) / nc; 1250| 152k| for (size_t fi = 0; fi < m->mNumFaces; fi++) { ------------------ | Branch (1250:33): [True: 151k, False: 276] ------------------ 1251| 151k| const aiFace &f = m->mFaces[fi]; 1252| 607k| for (size_t pvi = 0; pvi < f.mNumIndices; pvi++) { ------------------ | Branch (1252:36): [True: 455k, False: 151k] ------------------ 1253| 455k| const aiVector3D &curUv = m->mTextureCoords[uvi][f.mIndices[pvi]]; 1254| 455k| auto elem = index_by_uv.find(curUv); 1255| 455k| if (elem == index_by_uv.end()) { ------------------ | Branch (1255:21): [True: 78.6k, False: 376k] ------------------ 1256| 78.6k| index_by_uv[curUv] = index; 1257| 78.6k| uv_indices[uvi].push_back(index); 1258| 236k| for (uint32_t x = 0; x < nc; ++x) { ------------------ | Branch (1258:40): [True: 157k, False: 78.6k] ------------------ 1259| 157k| uv_data[uvi].push_back(curUv[x]); 1260| 157k| } 1261| 78.6k| ++index; 1262| 376k| } else { 1263| 376k| uv_indices[uvi].push_back(elem->second); 1264| 376k| } 1265| 455k| } 1266| 151k| } 1267| 276| } 1268| 13.6k| } 1269| | 1270| | 1271| 12.6k| FBX::Node::WritePropertyNode("Vertices", flattened_vertices, outstream, binary, indent); 1272| 12.6k| FBX::Node::WritePropertyNode("PolygonVertexIndex", polygon_data, outstream, binary, indent); 1273| 12.6k| FBX::Node::WritePropertyNode("GeometryVersion", int32_t(124), outstream, binary, indent); 1274| | 1275| 12.6k| if (!normal_data.empty()) { ------------------ | Branch (1275:6): [True: 12.1k, False: 516] ------------------ 1276| 12.1k| FBX::Node normals("LayerElementNormal", int32_t(0)); 1277| 12.1k| normals.Begin(outstream, binary, indent); 1278| 12.1k| normals.DumpProperties(outstream, binary, indent); 1279| 12.1k| normals.EndProperties(outstream, binary, indent); 1280| 12.1k| normals.BeginChildren(outstream, binary, indent); 1281| 12.1k| indent = 3; 1282| 12.1k| FBX::Node::WritePropertyNode("Version", int32_t(101), outstream, binary, indent); 1283| 12.1k| FBX::Node::WritePropertyNode("Name", "", outstream, binary, indent); 1284| 12.1k| FBX::Node::WritePropertyNode("MappingInformationType", "ByPolygonVertex", outstream, binary, indent); 1285| 12.1k| FBX::Node::WritePropertyNode("ReferenceInformationType", "Direct", outstream, binary, indent); 1286| 12.1k| FBX::Node::WritePropertyNode("Normals", normal_data, outstream, binary, indent); 1287| | // note: version 102 has a NormalsW also... not sure what it is, 1288| | // so stick with version 101 for now. 1289| 12.1k| indent = 2; 1290| 12.1k| normals.End(outstream, binary, indent, true); 1291| 12.1k| } 1292| | 1293| 12.6k| if (!color_data.empty()) { ------------------ | Branch (1293:6): [True: 201, False: 12.4k] ------------------ 1294| 201| const auto colorChannelIndex = 0; 1295| 201| FBX::Node vertexcolors("LayerElementColor", int32_t(colorChannelIndex)); 1296| 201| vertexcolors.Begin(outstream, binary, indent); 1297| 201| vertexcolors.DumpProperties(outstream, binary, indent); 1298| 201| vertexcolors.EndProperties(outstream, binary, indent); 1299| 201| vertexcolors.BeginChildren(outstream, binary, indent); 1300| 201| indent = 3; 1301| 201| FBX::Node::WritePropertyNode("Version", int32_t(101), outstream, binary, indent); 1302| 201| char layerName[8]; 1303| 201| snprintf(layerName, sizeof(layerName), "COLOR_%d", colorChannelIndex); 1304| 201| FBX::Node::WritePropertyNode("Name", (const char *)layerName, outstream, binary, indent); 1305| 201| FBX::Node::WritePropertyNode("MappingInformationType", "ByPolygonVertex", outstream, binary, indent); 1306| 201| FBX::Node::WritePropertyNode("ReferenceInformationType", "Direct", outstream, binary, indent); 1307| 201| FBX::Node::WritePropertyNode("Colors", color_data, outstream, binary, indent); 1308| 201| indent = 2; 1309| 201| vertexcolors.End(outstream, binary, indent, true); 1310| 201| } 1311| | 1312| 12.8k| for (uint32_t uvi = 0; uvi < uv_data.size(); uvi++) { ------------------ | Branch (1312:32): [True: 189, False: 12.6k] ------------------ 1313| 189| FBX::Node uv("LayerElementUV", int32_t(uvi)); 1314| 189| uv.Begin(outstream, binary, indent); 1315| 189| uv.DumpProperties(outstream, binary, indent); 1316| 189| uv.EndProperties(outstream, binary, indent); 1317| 189| uv.BeginChildren(outstream, binary, indent); 1318| 189| indent = 3; 1319| 189| FBX::Node::WritePropertyNode("Version", int32_t(101), outstream, binary, indent); 1320| 189| FBX::Node::WritePropertyNode("Name", "", outstream, binary, indent); 1321| 189| FBX::Node::WritePropertyNode("MappingInformationType", "ByPolygonVertex", outstream, binary, indent); 1322| 189| FBX::Node::WritePropertyNode("ReferenceInformationType", "IndexToDirect", outstream, binary, indent); 1323| 189| FBX::Node::WritePropertyNode("UV", uv_data[uvi], outstream, binary, indent); 1324| 189| FBX::Node::WritePropertyNode("UVIndex", uv_indices[uvi], outstream, binary, indent); 1325| 189| indent = 2; 1326| 189| uv.End(outstream, binary, indent, true); 1327| 189| } 1328| | 1329| | 1330| | // When merging multiple meshes, we instead use by polygon so the correct material is 1331| | // assigned to each face. Previously, this LayerElementMaterial always had 0 since it 1332| | // assumed there was 1 material for each node for all meshes. 1333| 12.6k| FBX::Node mat("LayerElementMaterial", int32_t(0)); 1334| 12.6k| mat.AddChild("Version", int32_t(101)); 1335| 12.6k| mat.AddChild("Name", ""); 1336| 12.6k| if (node->mNumMeshes == 1) { ------------------ | Branch (1336:13): [True: 12.3k, False: 290] ------------------ 1337| 12.3k| mat.AddChild("MappingInformationType", "AllSame"); 1338| 12.3k| mat.AddChild("ReferenceInformationType", "IndexToDirect"); 1339| 12.3k| std::vector mat_indices = {0}; 1340| 12.3k| mat.AddChild("Materials", mat_indices); 1341| 12.3k| } else { 1342| 290| mat.AddChild("MappingInformationType", "ByPolygon"); 1343| 290| mat.AddChild("ReferenceInformationType", "IndexToDirect"); 1344| 290| std::vector mat_indices; 1345| 1.59k| for (uint32_t n_mi = 0; n_mi < node->mNumMeshes; n_mi++) { ------------------ | Branch (1345:35): [True: 1.30k, False: 290] ------------------ 1346| 1.30k| const auto mi = node->mMeshes[n_mi]; 1347| 1.30k| const auto *const m = mScene->mMeshes[mi]; 1348| 227k| for (size_t fi = 0; fi < m->mNumFaces; fi++) { ------------------ | Branch (1348:33): [True: 226k, False: 1.30k] ------------------ 1349| 226k| mat_indices.push_back(n_mi); 1350| 226k| } 1351| 1.30k| } 1352| 290| mat.AddChild("Materials", mat_indices); 1353| 290| } 1354| 12.6k| mat.Dump(outstream, binary, indent); 1355| | 1356| | // finally we have the layer specifications, 1357| | // which select the normals / UV set / etc to use. 1358| | // TODO: handle multiple uv sets correctly? 1359| 12.6k| FBX::Node layer("Layer", int32_t(0)); 1360| 12.6k| layer.AddChild("Version", int32_t(100)); 1361| 12.6k| FBX::Node le; 1362| | 1363| 12.6k| if (!normal_data.empty()) { ------------------ | Branch (1363:7): [True: 12.1k, False: 516] ------------------ 1364| 12.1k| le = FBX::Node("LayerElement"); 1365| 12.1k| le.AddChild("Type", "LayerElementNormal"); 1366| 12.1k| le.AddChild("TypedIndex", int32_t(0)); 1367| 12.1k| layer.AddChild(le); 1368| 12.1k| } 1369| | 1370| 12.6k| if (!color_data.empty()) { ------------------ | Branch (1370:7): [True: 201, False: 12.4k] ------------------ 1371| 201| le = FBX::Node("LayerElement"); 1372| 201| le.AddChild("Type", "LayerElementColor"); 1373| 201| le.AddChild("TypedIndex", int32_t(0)); 1374| 201| layer.AddChild(le); 1375| 201| } 1376| | 1377| 12.6k| le = FBX::Node("LayerElement"); 1378| 12.6k| le.AddChild("Type", "LayerElementMaterial"); 1379| 12.6k| le.AddChild("TypedIndex", int32_t(0)); 1380| 12.6k| layer.AddChild(le); 1381| 12.6k| le = FBX::Node("LayerElement"); 1382| 12.6k| le.AddChild("Type", "LayerElementUV"); 1383| 12.6k| le.AddChild("TypedIndex", int32_t(0)); 1384| 12.6k| layer.AddChild(le); 1385| 12.6k| layer.Dump(outstream, binary, indent); 1386| | 1387| 12.6k| for(unsigned int lr = 1; lr < uv_data.size(); ++ lr) { ------------------ | Branch (1387:34): [True: 3, False: 12.6k] ------------------ 1388| 3| FBX::Node layerExtra("Layer", int32_t(lr)); 1389| 3| layerExtra.AddChild("Version", int32_t(100)); 1390| 3| FBX::Node leExtra("LayerElement"); 1391| 3| leExtra.AddChild("Type", "LayerElementUV"); 1392| 3| leExtra.AddChild("TypedIndex", int32_t(lr)); 1393| 3| layerExtra.AddChild(leExtra); 1394| 3| layerExtra.Dump(outstream, binary, indent); 1395| 3| } 1396| | // finish the node record 1397| 12.6k| indent = 1; 1398| 12.6k| n.End(outstream, binary, indent, true); 1399| | 1400| 15.5k| for (uint32_t ni = 0; ni < node->mNumChildren; ni++) { ------------------ | Branch (1400:31): [True: 2.93k, False: 12.6k] ------------------ 1401| 2.93k| visit_node_geo(node->mChildren[ni]); 1402| 2.93k| } 1403| 12.6k| return; 1404| 37.2k| }; _ZN6Assimp11FBXExporter12generate_uidEv: 101| 64.0k| int64_t generate_uid() { return ++last_uid; } _ZN6Assimp3FBX14ImportSettingsC2Ev: 54| 624| strictMode(true), 55| 624| readAllLayers(true), 56| 624| readAllMaterials(false), 57| 624| readMaterials(true), 58| 624| readTextures(true), 59| 624| readCameras(true), 60| 624| readLights(true), 61| 624| readAnimations(true), 62| 624| readWeights(true), 63| 624| useSkeleton(false), 64| 624| preservePivots(true), 65| 624| optimizeEmptyAnimationCurves(true), 66| 624| useLegacyEmbeddedTextureNaming(false), 67| 624| removeEmptyBones(true), 68| 624| convertToMeters(false) { 69| | // empty 70| 624| } _ZNK6Assimp11FBXImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 91| 49|bool FBXImporter::CanRead(const std::string & pFile, IOSystem * pIOHandler, bool /*checkSig*/) const { 92| | // at least ASCII-FBX files usually have a 'FBX' somewhere in their head 93| 49| static const char *tokens[] = { " \n\r\n " }; 94| | return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); 95| 49|} _ZNK6Assimp11FBXImporter7GetInfoEv: 99| 634|const aiImporterDesc *FBXImporter::GetInfo() const { 100| 634| return &desc; 101| 634|} _ZN6Assimp11FBXImporterC2Ev: 73| 624| FBXImporter() = default; _ZN6Assimp11HMPImporterC2Ev: 75| 624|HMPImporter::HMPImporter() = default; _ZN6Assimp11HMPImporterD2Ev: 79| 624|HMPImporter::~HMPImporter() = default; _ZNK6Assimp11HMPImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 83| 410|bool HMPImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 84| 410| static constexpr uint32_t tokens[] = { 85| 410| AI_HMP_MAGIC_NUMBER_LE_4, ------------------ | | 53| 410|#define AI_HMP_MAGIC_NUMBER_LE_4 AI_MAKE_MAGIC("4PMH") ------------------ 86| 410| AI_HMP_MAGIC_NUMBER_LE_5, ------------------ | | 56| 410|#define AI_HMP_MAGIC_NUMBER_LE_5 AI_MAKE_MAGIC("5PMH") ------------------ 87| 410| AI_HMP_MAGIC_NUMBER_LE_7 ------------------ | | 59| 410|#define AI_HMP_MAGIC_NUMBER_LE_7 AI_MAKE_MAGIC("7PMH") ------------------ 88| 410| }; 89| | return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); 90| 410|} _ZNK6Assimp11HMPImporter7GetInfoEv: 94| 634|const aiImporterDesc *HMPImporter::GetInfo() const { 95| 634| return &desc; 96| 634|} _ZN6Assimp12LogFunctionsINS_11IFCImporterEE6PrefixEv: 73| 1|const char *LogFunctions::Prefix() { 74| 1| return "IFC: "; 75| 1|} _ZNK6Assimp11IFCImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 121| 54|bool IFCImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 122| | // note: this is the common identification for STEP-encoded files, so 123| | // it is only unambiguous as long as we don't support any further 124| | // file formats with STEP as their encoding. 125| 54| static const char *tokens[] = { "ISO-10303-21" }; 126| | return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); 127| 54|} _ZNK6Assimp11IFCImporter7GetInfoEv: 131| 637|const aiImporterDesc *IFCImporter::GetInfo() const { 132| 637| return &desc; 133| 637|} _ZN6Assimp11IFCImporter15SetupPropertiesEPKNS_8ImporterE: 137| 3|void IFCImporter::SetupProperties(const Importer *pImp) { 138| 3| settings.skipSpaceRepresentations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS, true); 139| 3| settings.useCustomTriangulation = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION, true); 140| 3| settings.conicSamplingAngle = std::min(std::max((float)pImp->GetPropertyFloat(AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE, AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE), 5.0f), 120.0f); 141| 3| settings.cylindricalTessellation = std::min(std::max(pImp->GetPropertyInteger(AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION, AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION), 3), 180); 142| 3| settings.skipAnnotations = true; 143| 3|} _ZN6Assimp11IFCImporter14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 147| 3|void IFCImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { 148| 3| std::shared_ptr stream(pIOHandler->Open(pFile)); 149| 3| if (!stream) { ------------------ | Branch (149:9): [True: 0, False: 3] ------------------ 150| 0| ThrowException("Could not open file for reading"); 151| 0| } 152| | 153| | // if this is a ifczip file, decompress its contents first 154| 3| if (GetExtension(pFile) == "ifczip") { ------------------ | Branch (154:9): [True: 0, False: 3] ------------------ 155| 0|#ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC 156| 0| unzFile zip = unzOpen(pFile.c_str()); 157| 0| if (zip == nullptr) { ------------------ | Branch (157:13): [True: 0, False: 0] ------------------ 158| 0| ThrowException("Could not open ifczip file for reading, unzip failed"); 159| 0| } 160| | 161| | // chop 'zip' postfix 162| 0| std::string fileName = pFile.substr(0, pFile.length() - 3); 163| | 164| 0| std::string::size_type s = pFile.find_last_of('\\'); 165| 0| if (s == std::string::npos) { ------------------ | Branch (165:13): [True: 0, False: 0] ------------------ 166| 0| s = pFile.find_last_of('/'); 167| 0| } 168| 0| if (s != std::string::npos) { ------------------ | Branch (168:13): [True: 0, False: 0] ------------------ 169| 0| fileName = fileName.substr(s + 1); 170| 0| } 171| | 172| | // search file (same name as the IFCZIP except for the file extension) and place file pointer there 173| 0| if (UNZ_OK == unzGoToFirstFile(zip)) { ------------------ | | 74| 0|#define UNZ_OK (0) ------------------ | Branch (173:13): [True: 0, False: 0] ------------------ 174| 0| do { 175| | // get file size, etc. 176| 0| unz_file_info fileInfo; 177| 0| char filename[256]; 178| 0| unzGetCurrentFileInfo(zip, &fileInfo, filename, sizeof(filename), nullptr, 0, nullptr, 0); 179| 0| if (GetExtension(filename) != "ifc") { ------------------ | Branch (179:21): [True: 0, False: 0] ------------------ 180| 0| continue; 181| 0| } 182| 0| uint8_t *buff = new uint8_t[fileInfo.uncompressed_size]; 183| 0| LogInfo("Decompressing IFCZIP file"); 184| 0| unzOpenCurrentFile(zip); 185| 0| size_t total = 0; 186| 0| int read = 0; 187| 0| do { 188| 0| unsigned bufferSize = fileInfo.uncompressed_size < INT16_MAX ? static_cast(fileInfo.uncompressed_size) : INT16_MAX; ------------------ | Branch (188:43): [True: 0, False: 0] ------------------ 189| 0| void *buffer = malloc(bufferSize); 190| 0| read = unzReadCurrentFile(zip, buffer, bufferSize); 191| 0| if (read > 0) { ------------------ | Branch (191:25): [True: 0, False: 0] ------------------ 192| 0| memcpy((char *)buff + total, buffer, read); 193| 0| total += read; 194| 0| } 195| 0| free(buffer); 196| 0| } while (read > 0); ------------------ | Branch (196:26): [True: 0, False: 0] ------------------ 197| 0| size_t filesize = fileInfo.uncompressed_size; 198| 0| if (total == 0 || size_t(total) != filesize) { ------------------ | Branch (198:21): [True: 0, False: 0] | Branch (198:35): [True: 0, False: 0] ------------------ 199| 0| delete[] buff; 200| 0| ThrowException("Failed to decompress IFC ZIP file"); 201| 0| } 202| 0| unzCloseCurrentFile(zip); 203| 0| stream = std::make_shared(buff, fileInfo.uncompressed_size, true); 204| 0| if (unzGoToNextFile(zip) == UNZ_END_OF_LIST_OF_FILE) { ------------------ | | 75| 0|#define UNZ_END_OF_LIST_OF_FILE (-100) ------------------ | Branch (204:21): [True: 0, False: 0] ------------------ 205| 0| ThrowException("Found no IFC file member in IFCZIP file (1)"); 206| 0| } 207| 0| break; 208| | 209| 0| } while (true); ------------------ | Branch (209:22): [True: 0, Folded] ------------------ 210| 0| } else { 211| 0| ThrowException("Found no IFC file member in IFCZIP file (2)"); 212| 0| } 213| | 214| 0| unzClose(zip); 215| |#else 216| | ThrowException("Could not open ifczip file for reading, assimp was built without ifczip support"); 217| |#endif 218| 0| } 219| | 220| 3| std::unique_ptr db(STEP::ReadFileHeader(std::move(stream))); 221| 3| const STEP::HeaderInfo &head = static_cast(*db).GetHeader(); 222| | 223| 3| if (!head.fileSchema.size() || head.fileSchema.substr(0, 4) != "IFC2") { ------------------ | Branch (223:9): [True: 3, False: 0] | Branch (223:9): [True: 1, False: 2] | Branch (223:36): [True: 0, False: 0] ------------------ 224| 1| ThrowException("Unrecognized file schema: " + head.fileSchema); 225| 1| } 226| | 227| 3| if (!DefaultLogger::isNullLogger()) { ------------------ | Branch (227:9): [True: 0, False: 3] ------------------ 228| 0| LogDebug("File schema is \'", head.fileSchema, '\''); 229| 0| if (head.timestamp.length()) { ------------------ | Branch (229:13): [True: 0, False: 0] ------------------ 230| 0| LogDebug("Timestamp \'", head.timestamp, '\''); 231| 0| } 232| 0| if (head.app.length()) { ------------------ | Branch (232:13): [True: 0, False: 0] ------------------ 233| 0| LogDebug("Application/Exporter identline is \'", head.app, '\''); 234| 0| } 235| 0| } 236| | 237| | // obtain a copy of the machine-generated IFC scheme 238| 3| ::Assimp::STEP::EXPRESS::ConversionSchema schema; 239| 3| Schema_2x3::GetSchema(schema); 240| | 241| | // tell the reader which entity types to track with special care 242| 3| static const char *const types_to_track[] = { 243| 3| "ifcsite", "ifcbuilding", "ifcproject" 244| 3| }; 245| | 246| | // tell the reader for which types we need to simulate STEPs reverse indices 247| 3| static const char *const inverse_indices_to_track[] = { 248| 3| "ifcrelcontainedinspatialstructure", 249| 3| "ifcrelaggregates", 250| 3| "ifcrelvoidselement", 251| 3| "ifcreldefinesbyproperties", 252| 3| "ifcpropertyset", 253| 3| "ifcstyleditem" 254| 3| }; 255| | 256| | // feed the IFC schema into the reader and pre-parse all lines 257| 3| STEP::ReadFile(*db, schema, types_to_track, inverse_indices_to_track); 258| 3| const STEP::LazyObject *proj = db->GetObject("ifcproject"); 259| 3| if (!proj) { ------------------ | Branch (259:9): [True: 0, False: 3] ------------------ 260| 0| ThrowException("missing IfcProject entity"); 261| 0| } 262| | 263| 3| ConversionData conv(*db, proj->To(), pScene, settings); 264| 3| SetUnits(conv); 265| 3| SetCoordinateSpace(conv); 266| 3| ProcessSpatialStructures(conv); 267| 3| MakeTreeRelative(conv); 268| | 269| |// NOTE - this is a stress test for the importer, but it works only 270| |// in a build with no entities disabled. See 271| |// scripts/IFCImporter/CPPGenerator.py 272| |// for more information. 273| |#ifdef ASSIMP_IFC_TEST 274| | db->EvaluateAll(); 275| |#endif 276| | 277| | // do final data copying 278| 3| if (conv.meshes.size()) { ------------------ | Branch (278:9): [True: 0, False: 3] ------------------ 279| 0| pScene->mNumMeshes = static_cast(conv.meshes.size()); 280| 0| pScene->mMeshes = new aiMesh *[pScene->mNumMeshes](); 281| 0| std::copy(conv.meshes.begin(), conv.meshes.end(), pScene->mMeshes); 282| | 283| | // needed to keep the d'tor from burning us 284| 0| conv.meshes.clear(); 285| 0| } 286| | 287| 3| if (conv.materials.size()) { ------------------ | Branch (287:9): [True: 0, False: 3] ------------------ 288| 0| pScene->mNumMaterials = static_cast(conv.materials.size()); 289| 0| pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials](); 290| 0| std::copy(conv.materials.begin(), conv.materials.end(), pScene->mMaterials); 291| | 292| | // needed to keep the d'tor from burning us 293| 0| conv.materials.clear(); 294| 0| } 295| | 296| | // apply world coordinate system (which includes the scaling to convert to meters and a -90 degrees rotation around x) 297| 3| aiMatrix4x4 scale, rot; 298| 3| aiMatrix4x4::Scaling(static_cast(IfcVector3(conv.len_scale)), scale); 299| 3| aiMatrix4x4::RotationX(-AI_MATH_HALF_PI_F, rot); 300| | 301| 3| pScene->mRootNode->mTransformation = rot * scale * conv.wcs * pScene->mRootNode->mTransformation; 302| | 303| | // this must be last because objects are evaluated lazily as we process them 304| 3| if (!DefaultLogger::isNullLogger()) { ------------------ | Branch (304:9): [True: 0, False: 3] ------------------ 305| 0| LogDebug("STEP: evaluated ", db->GetEvaluatedObjectCount(), " object records"); 306| 0| } 307| 3|} _ZN6Assimp11IFCImporterC2Ev: 89| 624| IFCImporter() = default; _ZN6Assimp11IFCImporter8SettingsC2Ev: 80| 624| skipSpaceRepresentations(), useCustomTriangulation(), skipAnnotations(), conicSamplingAngle(10.f), cylindricalTessellation(32) {} _ZN6Assimp11IQMImporterC2Ev: 87| 624| mScene(nullptr) { 88| | // empty 89| 624|} _ZNK6Assimp11IQMImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 93| 43|bool IQMImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const { 94| 43| const std::string extension = GetExtension(pFile); 95| | 96| 43| if (extension == "iqm") ------------------ | Branch (96:9): [True: 0, False: 43] ------------------ 97| 0| return true; 98| 43| else if (!extension.length() || checkSig) { ------------------ | Branch (98:14): [True: 43, False: 0] | Branch (98:37): [True: 0, False: 0] ------------------ 99| 43| if (!pIOHandler) { ------------------ | Branch (99:13): [True: 0, False: 43] ------------------ 100| 0| return true; 101| 0| } 102| 43| std::unique_ptr pStream(pIOHandler->Open(pFile, "rb")); 103| 43| unsigned char data[15]; 104| 43| if (!pStream || 15 != pStream->Read(data, 1, 15)) { ------------------ | Branch (104:13): [True: 0, False: 43] | Branch (104:25): [True: 0, False: 43] ------------------ 105| 0| return false; 106| 0| } 107| 43| return !memcmp(data, "INTERQUAKEMODEL", 15); 108| 43| } 109| 0| return false; 110| 43|} _ZNK6Assimp11IQMImporter7GetInfoEv: 113| 635|const aiImporterDesc *IQMImporter::GetInfo() const { 114| 635| return &desc; 115| 635|} _ZN6Assimp11IQMImporter14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 119| 1|void IQMImporter::InternReadFile(const std::string &file, aiScene *pScene, IOSystem *pIOHandler) { 120| | // Read file into memory 121| 1| std::unique_ptr pStream(pIOHandler->Open(file, "rb")); 122| 1| if (!pStream) { ------------------ | Branch (122:9): [True: 0, False: 1] ------------------ 123| 0| throw DeadlyImportError("Failed to open file ", file, "."); 124| 0| } 125| | 126| | // Get the file-size and validate it, throwing an exception when fails 127| 1| const size_t fileSize = pStream->FileSize(); 128| 1| if (fileSize < sizeof( iqmheader )) { ------------------ | Branch (128:9): [True: 0, False: 1] ------------------ 129| 0| throw DeadlyImportError("IQM-file ", file, " is too small."); 130| 0| } 131| 1| std::vector buffer(fileSize); 132| 1| unsigned char *data = buffer.data(); 133| 1| if (fileSize != pStream->Read(data, 1, fileSize)) { ------------------ | Branch (133:9): [True: 0, False: 1] ------------------ 134| 0| throw DeadlyImportError("Failed to read the file ", file, "."); 135| 0| } 136| | 137| | // get header 138| 1| iqmheader &hdr = reinterpret_cast( *data ); 139| 1| swap_block( &hdr.version, sizeof( iqmheader ) - sizeof( iqmheader::magic ) ); 140| | 141| | // extra check for header 142| 1| if (memcmp(data, IQM_MAGIC, sizeof( IQM_MAGIC ) ) ------------------ | | 4| 1|#define IQM_MAGIC "INTERQUAKEMODEL" ------------------ if (memcmp(data, IQM_MAGIC, sizeof( IQM_MAGIC ) ) ------------------ | | 4| 1|#define IQM_MAGIC "INTERQUAKEMODEL" ------------------ | Branch (142:9): [True: 0, False: 1] ------------------ 143| 1| || hdr.version != IQM_VERSION ------------------ | | 5| 2|#define IQM_VERSION 2 ------------------ | Branch (143:9): [True: 0, False: 1] ------------------ 144| 1| || hdr.filesize != fileSize) { ------------------ | Branch (144:9): [True: 0, False: 1] ------------------ 145| 0| throw DeadlyImportError("Bad binary header in file ", file, "."); 146| 0| } 147| | 148| 1| ASSIMP_LOG_DEBUG("IQM: loading ", file); 149| | 150| | // create the root node 151| 1| pScene->mRootNode = new aiNode( "" ); 152| | // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system 153| 1| pScene->mRootNode->mTransformation = aiMatrix4x4( 154| 1| 1.f, 0.f, 0.f, 0.f, 155| 1| 0.f, 0.f, 1.f, 0.f, 156| 1| 0.f, -1.f, 0.f, 0.f, 157| 1| 0.f, 0.f, 0.f, 1.f); 158| 1| pScene->mRootNode->mNumMeshes = hdr.num_meshes; 159| 1| pScene->mRootNode->mMeshes = new unsigned int[hdr.num_meshes]; 160| 1| std::iota( pScene->mRootNode->mMeshes, pScene->mRootNode->mMeshes + pScene->mRootNode->mNumMeshes, 0 ); 161| | 162| 1| mScene = pScene; 163| | 164| | // Allocate output storage 165| 1| pScene->mNumMeshes = 0; 166| 1| pScene->mMeshes = new aiMesh *[hdr.num_meshes](); // Set arrays to zero to ensue proper destruction if an exception is raised 167| | 168| 1| pScene->mNumMaterials = 0; 169| 1| pScene->mMaterials = new aiMaterial *[hdr.num_meshes](); 170| | 171| | // swap vertex arrays beforehand... 172| 7| for( auto array = reinterpret_cast( data + hdr.ofs_vertexarrays ), end = array + hdr.num_vertexarrays; array != end; ++array ) ------------------ | Branch (172:125): [True: 6, False: 1] ------------------ 173| 6| { 174| 6| swap_block( &array->type, sizeof( iqmvertexarray ) ); 175| 6| } 176| | 177| | // Read all surfaces from the file 178| 3| for( auto imesh = reinterpret_cast( data + hdr.ofs_meshes ), end_ = imesh + hdr.num_meshes; imesh != end_; ++imesh ) ------------------ | Branch (178:107): [True: 2, False: 1] ------------------ 179| 2| { 180| 2| swap_block( &imesh->name, sizeof( iqmmesh ) ); 181| | // Allocate output mesh & material 182| 2| auto mesh = pScene->mMeshes[pScene->mNumMeshes++] = new aiMesh(); 183| 2| mesh->mMaterialIndex = pScene->mNumMaterials; 184| 2| auto mat = pScene->mMaterials[pScene->mNumMaterials++] = new aiMaterial(); 185| | 186| 2| { 187| 2| auto text = reinterpret_cast( data + hdr.ofs_text ); 188| 2| aiString name( text + imesh->material ); 189| 2| mat->AddProperty( &name, AI_MATKEY_NAME ); 190| 2| mat->AddProperty( &name, AI_MATKEY_TEXTURE_DIFFUSE(0) ); 191| 2| } 192| | 193| | // Fill mesh information 194| 2| mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; 195| 2| mesh->mNumFaces = 0; 196| 2| mesh->mFaces = new aiFace[imesh->num_triangles]; 197| | 198| | // Fill in all triangles 199| 2.99k| for( auto tri = reinterpret_cast( data + hdr.ofs_triangles ) + imesh->first_triangle, end = tri + imesh->num_triangles; tri != end; ++tri ) ------------------ | Branch (199:143): [True: 2.98k, False: 2] ------------------ 200| 2.98k| { 201| 2.98k| swap_block( tri->vertex, sizeof( tri->vertex ) ); 202| 2.98k| auto& face = mesh->mFaces[mesh->mNumFaces++]; 203| 2.98k| face.mNumIndices = 3; 204| 2.98k| face.mIndices = new unsigned int[3]{ tri->vertex[0] - imesh->first_vertex, 205| 2.98k| tri->vertex[2] - imesh->first_vertex, 206| 2.98k| tri->vertex[1] - imesh->first_vertex }; 207| 2.98k| } 208| | 209| | // Fill in all vertices 210| 14| for( auto array = reinterpret_cast( data + hdr.ofs_vertexarrays ), end__ = array + hdr.num_vertexarrays; array != end__; ++array ) ------------------ | Branch (210:137): [True: 12, False: 2] ------------------ 211| 12| { 212| 12| const unsigned int nVerts = imesh->num_vertexes; 213| 12| const unsigned int step = array->size; 214| | 215| 12| switch ( array->type ) 216| 12| { 217| 2| case IQM_POSITION: ------------------ | Branch (217:13): [True: 2, False: 10] ------------------ 218| 2| if( array->format == IQM_FLOAT && step >= 3 ){ ------------------ | Branch (218:21): [True: 2, False: 0] | Branch (218:51): [True: 2, False: 0] ------------------ 219| 2| mesh->mNumVertices = nVerts; 220| 2| auto v = mesh->mVertices = new aiVector3D[nVerts]; 221| 2| for( auto f = reinterpret_cast( data + array->offset ) + imesh->first_vertex * step, 222| 1.86k| end = f + nVerts * step; f != end; f += step, ++v ) ------------------ | Branch (222:50): [True: 1.86k, False: 2] ------------------ 223| 1.86k| { 224| 1.86k| *v = { AI_BE( f[0] ), 225| 1.86k| AI_BE( f[1] ), 226| 1.86k| AI_BE( f[2] ) }; 227| 1.86k| } 228| 2| } 229| 2| break; 230| 2| case IQM_TEXCOORD: ------------------ | Branch (230:16): [True: 2, False: 10] ------------------ 231| 2| if( array->format == IQM_FLOAT && step >= 2) ------------------ | Branch (231:21): [True: 2, False: 0] | Branch (231:51): [True: 2, False: 0] ------------------ 232| 2| { 233| 2| auto v = mesh->mTextureCoords[0] = new aiVector3D[nVerts]; 234| 2| mesh->mNumUVComponents[0] = 2; 235| 2| for( auto f = reinterpret_cast( data + array->offset ) + imesh->first_vertex * step, 236| 1.86k| end = f + nVerts * step; f != end; f += step, ++v ) ------------------ | Branch (236:50): [True: 1.86k, False: 2] ------------------ 237| 1.86k| { 238| 1.86k| *v = { AI_BE( f[0] ), 239| 1.86k| 1 - AI_BE( f[1] ), 0 }; 240| 1.86k| } 241| 2| } 242| 2| break; 243| 2| case IQM_NORMAL: ------------------ | Branch (243:13): [True: 2, False: 10] ------------------ 244| 2| if (array->format == IQM_FLOAT && step >= 3) ------------------ | Branch (244:21): [True: 2, False: 0] | Branch (244:51): [True: 2, False: 0] ------------------ 245| 2| { 246| 2| auto v = mesh->mNormals = new aiVector3D[nVerts]; 247| 2| for( auto f = reinterpret_cast( data + array->offset ) + imesh->first_vertex * step, 248| 1.86k| end = f + nVerts * step; f != end; f += step, ++v ) ------------------ | Branch (248:50): [True: 1.86k, False: 2] ------------------ 249| 1.86k| { 250| 1.86k| *v = { AI_BE( f[0] ), 251| 1.86k| AI_BE( f[1] ), 252| 1.86k| AI_BE( f[2] ) }; 253| 1.86k| } 254| 2| } 255| 2| break; 256| 0| case IQM_COLOR: ------------------ | Branch (256:13): [True: 0, False: 12] ------------------ 257| 0| if (array->format == IQM_UBYTE && step >= 3) ------------------ | Branch (257:21): [True: 0, False: 0] | Branch (257:51): [True: 0, False: 0] ------------------ 258| 0| { 259| 0| auto v = mesh->mColors[0] = new aiColor4D[nVerts]; 260| 0| for( auto f = ( data + array->offset ) + imesh->first_vertex * step, 261| 0| end = f + nVerts * step; f != end; f += step, ++v ) ------------------ | Branch (261:50): [True: 0, False: 0] ------------------ 262| 0| { 263| 0| *v = { ( f[0] ) / 255.f, 264| 0| ( f[1] ) / 255.f, 265| 0| ( f[2] ) / 255.f, 266| 0| step == 3? 1 : ( f[3] ) / 255.f }; ------------------ | Branch (266:32): [True: 0, False: 0] ------------------ 267| 0| } 268| 0| } 269| 0| else if (array->format == IQM_FLOAT && step >= 3) ------------------ | Branch (269:26): [True: 0, False: 0] | Branch (269:56): [True: 0, False: 0] ------------------ 270| 0| { 271| 0| auto v = mesh->mColors[0] = new aiColor4D[nVerts]; 272| 0| for( auto f = reinterpret_cast( data + array->offset ) + imesh->first_vertex * step, 273| 0| end = f + nVerts * step; f != end; f += step, ++v ) ------------------ | Branch (273:50): [True: 0, False: 0] ------------------ 274| 0| { 275| 0| *v = { AI_BE( f[0] ), 276| 0| AI_BE( f[1] ), 277| 0| AI_BE( f[2] ), 278| 0| step == 3? 1 : AI_BE( f[3] ) }; ------------------ | Branch (278:32): [True: 0, False: 0] ------------------ 279| 0| } 280| 0| } 281| 0| break; 282| 2| case IQM_TANGENT: ------------------ | Branch (282:13): [True: 2, False: 10] ------------------ 283| |#if 0 284| | if (array->format == IQM_FLOAT && step >= 3) 285| | { 286| | auto v = mesh->mTangents = new aiVector3D[nVerts]; 287| | for( auto f = reinterpret_cast( data + array->offset ) + imesh->first_vertex * step, 288| | end = f + nVerts * step; f != end; f += step, ++v ) 289| | { 290| | *v = { AI_BE( f[0] ), 291| | AI_BE( f[1] ), 292| | AI_BE( f[2] ) }; 293| | } 294| | } 295| |#endif 296| 2| break; 297| 2| case IQM_BLENDINDEXES: ------------------ | Branch (297:13): [True: 2, False: 10] ------------------ 298| 4| case IQM_BLENDWEIGHTS: ------------------ | Branch (298:13): [True: 2, False: 10] ------------------ 299| 4| case IQM_CUSTOM: ------------------ | Branch (299:13): [True: 0, False: 12] ------------------ 300| 4| break; // these attributes are not relevant. 301| | 302| 0| default: ------------------ | Branch (302:13): [True: 0, False: 12] ------------------ 303| 0| break; 304| 12| } 305| 12| } 306| 2| } 307| 1|} _Z10swap_blockPjm: 62| 2.99k|inline void swap_block( uint32_t *block, size_t size ){ 63| 2.99k| (void)block; // suppress 'unreferenced formal parameter' MSVC warning 64| 2.99k| size >>= 2; 65| 12.0k| for ( size_t i = 0; i < size; ++i ) ------------------ | Branch (65:25): [True: 9.03k, False: 2.99k] ------------------ 66| 9.03k| AI_SWAP4( block[ i ] ); 67| 2.99k|} _ZN6Assimp11IRRImporterC2Ev: 85| 624| fps(), configSpeedFlag() { 86| | // empty 87| 624|} _ZN6Assimp11IRRImporterD2Ev: 91| 624|IRRImporter::~IRRImporter() = default; _ZNK6Assimp11IRRImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 95| 340|bool IRRImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 96| 340| static const char *tokens[] = { "irr_scene" }; 97| | return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); 98| 340|} _ZNK6Assimp11IRRImporter7GetInfoEv: 101| 645|const aiImporterDesc *IRRImporter::GetInfo() const { 102| 645| return &desc; 103| 645|} _ZN6Assimp11IRRImporter15SetupPropertiesEPKNS_8ImporterE: 106| 11|void IRRImporter::SetupProperties(const Importer *pImp) { 107| | // read the output frame rate of all node animation channels 108| 11| fps = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_IRR_ANIM_FPS, 100); 109| 11| if (fps < 10.) { ------------------ | Branch (109:9): [True: 0, False: 11] ------------------ 110| 0| ASSIMP_LOG_ERROR("IRR: Invalid FPS configuration"); 111| 0| fps = 100; 112| 0| } 113| | 114| | // AI_CONFIG_FAVOUR_SPEED 115| | configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 0)); 116| 11|} _ZN6Assimp11IRRImporter12CopyMaterialERNSt3__16vectorIP10aiMaterialNS1_9allocatorIS4_EEEERNS2_INS1_4pairIS4_jEENS5_ISA_EEEERjP6aiMesh: 237| 13| aiMesh *mesh) { 238| 13| if (inmaterials.empty()) { ------------------ | Branch (238:9): [True: 0, False: 13] ------------------ 239| | // Do we have a default material? If not we need to create one 240| 0| if (UINT_MAX == defMatIdx) { ------------------ | Branch (240:13): [True: 0, False: 0] ------------------ 241| 0| defMatIdx = (unsigned int)materials.size(); 242| | // TODO: add this materials to someone? 243| | /*aiMaterial* mat = new aiMaterial(); 244| | 245| | aiString s; 246| | s.Set(AI_DEFAULT_MATERIAL_NAME); 247| | mat->AddProperty(&s,AI_MATKEY_NAME); 248| | 249| | aiColor3D c(0.6f,0.6f,0.6f); 250| | mat->AddProperty(&c,1,AI_MATKEY_COLOR_DIFFUSE);*/ 251| 0| } 252| 0| mesh->mMaterialIndex = defMatIdx; 253| 0| return; 254| 13| } else if (inmaterials.size() > 1) { ------------------ | Branch (254:16): [True: 0, False: 13] ------------------ 255| 0| ASSIMP_LOG_INFO("IRR: Skipping additional materials"); 256| 0| } 257| | 258| 13| mesh->mMaterialIndex = (unsigned int)materials.size(); 259| 13| materials.push_back(inmaterials[0].first); 260| 13|} _ZN6Assimp11IRRImporter17ComputeAnimationsEPNS0_4NodeEP6aiNodeRNSt3__16vectorIP10aiNodeAnimNS5_9allocatorIS8_EEEE: 280| 71|void IRRImporter::ComputeAnimations(Node *root, aiNode *real, std::vector &anims) { 281| 71| ai_assert(nullptr != root && nullptr != real); 282| | 283| | // XXX totally WIP - doesn't produce proper results, need to evaluate 284| | // whether there's any use for Irrlicht's proprietary scene format 285| | // outside Irrlicht ... 286| | // This also applies to the above function of FindSuitableMultiple and ClampSpline which are 287| | // solely used in this function 288| | 289| 71| if (root->animators.empty()) { ------------------ | Branch (289:9): [True: 59, False: 12] ------------------ 290| 59| return; 291| 59| } 292| 12| unsigned int total(0); 293| 24| for (std::list::iterator it = root->animators.begin(); it != root->animators.end(); ++it) { ------------------ | Branch (293:70): [True: 12, False: 12] ------------------ 294| 12| if ((*it).type == Animator::UNKNOWN || (*it).type == Animator::OTHER) { ------------------ | Branch (294:13): [True: 0, False: 12] | Branch (294:48): [True: 0, False: 12] ------------------ 295| 0| ASSIMP_LOG_WARN("IRR: Skipping unknown or unsupported animator"); 296| 0| continue; 297| 0| } 298| 12| ++total; 299| 12| } 300| 12| if (!total) { ------------------ | Branch (300:9): [True: 0, False: 12] ------------------ 301| 0| return; 302| 12| } else if (1 == total) { ------------------ | Branch (302:16): [True: 12, False: 0] ------------------ 303| 12| ASSIMP_LOG_WARN("IRR: Adding dummy nodes to simulate multiple animators"); 304| 12| } 305| | 306| | // NOTE: 1 tick == i millisecond 307| | 308| 12| unsigned int cur = 0; 309| 12| for (std::list::iterator it = root->animators.begin(); 310| 24| it != root->animators.end(); ++it) { ------------------ | Branch (310:13): [True: 12, False: 12] ------------------ 311| 12| if ((*it).type == Animator::UNKNOWN || (*it).type == Animator::OTHER) continue; ------------------ | Branch (311:13): [True: 0, False: 12] | Branch (311:48): [True: 0, False: 12] ------------------ 312| | 313| 12| Animator &in = *it; 314| 12| aiNodeAnim *anim = new aiNodeAnim(); 315| | 316| 12| if (cur != total - 1) { ------------------ | Branch (316:13): [True: 0, False: 12] ------------------ 317| | // Build a new name - a prefix instead of a suffix because it is 318| | // easier to check against 319| 0| anim->mNodeName.length = ::ai_snprintf(anim->mNodeName.data, AI_MAXLEN, 320| 0| "$INST_DUMMY_%i_%s", total - 1, 321| 0| (root->name.length() ? root->name.c_str() : "")); ------------------ | Branch (321:22): [True: 0, False: 0] ------------------ 322| | 323| | // we'll also need to insert a dummy in the node hierarchy. 324| 0| aiNode *dummy = new aiNode(); 325| | 326| 0| for (unsigned int i = 0; i < real->mParent->mNumChildren; ++i) ------------------ | Branch (326:38): [True: 0, False: 0] ------------------ 327| 0| if (real->mParent->mChildren[i] == real) ------------------ | Branch (327:21): [True: 0, False: 0] ------------------ 328| 0| real->mParent->mChildren[i] = dummy; 329| | 330| 0| dummy->mParent = real->mParent; 331| 0| dummy->mName = anim->mNodeName; 332| | 333| 0| dummy->mNumChildren = 1; 334| 0| dummy->mChildren = new aiNode *[dummy->mNumChildren]; 335| 0| dummy->mChildren[0] = real; 336| | 337| | // the transformation matrix of the dummy node is the identity 338| | 339| 0| real->mParent = dummy; 340| 0| } else 341| 12| anim->mNodeName.Set(root->name); 342| 12| ++cur; 343| | 344| 12| switch (in.type) { 345| 6| case Animator::ROTATION: { ------------------ | Branch (345:9): [True: 6, False: 6] ------------------ 346| | // ----------------------------------------------------- 347| | // find out how long a full rotation will take 348| | // This is the least common multiple of 360.f and all 349| | // three euler angles. Although we'll surely find a 350| | // possible multiple (haha) it could be somewhat large 351| | // for our purposes. So we need to modify the angles 352| | // here in order to get good results. 353| | // ----------------------------------------------------- 354| 6| int angles[3]; 355| 6| angles[0] = (int)(in.direction.x * 100); 356| 6| angles[1] = (int)(in.direction.y * 100); 357| 6| angles[2] = (int)(in.direction.z * 100); 358| | 359| 6| angles[0] %= 360; 360| 6| angles[1] %= 360; 361| 6| angles[2] %= 360; 362| | 363| 6| if ((angles[0] * angles[1]) != 0 && (angles[1] * angles[2]) != 0) { ------------------ | Branch (363:17): [True: 4, False: 2] | Branch (363:49): [True: 4, False: 0] ------------------ 364| 4| FindSuitableMultiple(angles[0]); 365| 4| FindSuitableMultiple(angles[1]); 366| 4| FindSuitableMultiple(angles[2]); 367| 4| } 368| | 369| 6| int lcm = 360; 370| | 371| 6| if (angles[0]) ------------------ | Branch (371:17): [True: 6, False: 0] ------------------ 372| 6| lcm = Math::lcm(lcm, angles[0]); 373| | 374| 6| if (angles[1]) ------------------ | Branch (374:17): [True: 4, False: 2] ------------------ 375| 4| lcm = Math::lcm(lcm, angles[1]); 376| | 377| 6| if (angles[2]) ------------------ | Branch (377:17): [True: 4, False: 2] ------------------ 378| 4| lcm = Math::lcm(lcm, angles[2]); 379| | 380| 6| if (360 == lcm) ------------------ | Branch (380:17): [True: 4, False: 2] ------------------ 381| 4| break; 382| | 383| | // find out how many time units we'll need for the finest 384| | // track (in seconds) - this defines the number of output 385| | // keys (fps * seconds) 386| 2| float max = 0.f; 387| 2| if (angles[0]) ------------------ | Branch (387:17): [True: 2, False: 0] ------------------ 388| 2| max = (float)lcm / angles[0]; 389| 2| if (angles[1]) ------------------ | Branch (389:17): [True: 2, False: 0] ------------------ 390| 2| max = std::max(max, (float)lcm / angles[1]); 391| 2| if (angles[2]) ------------------ | Branch (391:17): [True: 2, False: 0] ------------------ 392| 2| max = std::max(max, (float)lcm / angles[2]); 393| | 394| 2| anim->mNumRotationKeys = (unsigned int)(max * fps); 395| 2| anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys]; 396| | 397| | // begin with a zero angle 398| 2| aiVector3D angle; 399| 12.0k| for (unsigned int i = 0; i < anim->mNumRotationKeys; ++i) { ------------------ | Branch (399:38): [True: 12.0k, False: 2] ------------------ 400| | // build the quaternion for the given euler angles 401| 12.0k| aiQuatKey &q = anim->mRotationKeys[i]; 402| | 403| 12.0k| q.mValue = aiQuaternion(angle.x, angle.y, angle.z); 404| 12.0k| q.mTime = (double)i; 405| | 406| | // increase the angle 407| 12.0k| angle += in.direction; 408| 12.0k| } 409| | 410| | // This animation is repeated and repeated ... 411| 2| anim->mPostState = anim->mPreState = aiAnimBehaviour_REPEAT; 412| 2| } break; 413| | 414| 3| case Animator::FLY_CIRCLE: { ------------------ | Branch (414:9): [True: 3, False: 9] ------------------ 415| | // ----------------------------------------------------- 416| | // Find out how much time we'll need to perform a 417| | // full circle. 418| | // ----------------------------------------------------- 419| 3| const double seconds = (1. / in.speed) / 1000.; 420| 3| const double tdelta = 1000. / fps; 421| | 422| 3| anim->mNumPositionKeys = (unsigned int)(fps * seconds); 423| 3| anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys]; 424| | 425| | // from Irrlicht, what else should we do than copying it? 426| 3| aiVector3D vecU, vecV; 427| 3| if (in.direction.y) { ------------------ | Branch (427:17): [True: 3, False: 0] ------------------ 428| 3| vecV = aiVector3D(50, 0, 0) ^ in.direction; 429| 3| } else 430| 0| vecV = aiVector3D(0, 50, 00) ^ in.direction; 431| 3| vecV.Normalize(); 432| 3| vecU = (vecV ^ in.direction).Normalize(); 433| | 434| | // build the output keys 435| 300| for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) { ------------------ | Branch (435:38): [True: 297, False: 3] ------------------ 436| 297| aiVectorKey &key = anim->mPositionKeys[i]; 437| 297| key.mTime = i * tdelta; 438| | 439| 297| const ai_real t = (ai_real)(in.speed * key.mTime); 440| 297| key.mValue = in.circleCenter + in.circleRadius * ((vecU * std::cos(t)) + (vecV * std::sin(t))); 441| 297| } 442| | 443| | // This animation is repeated and repeated ... 444| 3| anim->mPostState = anim->mPreState = aiAnimBehaviour_REPEAT; 445| 3| } break; 446| | 447| 0| case Animator::FLY_STRAIGHT: { ------------------ | Branch (447:9): [True: 0, False: 12] ------------------ 448| 0| anim->mPostState = anim->mPreState = (in.loop ? aiAnimBehaviour_REPEAT : aiAnimBehaviour_CONSTANT); ------------------ | Branch (448:51): [True: 0, False: 0] ------------------ 449| 0| const double seconds = in.timeForWay / 1000.; 450| 0| const double tdelta = 1000. / fps; 451| | 452| 0| anim->mNumPositionKeys = (unsigned int)(fps * seconds); 453| 0| anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys]; 454| | 455| 0| aiVector3D diff = in.direction - in.circleCenter; 456| 0| const ai_real lengthOfWay = diff.Length(); 457| 0| diff.Normalize(); 458| | 459| 0| const double timeFactor = lengthOfWay / in.timeForWay; 460| | 461| | // build the output keys 462| 0| for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) { ------------------ | Branch (462:38): [True: 0, False: 0] ------------------ 463| 0| aiVectorKey &key = anim->mPositionKeys[i]; 464| 0| key.mTime = i * tdelta; 465| 0| key.mValue = in.circleCenter + diff * ai_real(timeFactor * key.mTime); 466| 0| } 467| 0| } break; 468| | 469| 3| case Animator::FOLLOW_SPLINE: { ------------------ | Branch (469:9): [True: 3, False: 9] ------------------ 470| | // repeat outside the defined time range 471| 3| anim->mPostState = anim->mPreState = aiAnimBehaviour_REPEAT; 472| 3| const int size = (int)in.splineKeys.size(); 473| 3| if (!size) { ------------------ | Branch (473:17): [True: 0, False: 3] ------------------ 474| | // We have no point in the spline. That's bad. Really bad. 475| 0| ASSIMP_LOG_WARN("IRR: Spline animators with no points defined"); 476| | 477| 0| delete anim; 478| 0| anim = nullptr; 479| 0| break; 480| 3| } else if (size == 1) { ------------------ | Branch (480:24): [True: 0, False: 3] ------------------ 481| | // We have just one point in the spline so we don't need the full calculation 482| 0| anim->mNumPositionKeys = 1; 483| 0| anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys]; 484| | 485| 0| anim->mPositionKeys[0].mValue = in.splineKeys[0].mValue; 486| 0| anim->mPositionKeys[0].mTime = 0.f; 487| 0| break; 488| 0| } 489| | 490| 3| unsigned int ticksPerFull = 15; 491| 3| anim->mNumPositionKeys = (unsigned int)(ticksPerFull * fps); 492| 3| anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys]; 493| | 494| 4.50k| for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) { ------------------ | Branch (494:38): [True: 4.50k, False: 3] ------------------ 495| 4.50k| aiVectorKey &key = anim->mPositionKeys[i]; 496| | 497| 4.50k| const ai_real dt = (i * in.speed * ai_real(0.001)); 498| 4.50k| const ai_real u = dt - std::floor(dt); 499| 4.50k| const int idx = (int)std::floor(dt) % size; 500| | 501| | // get the 4 current points to evaluate the spline 502| 4.50k| const aiVector3D &p0 = in.splineKeys[ClampSpline(idx - 1, size)].mValue; 503| 4.50k| const aiVector3D &p1 = in.splineKeys[ClampSpline(idx + 0, size)].mValue; 504| 4.50k| const aiVector3D &p2 = in.splineKeys[ClampSpline(idx + 1, size)].mValue; 505| 4.50k| const aiVector3D &p3 = in.splineKeys[ClampSpline(idx + 2, size)].mValue; 506| | 507| | // compute polynomials 508| 4.50k| const ai_real u2 = u * u; 509| 4.50k| const ai_real u3 = u2 * 2; 510| | 511| 4.50k| const ai_real h1 = ai_real(2.0) * u3 - ai_real(3.0) * u2 + ai_real(1.0); 512| 4.50k| const ai_real h2 = ai_real(-2.0) * u3 + ai_real(3.0) * u3; 513| 4.50k| const ai_real h3 = u3 - ai_real(2.0) * u3; 514| 4.50k| const ai_real h4 = u3 - u2; 515| | 516| | // compute the spline tangents 517| 4.50k| const aiVector3D t1 = (p2 - p0) * in.tightness; 518| 4.50k| aiVector3D t2 = (p3 - p1) * in.tightness; 519| | 520| | // and use them to get the interpolated point 521| 4.50k| t2 = (h1 * p1 + p2 * h2 + t1 * h3 + h4 * t2); 522| | 523| | // build a simple translation matrix from it 524| 4.50k| key.mValue = t2; 525| 4.50k| key.mTime = (double)i; 526| 4.50k| } 527| 3| } break; 528| 0| default: ------------------ | Branch (528:9): [True: 0, False: 12] ------------------ 529| | // UNKNOWN , OTHER 530| 0| break; 531| 12| }; 532| 12| if (anim) { ------------------ | Branch (532:13): [True: 12, False: 0] ------------------ 533| 12| anims.push_back(anim); 534| 12| ++total; 535| 12| } 536| 12| } 537| 12|} _Z12SetupMappingP10aiMaterial16aiTextureMappingRK10aiVector3tIfE: 541| 13|void SetupMapping(aiMaterial *mat, aiTextureMapping mode, const aiVector3D &axis = aiVector3D(0.f, 0.f, -1.f)) { 542| 13| if (nullptr == mat) { ------------------ | Branch (542:9): [True: 0, False: 13] ------------------ 543| 0| return; 544| 0| } 545| | 546| | // Check whether there are texture properties defined - setup 547| | // the desired texture mapping mode for all of them and ignore 548| | // all UV settings we might encounter. WE HAVE NO UVS! 549| | 550| 13| std::vector p; 551| 13| p.reserve(mat->mNumProperties + 1); 552| | 553| 13| for (unsigned int i = 0; i < mat->mNumProperties; ++i) { ------------------ | Branch (553:30): [True: 0, False: 13] ------------------ 554| 0| aiMaterialProperty *prop = mat->mProperties[i]; 555| 0| if (!::strcmp(prop->mKey.data, "$tex.file")) { ------------------ | Branch (555:13): [True: 0, False: 0] ------------------ 556| | // Setup the mapping key 557| 0| aiMaterialProperty *m = new aiMaterialProperty(); 558| 0| m->mKey.Set("$tex.mapping"); 559| 0| m->mIndex = prop->mIndex; 560| 0| m->mSemantic = prop->mSemantic; 561| 0| m->mType = aiPTI_Integer; 562| | 563| 0| m->mDataLength = 4; 564| 0| m->mData = new char[4]; 565| 0| *((int *)m->mData) = mode; 566| | 567| 0| p.push_back(prop); 568| 0| p.push_back(m); 569| | 570| | // Setup the mapping axis 571| 0| if (mode == aiTextureMapping_CYLINDER || mode == aiTextureMapping_PLANE || mode == aiTextureMapping_SPHERE) { ------------------ | Branch (571:17): [True: 0, False: 0] | Branch (571:54): [True: 0, False: 0] | Branch (571:88): [True: 0, False: 0] ------------------ 572| 0| m = new aiMaterialProperty(); 573| 0| m->mKey.Set("$tex.mapaxis"); 574| 0| m->mIndex = prop->mIndex; 575| 0| m->mSemantic = prop->mSemantic; 576| 0| m->mType = aiPTI_Float; 577| | 578| 0| m->mDataLength = sizeof(aiVector3D); 579| 0| m->mData = new char[m->mDataLength]; 580| 0| *((aiVector3D *)m->mData) = axis; 581| 0| p.push_back(m); 582| 0| } 583| 0| } else if (!::strcmp(prop->mKey.data, "$tex.uvwsrc")) { ------------------ | Branch (583:20): [True: 0, False: 0] ------------------ 584| 0| delete mat->mProperties[i]; 585| 0| } else 586| 0| p.push_back(prop); 587| 0| } 588| | 589| 13| if (p.empty()) return; ------------------ | Branch (589:9): [True: 13, False: 0] ------------------ 590| | 591| | // rebuild the output array 592| 0| if (p.size() > mat->mNumAllocated) { ------------------ | Branch (592:9): [True: 0, False: 0] ------------------ 593| 0| delete[] mat->mProperties; 594| 0| mat->mProperties = new aiMaterialProperty *[p.size() * 2]; 595| | 596| 0| mat->mNumAllocated = static_cast(p.size() * 2); 597| 0| } 598| 0| mat->mNumProperties = (unsigned int)p.size(); 599| 0| ::memcpy(mat->mProperties, &p[0], sizeof(void *) * mat->mNumProperties); 600| 0|} _ZN6Assimp11IRRImporter13GenerateGraphEPNS0_4NodeEP6aiNodeP7aiSceneRNS_11BatchLoaderERNSt3__16vectorIP6aiMeshNS9_9allocatorISC_EEEERNSA_IP10aiNodeAnimNSD_ISI_EEEERNSA_INS_14AttachmentInfoENSD_ISM_EEEERNSA_IP10aiMaterialNSD_ISR_EEEERj: 609| 71| unsigned int &defMatIdx) { 610| 71| unsigned int oldMeshSize = (unsigned int)meshes.size(); 611| | // unsigned int meshTrafoAssign = 0; 612| | 613| | // Now determine the type of the node 614| 71| switch (root->type) { 615| 5| case Node::ANIMMESH: ------------------ | Branch (615:5): [True: 5, False: 66] ------------------ 616| 34| case Node::MESH: { ------------------ | Branch (616:5): [True: 29, False: 42] ------------------ 617| 34| if (!root->meshPath.length()) ------------------ | Branch (617:13): [True: 0, False: 34] ------------------ 618| 0| break; 619| | 620| | // Get the loaded mesh from the scene and add it to 621| | // the list of all scenes to be attached to the 622| | // graph we're currently building 623| 34| aiScene *localScene = batch.GetImport(root->id); 624| 34| if (!localScene) { ------------------ | Branch (624:13): [True: 34, False: 0] ------------------ 625| 34| ASSIMP_LOG_ERROR("IRR: Unable to load external file: ", root->meshPath); 626| 34| break; 627| 34| } 628| 0| attach.emplace_back(localScene, rootOut); 629| | 630| | // Now combine the material we've loaded for this mesh 631| | // with the real materials we got from the file. As we 632| | // don't execute any pp-steps on the file, the numbers 633| | // should be equal. If they are not, we can impossibly 634| | // do this ... 635| 0| if (root->materials.size() != (unsigned int)localScene->mNumMaterials) { ------------------ | Branch (635:13): [True: 0, False: 0] ------------------ 636| 0| ASSIMP_LOG_WARN("IRR: Failed to match imported materials " 637| 0| "with the materials found in the IRR scene file"); 638| | 639| 0| break; 640| 0| } 641| 0| for (unsigned int i = 0; i < localScene->mNumMaterials; ++i) { ------------------ | Branch (641:34): [True: 0, False: 0] ------------------ 642| | // Delete the old material, we don't need it anymore 643| 0| delete localScene->mMaterials[i]; 644| | 645| 0| std::pair &src = root->materials[i]; 646| 0| localScene->mMaterials[i] = src.first; 647| 0| } 648| | 649| | // NOTE: Each mesh should have exactly one material assigned, 650| | // but we do it in a separate loop if this behavior changes 651| | // in future. 652| 0| for (unsigned int i = 0; i < localScene->mNumMeshes; ++i) { ------------------ | Branch (652:34): [True: 0, False: 0] ------------------ 653| | // Process material flags 654| 0| aiMesh *mesh = localScene->mMeshes[i]; 655| | 656| | // If "trans_vertex_alpha" mode is enabled, search all vertex colors 657| | // and check whether they have a common alpha value. This is quite 658| | // often the case so we can simply extract it to a shared oacity 659| | // value. 660| 0| std::pair &src = root->materials[mesh->mMaterialIndex]; 661| 0| aiMaterial *mat = (aiMaterial *)src.first; 662| | 663| 0| if (mesh->HasVertexColors(0) && src.second & AI_IRRMESH_MAT_trans_vertex_alpha) { ------------------ | | 26| 0|#define AI_IRRMESH_MAT_trans_vertex_alpha 0x1 ------------------ | Branch (663:17): [True: 0, False: 0] | Branch (663:45): [True: 0, False: 0] ------------------ 664| 0| bool bdo = true; 665| 0| for (unsigned int a = 1; a < mesh->mNumVertices; ++a) { ------------------ | Branch (665:42): [True: 0, False: 0] ------------------ 666| | 667| 0| if (mesh->mColors[0][a].a != mesh->mColors[0][a - 1].a) { ------------------ | Branch (667:25): [True: 0, False: 0] ------------------ 668| 0| bdo = false; 669| 0| break; 670| 0| } 671| 0| } 672| 0| if (bdo) { ------------------ | Branch (672:21): [True: 0, False: 0] ------------------ 673| 0| ASSIMP_LOG_INFO("IRR: Replacing mesh vertex alpha with common opacity"); 674| | 675| 0| for (unsigned int a = 0; a < mesh->mNumVertices; ++a) ------------------ | Branch (675:46): [True: 0, False: 0] ------------------ 676| 0| mesh->mColors[0][a].a = 1.f; 677| | 678| 0| mat->AddProperty(&mesh->mColors[0][0].a, 1, AI_MATKEY_OPACITY); 679| 0| } 680| 0| } 681| | 682| | // If we have a second texture coordinate set and a second texture 683| | // (either light-map, normal-map, 2layered material) we need to 684| | // setup the correct UV index for it. The texture can either 685| | // be diffuse (light-map & 2layer) or a normal map (normal & parallax) 686| 0| if (mesh->HasTextureCoords(1)) { ------------------ | Branch (686:17): [True: 0, False: 0] ------------------ 687| | 688| 0| int idx = 1; 689| 0| if (src.second & (AI_IRRMESH_MAT_solid_2layer | AI_IRRMESH_MAT_lightmap)) { ------------------ | | 23| 0|#define AI_IRRMESH_MAT_solid_2layer 0x10000 ------------------ if (src.second & (AI_IRRMESH_MAT_solid_2layer | AI_IRRMESH_MAT_lightmap)) { ------------------ | | 30| 0|#define AI_IRRMESH_MAT_lightmap 0x2 ------------------ | Branch (689:21): [True: 0, False: 0] ------------------ 690| 0| mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_DIFFUSE(0)); 691| 0| } else if (src.second & AI_IRRMESH_MAT_normalmap_solid) { ------------------ | | 39| 0|#define AI_IRRMESH_MAT_normalmap_solid (0x100) ------------------ | Branch (691:28): [True: 0, False: 0] ------------------ 692| 0| mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_NORMALS(0)); 693| 0| } 694| 0| } 695| 0| } 696| 0| } break; 697| | 698| 6| case Node::LIGHT: ------------------ | Branch (698:5): [True: 6, False: 65] ------------------ 699| 9| case Node::CAMERA: ------------------ | Branch (699:5): [True: 3, False: 68] ------------------ 700| | 701| | // We're already finished with lights and cameras 702| 9| break; 703| | 704| 6| case Node::SPHERE: { ------------------ | Branch (704:5): [True: 6, False: 65] ------------------ 705| | // Generate the sphere model. Our input parameter to 706| | // the sphere generation algorithm is the number of 707| | // subdivisions of each triangle - but here we have 708| | // the number of polygons on a specific axis. Just 709| | // use some hard-coded limits to approximate this ... 710| 6| unsigned int mul = root->spherePolyCountX * root->spherePolyCountY; 711| 6| if (mul < 100) ------------------ | Branch (711:13): [True: 0, False: 6] ------------------ 712| 0| mul = 2; 713| 6| else if (mul < 300) ------------------ | Branch (713:18): [True: 6, False: 0] ------------------ 714| 6| mul = 3; 715| 0| else 716| 0| mul = 4; 717| | 718| 6| meshes.push_back(StandardShapes::MakeMesh(mul, 719| 6| &StandardShapes::MakeSphere)); 720| | 721| | // Adjust scaling 722| 6| root->scaling *= root->sphereRadius / 2; 723| | 724| | // Copy one output material 725| 6| CopyMaterial(materials, root->materials, defMatIdx, meshes.back()); 726| | 727| | // Now adjust this output material - if there is a first texture 728| | // set, setup spherical UV mapping around the Y axis. 729| 6| SetupMapping((aiMaterial *)materials.back(), aiTextureMapping_SPHERE); 730| 6| } break; 731| | 732| 7| case Node::CUBE: { ------------------ | Branch (732:5): [True: 7, False: 64] ------------------ 733| | // Generate an unit cube first 734| 7| meshes.push_back(StandardShapes::MakeMesh( 735| 7| &StandardShapes::MakeHexahedron)); 736| | 737| | // Adjust scaling 738| 7| root->scaling *= root->sphereRadius; 739| | 740| | // Copy one output material 741| 7| CopyMaterial(materials, root->materials, defMatIdx, meshes.back()); 742| | 743| | // Now adjust this output material - if there is a first texture 744| | // set, setup cubic UV mapping 745| 7| SetupMapping((aiMaterial *)materials.back(), aiTextureMapping_BOX); 746| 7| } break; 747| | 748| 1| case Node::SKYBOX: { ------------------ | Branch (748:5): [True: 1, False: 70] ------------------ 749| | // A sky-box is defined by six materials 750| 1| if (root->materials.size() < 6) { ------------------ | Branch (750:13): [True: 1, False: 0] ------------------ 751| 1| ASSIMP_LOG_ERROR("IRR: There should be six materials for a skybox"); 752| 1| break; 753| 1| } 754| | 755| | // copy those materials and generate 6 meshes for our new sky-box 756| 0| materials.reserve(materials.size() + 6); 757| 0| for (unsigned int i = 0; i < 6; ++i) ------------------ | Branch (757:34): [True: 0, False: 0] ------------------ 758| 0| materials.insert(materials.end(), root->materials[i].first); 759| | 760| 0| BuildSkybox(meshes, materials); 761| | 762| | // ************************************************************* 763| | // Skyboxes will require a different code path for rendering, 764| | // so there must be a way for the user to add special support 765| | // for IRR skyboxes. We add a 'IRR.SkyBox_' prefix to the node. 766| | // ************************************************************* 767| 0| root->name = "IRR.SkyBox_" + root->name; 768| 0| ASSIMP_LOG_INFO("IRR: Loading skybox, this will " 769| 0| "require special handling to be displayed correctly"); 770| 0| } break; 771| | 772| 0| case Node::TERRAIN: { ------------------ | Branch (772:5): [True: 0, False: 71] ------------------ 773| | // to support terrains, we'd need to have a texture decoder 774| 0| ASSIMP_LOG_ERROR("IRR: Unsupported node - TERRAIN"); 775| 0| } break; 776| 14| default: ------------------ | Branch (776:5): [True: 14, False: 57] ------------------ 777| | // DUMMY 778| 14| break; 779| 71| }; 780| | 781| | // Check whether we added a mesh (or more than one ...). In this case 782| | // we'll also need to attach it to the node 783| 71| if (oldMeshSize != (unsigned int)meshes.size()) { ------------------ | Branch (783:9): [True: 13, False: 58] ------------------ 784| | 785| 13| rootOut->mNumMeshes = (unsigned int)meshes.size() - oldMeshSize; 786| 13| rootOut->mMeshes = new unsigned int[rootOut->mNumMeshes]; 787| | 788| 26| for (unsigned int a = 0; a < rootOut->mNumMeshes; ++a) { ------------------ | Branch (788:34): [True: 13, False: 13] ------------------ 789| 13| rootOut->mMeshes[a] = oldMeshSize + a; 790| 13| } 791| 13| } 792| | 793| | // Setup the name of this node 794| 71| rootOut->mName.Set(root->name); 795| | 796| | // Now compute the final local transformation matrix of the 797| | // node from the given translation, rotation and scaling values. 798| | // (the rotation is given in Euler angles, XYZ order) 799| | // std::swap((float&)root->rotation.z,(float&)root->rotation.y); 800| 71| rootOut->mTransformation.FromEulerAnglesXYZ(AI_DEG_TO_RAD(root->rotation)); 801| | 802| | // apply scaling 803| 71| aiMatrix4x4 &mat = rootOut->mTransformation; 804| 71| mat.a1 *= root->scaling.x; 805| 71| mat.b1 *= root->scaling.x; 806| 71| mat.c1 *= root->scaling.x; 807| 71| mat.a2 *= root->scaling.y; 808| 71| mat.b2 *= root->scaling.y; 809| 71| mat.c2 *= root->scaling.y; 810| 71| mat.a3 *= root->scaling.z; 811| 71| mat.b3 *= root->scaling.z; 812| 71| mat.c3 *= root->scaling.z; 813| | 814| | // apply translation 815| 71| mat.a4 += root->position.x; 816| 71| mat.b4 += root->position.y; 817| 71| mat.c4 += root->position.z; 818| | 819| | // now compute animations for the node 820| 71| ComputeAnimations(root, rootOut, anims); 821| | 822| | // Add all children recursively. First allocate enough storage 823| | // for them, then call us again 824| 71| rootOut->mNumChildren = (unsigned int)root->children.size(); 825| 71| if (rootOut->mNumChildren) { ------------------ | Branch (825:9): [True: 14, False: 57] ------------------ 826| | 827| 14| rootOut->mChildren = new aiNode *[rootOut->mNumChildren]; 828| 77| for (unsigned int i = 0; i < rootOut->mNumChildren; ++i) { ------------------ | Branch (828:34): [True: 63, False: 14] ------------------ 829| | 830| 63| aiNode *node = rootOut->mChildren[i] = new aiNode(); 831| 63| node->mParent = rootOut; 832| 63| GenerateGraph(root->children[i], node, scene, batch, meshes, 833| 63| anims, attach, materials, defMatIdx); 834| 63| } 835| 14| } 836| 71|} _ZN6Assimp11IRRImporter19ParseNodeAttributesERN4pugi8xml_nodeEPNS0_4NodeERNS_11BatchLoaderE: 838| 63|void IRRImporter::ParseNodeAttributes(pugi::xml_node &attributesNode, IRRImporter::Node *nd, BatchLoader &batch) { 839| 63| ai_assert(!ASSIMP_stricmp(attributesNode.name(), "attributes")); // Node must be 840| 63| ai_assert(nd != nullptr); // dude 841| | 842| | // Big switch statement that tests for various tags inside 843| | // and applies them to nd 844| | // I don't believe nodes have boolean attributes 845| 729| for (pugi::xml_node &attribute : attributesNode.children()) { ------------------ | Branch (845:36): [True: 729, False: 63] ------------------ 846| 729| if (attribute.type() != pugi::node_element) continue; ------------------ | Branch (846:13): [True: 0, False: 729] ------------------ 847| 729| if (!ASSIMP_stricmp(attribute.name(), "vector3d")) { // ------------------ | Branch (847:13): [True: 196, False: 533] ------------------ 848| 196| VectorProperty prop; 849| 196| ReadVectorProperty(prop, attribute); 850| 196| if (prop.name == "Position") { ------------------ | Branch (850:17): [True: 63, False: 133] ------------------ 851| 63| nd->position = prop.value; 852| 133| } else if (prop.name == "Rotation") { ------------------ | Branch (852:24): [True: 63, False: 70] ------------------ 853| 63| nd->rotation = prop.value; 854| 70| } else if (prop.name == "Scale") { ------------------ | Branch (854:24): [True: 63, False: 7] ------------------ 855| 63| nd->scaling = prop.value; 856| 63| } else if (Node::CAMERA == nd->type) { ------------------ | Branch (856:24): [True: 6, False: 1] ------------------ 857| 6| aiCamera *cam = cameras.back(); 858| 6| if (prop.name == "Target") { ------------------ | Branch (858:21): [True: 3, False: 3] ------------------ 859| 3| cam->mLookAt = prop.value; 860| 3| } else if (prop.name == "UpVector") { ------------------ | Branch (860:28): [True: 3, False: 0] ------------------ 861| 3| cam->mUp = prop.value; 862| 3| } 863| 6| } 864| 533| } else if (!ASSIMP_stricmp(attribute.name(), "float")) { // ------------------ | Branch (864:20): [True: 38, False: 495] ------------------ 865| 38| FloatProperty prop; 866| 38| ReadFloatProperty(prop, attribute); 867| 38| if (prop.name == "FramesPerSecond" && Node::ANIMMESH == nd->type) { ------------------ | Branch (867:17): [True: 7, False: 31] | Branch (867:51): [True: 5, False: 2] ------------------ 868| 5| nd->framesPerSecond = prop.value; 869| 33| } else if (Node::CAMERA == nd->type) { ------------------ | Branch (869:24): [True: 12, False: 21] ------------------ 870| | /* This is the vertical, not the horizontal FOV. 871| | * We need to compute the right FOV from the 872| | * screen aspect which we don't know yet. 873| | */ 874| 12| if (prop.name == "Fovy") { ------------------ | Branch (874:21): [True: 3, False: 9] ------------------ 875| 3| cameras.back()->mHorizontalFOV = prop.value; 876| 9| } else if (prop.name == "Aspect") { ------------------ | Branch (876:28): [True: 3, False: 6] ------------------ 877| 3| cameras.back()->mAspect = prop.value; 878| 6| } else if (prop.name == "ZNear") { ------------------ | Branch (878:28): [True: 3, False: 3] ------------------ 879| 3| cameras.back()->mClipPlaneNear = prop.value; 880| 3| } else if (prop.name == "ZFar") { ------------------ | Branch (880:28): [True: 3, False: 0] ------------------ 881| 3| cameras.back()->mClipPlaneFar = prop.value; 882| 3| } 883| 21| } else if (Node::LIGHT == nd->type) { ------------------ | Branch (883:24): [True: 6, False: 15] ------------------ 884| | /* Additional light information 885| | */ 886| 6| if (prop.name == "Attenuation") { ------------------ | Branch (886:21): [True: 0, False: 6] ------------------ 887| 0| lights.back()->mAttenuationLinear = prop.value; 888| 6| } else if (prop.name == "OuterCone") { ------------------ | Branch (888:28): [True: 0, False: 6] ------------------ 889| 0| lights.back()->mAngleOuterCone = AI_DEG_TO_RAD(prop.value); 890| 6| } else if (prop.name == "InnerCone") { ------------------ | Branch (890:28): [True: 0, False: 6] ------------------ 891| 0| lights.back()->mAngleInnerCone = AI_DEG_TO_RAD(prop.value); 892| 0| } 893| 6| } 894| | // radius of the sphere to be generated - 895| | // or alternatively, size of the cube 896| 15| else if ((Node::SPHERE == nd->type && prop.name == "Radius") || ------------------ | Branch (896:23): [True: 6, False: 9] | Branch (896:51): [True: 6, False: 0] ------------------ 897| 13| (Node::CUBE == nd->type && prop.name == "Size")) { ------------------ | Branch (897:23): [True: 7, False: 2] | Branch (897:49): [True: 7, False: 0] ------------------ 898| 13| nd->sphereRadius = prop.value; 899| 13| } 900| 495| } else if (!ASSIMP_stricmp(attribute.name(), "int")) { // ------------------ | Branch (900:20): [True: 138, False: 357] ------------------ 901| | // Only sphere nodes make use of integer attributes 902| 138| if (Node::SPHERE == nd->type) { ------------------ | Branch (902:17): [True: 24, False: 114] ------------------ 903| 24| IntProperty prop; 904| 24| ReadIntProperty(prop, attribute); 905| 24| if (prop.name == "PolyCountX") { ------------------ | Branch (905:21): [True: 6, False: 18] ------------------ 906| 6| nd->spherePolyCountX = prop.value; 907| 18| } else if (prop.name == "PolyCountY") { ------------------ | Branch (907:28): [True: 6, False: 12] ------------------ 908| 6| nd->spherePolyCountY = prop.value; 909| 6| } 910| 24| } 911| 357| } else if (!ASSIMP_stricmp(attribute.name(), "string") || !ASSIMP_stricmp(attribute.name(), "enum")) { // or < enum /> ------------------ | Branch (911:20): [True: 97, False: 260] | Branch (911:67): [True: 69, False: 191] ------------------ 912| 166| StringProperty prop; 913| 166| ReadStringProperty(prop, attribute); 914| 166| if (prop.value.length() == 0) continue; // skip empty strings ------------------ | Branch (914:17): [True: 37, False: 129] ------------------ 915| 129| if (prop.name == "Name") { ------------------ | Branch (915:17): [True: 26, False: 103] ------------------ 916| 26| nd->name = prop.value; 917| | 918| | /* If we're either a camera or a light source 919| | * we need to update the name in the aiLight/ 920| | * aiCamera structure, too. 921| | */ 922| 26| if (Node::CAMERA == nd->type) { ------------------ | Branch (922:21): [True: 0, False: 26] ------------------ 923| 0| cameras.back()->mName.Set(prop.value); 924| 26| } else if (Node::LIGHT == nd->type) { ------------------ | Branch (924:28): [True: 6, False: 20] ------------------ 925| 6| lights.back()->mName.Set(prop.value); 926| 6| } 927| 103| } else if (Node::LIGHT == nd->type && "LightType" == prop.name) { ------------------ | Branch (927:24): [True: 12, False: 91] | Branch (927:51): [True: 6, False: 6] ------------------ 928| 6| if (prop.value == "Spot") ------------------ | Branch (928:21): [True: 3, False: 3] ------------------ 929| 3| lights.back()->mType = aiLightSource_SPOT; 930| 3| else if (prop.value == "Point") ------------------ | Branch (930:26): [True: 3, False: 0] ------------------ 931| 3| lights.back()->mType = aiLightSource_POINT; 932| 0| else if (prop.value == "Directional") ------------------ | Branch (932:26): [True: 0, False: 0] ------------------ 933| 0| lights.back()->mType = aiLightSource_DIRECTIONAL; 934| 0| else { 935| | // We won't pass the validation with aiLightSourceType_UNDEFINED, 936| | // so we remove the light and replace it with a silly dummy node 937| 0| delete lights.back(); 938| 0| lights.pop_back(); 939| 0| nd->type = Node::DUMMY; 940| | 941| 0| ASSIMP_LOG_ERROR("Ignoring light of unknown type: ", prop.value); 942| 0| } 943| 97| } else if ((prop.name == "Mesh" && Node::MESH == nd->type) || ------------------ | Branch (943:25): [True: 34, False: 63] | Branch (943:48): [True: 29, False: 5] ------------------ 944| 68| Node::ANIMMESH == nd->type) { ------------------ | Branch (944:24): [True: 10, False: 58] ------------------ 945| | /* This is the file name of the mesh - either 946| | * animated or not. We need to make sure we setup 947| | * the correct post-processing settings here. 948| | */ 949| 39| unsigned int pp = 0; 950| 39| BatchLoader::PropertyMap map; 951| | 952| | /* If the mesh is a static one remove all animations from the impor data 953| | */ 954| 39| if (Node::ANIMMESH != nd->type) { ------------------ | Branch (954:21): [True: 29, False: 10] ------------------ 955| 29| pp |= aiProcess_RemoveComponent; 956| 29| SetGenericProperty(map.ints, AI_CONFIG_PP_RVC_FLAGS, 957| 29| aiComponent_ANIMATIONS | aiComponent_BONEWEIGHTS); 958| 29| } 959| | 960| | /* TODO: maybe implement the protection against recursive 961| | * loading calls directly in BatchLoader? The current 962| | * implementation is not absolutely safe. A LWS and an IRR 963| | * file referencing each other *could* cause the system to 964| | * recurse forever. 965| | */ 966| | 967| 39| const std::string extension = GetExtension(prop.value); 968| 39| if ("irr" == extension) { ------------------ | Branch (968:21): [True: 0, False: 39] ------------------ 969| 0| ASSIMP_LOG_ERROR("IRR: Can't load another IRR file recursively"); 970| 39| } else { 971| 39| nd->id = batch.AddLoadRequest(prop.value, pp, &map); 972| 39| nd->meshPath = prop.value; 973| 39| } 974| 39| } 975| 129| } 976| 729| } 977| 63|} _ZN6Assimp11IRRImporter14ParseAnimatorsERN4pugi8xml_nodeEPNS0_4NodeE: 979| 12|void IRRImporter::ParseAnimators(pugi::xml_node &animatorNode, IRRImporter::Node *nd) { 980| 12| Animator *curAnim = nullptr; 981| | // Make empty animator 982| 12| nd->animators.emplace_back(); 983| 12| curAnim = &nd->animators.back(); // Push it back 984| 12| pugi::xml_node attributes = animatorNode.child("attributes"); 985| 12| if (!attributes) { ------------------ | Branch (985:9): [True: 0, False: 12] ------------------ 986| 0| ASSIMP_LOG_WARN("Animator node does not contain attributes. "); 987| 0| return; 988| 0| } 989| | 990| 48| for (pugi::xml_node attrib : attributes.children()) { ------------------ | Branch (990:32): [True: 48, False: 12] ------------------ 991| | // XML may contain useless noes like CDATA 992| 48| if (!ASSIMP_stricmp(attrib.name(), "vector3d")) { ------------------ | Branch (992:13): [True: 24, False: 24] ------------------ 993| 24| VectorProperty prop; 994| 24| ReadVectorProperty(prop, attrib); 995| | 996| 24| if (curAnim->type == Animator::ROTATION && prop.name == "Rotation") { ------------------ | Branch (996:17): [True: 6, False: 18] | Branch (996:56): [True: 6, False: 0] ------------------ 997| | // We store the rotation euler angles in 'direction' 998| 6| curAnim->direction = prop.value; 999| 18| } else if (curAnim->type == Animator::FOLLOW_SPLINE) { ------------------ | Branch (999:24): [True: 12, False: 6] ------------------ 1000| | // Check whether the vector follows the PointN naming scheme, 1001| | // here N is the ONE-based index of the point 1002| 12| if (prop.name.length() >= 6 && prop.name.substr(0, 5) == "Point") { ------------------ | Branch (1002:21): [True: 12, False: 0] | Branch (1002:21): [True: 12, False: 0] | Branch (1002:48): [True: 12, False: 0] ------------------ 1003| | // Add a new key to the list 1004| 12| curAnim->splineKeys.emplace_back(); 1005| 12| aiVectorKey &key = curAnim->splineKeys.back(); 1006| | 1007| | // and parse its properties 1008| 12| key.mValue = prop.value; 1009| 12| key.mTime = strtoul10(&prop.name[5]); 1010| 12| } 1011| 12| } else if (curAnim->type == Animator::FLY_CIRCLE) { ------------------ | Branch (1011:24): [True: 6, False: 0] ------------------ 1012| 6| if (prop.name == "Center") { ------------------ | Branch (1012:21): [True: 3, False: 3] ------------------ 1013| 3| curAnim->circleCenter = prop.value; 1014| 3| } else if (prop.name == "Direction") { ------------------ | Branch (1014:28): [True: 3, False: 0] ------------------ 1015| 3| curAnim->direction = prop.value; 1016| | 1017| | // From Irrlicht's source - a workaround for backward compatibility with Irrlicht 1.1 1018| 3| if (curAnim->direction == aiVector3D()) { ------------------ | Branch (1018:25): [True: 0, False: 3] ------------------ 1019| 0| curAnim->direction = aiVector3D(0.f, 1.f, 0.f); 1020| 0| } else 1021| 3| curAnim->direction.Normalize(); 1022| 3| } 1023| 6| } else if (curAnim->type == Animator::FLY_STRAIGHT) { ------------------ | Branch (1023:24): [True: 0, False: 0] ------------------ 1024| 0| if (prop.name == "Start") { ------------------ | Branch (1024:21): [True: 0, False: 0] ------------------ 1025| | // We reuse the field here 1026| 0| curAnim->circleCenter = prop.value; 1027| 0| } else if (prop.name == "End") { ------------------ | Branch (1027:28): [True: 0, False: 0] ------------------ 1028| | // We reuse the field here 1029| 0| curAnim->direction = prop.value; 1030| 0| } 1031| 0| } 1032| | 1033| | //} else if (!ASSIMP_stricmp(reader->getNodeName(), "bool")) { 1034| 24| } else if (!ASSIMP_stricmp(attrib.name(), "bool")) { ------------------ | Branch (1034:20): [True: 0, False: 24] ------------------ 1035| 0| BoolProperty prop; 1036| 0| ReadBoolProperty(prop, attrib); 1037| | 1038| 0| if (curAnim->type == Animator::FLY_CIRCLE && prop.name == "Loop") { ------------------ | Branch (1038:17): [True: 0, False: 0] | Branch (1038:58): [True: 0, False: 0] ------------------ 1039| 0| curAnim->loop = prop.value; 1040| 0| } 1041| | //} else if (!ASSIMP_stricmp(reader->getNodeName(), "float")) { 1042| 24| } else if (!ASSIMP_stricmp(attrib.name(), "float")) { ------------------ | Branch (1042:20): [True: 12, False: 12] ------------------ 1043| 12| FloatProperty prop; 1044| 12| ReadFloatProperty(prop, attrib); 1045| | 1046| | // The speed property exists for several animators 1047| 12| if (prop.name == "Speed") { ------------------ | Branch (1047:17): [True: 6, False: 6] ------------------ 1048| 6| curAnim->speed = prop.value; 1049| 6| } else if (curAnim->type == Animator::FLY_CIRCLE && prop.name == "Radius") { ------------------ | Branch (1049:24): [True: 3, False: 3] | Branch (1049:65): [True: 3, False: 0] ------------------ 1050| 3| curAnim->circleRadius = prop.value; 1051| 3| } else if (curAnim->type == Animator::FOLLOW_SPLINE && prop.name == "Tightness") { ------------------ | Branch (1051:24): [True: 3, False: 0] | Branch (1051:68): [True: 3, False: 0] ------------------ 1052| 3| curAnim->tightness = prop.value; 1053| 3| } 1054| | //} else if (!ASSIMP_stricmp(reader->getNodeName(), "int")) { 1055| 12| } else if (!ASSIMP_stricmp(attrib.name(), "int")) { ------------------ | Branch (1055:20): [True: 0, False: 12] ------------------ 1056| 0| IntProperty prop; 1057| 0| ReadIntProperty(prop, attrib); 1058| | 1059| 0| if (curAnim->type == Animator::FLY_STRAIGHT && prop.name == "TimeForWay") { ------------------ | Branch (1059:17): [True: 0, False: 0] | Branch (1059:60): [True: 0, False: 0] ------------------ 1060| 0| curAnim->timeForWay = prop.value; 1061| 0| } 1062| | //} else if (!ASSIMP_stricmp(reader->getNodeName(), "string") || !ASSIMP_stricmp(reader->getNodeName(), "enum")) { 1063| 12| } else if (!ASSIMP_stricmp(attrib.name(), "string") || !ASSIMP_stricmp(attrib.name(), "enum")) { ------------------ | Branch (1063:20): [True: 12, False: 0] | Branch (1063:64): [True: 0, False: 0] ------------------ 1064| 12| StringProperty prop; 1065| 12| ReadStringProperty(prop, attrib); 1066| | 1067| 12| if (prop.name == "Type") { ------------------ | Branch (1067:17): [True: 12, False: 0] ------------------ 1068| | // type of the animator 1069| 12| if (prop.value == "rotation") { ------------------ | Branch (1069:21): [True: 6, False: 6] ------------------ 1070| 6| curAnim->type = Animator::ROTATION; 1071| 6| } else if (prop.value == "flyCircle") { ------------------ | Branch (1071:28): [True: 3, False: 3] ------------------ 1072| 3| curAnim->type = Animator::FLY_CIRCLE; 1073| 3| } else if (prop.value == "flyStraight") { ------------------ | Branch (1073:28): [True: 0, False: 3] ------------------ 1074| 0| curAnim->type = Animator::FLY_CIRCLE; 1075| 3| } else if (prop.value == "followSpline") { ------------------ | Branch (1075:28): [True: 3, False: 0] ------------------ 1076| 3| curAnim->type = Animator::FOLLOW_SPLINE; 1077| 3| } else { 1078| 0| ASSIMP_LOG_WARN("IRR: Ignoring unknown animator: ", prop.value); 1079| | 1080| 0| curAnim->type = Animator::UNKNOWN; 1081| 0| } 1082| 12| } 1083| 12| } 1084| 48| } 1085| 12|} _ZN6Assimp11IRRImporter9ParseNodeERN4pugi8xml_nodeERNS_11BatchLoaderE: 1087| 63|IRRImporter::Node *IRRImporter::ParseNode(pugi::xml_node &node, BatchLoader &batch) { 1088| | // Parse tags. 1089| | // tags have various types 1090| | // tags can contain , 1091| | // they can also contain other tags, (and can reference other files as well?) 1092| | // *********************************************************************** 1093| | /* What we're going to do with the node depends 1094| | * on its type: 1095| | * 1096| | * "mesh" - Load a mesh from an external file 1097| | * "cube" - Generate a cube 1098| | * "skybox" - Generate a skybox 1099| | * "light" - A light source 1100| | * "sphere" - Generate a sphere mesh 1101| | * "animatedMesh" - Load an animated mesh from an external file 1102| | * and join its animation channels with ours. 1103| | * "empty" - A dummy node 1104| | * "camera" - A camera 1105| | * "terrain" - a terrain node (data comes from a heightmap) 1106| | * "billboard", "" 1107| | * 1108| | * Each of these nodes can be animated and all can have multiple 1109| | * materials assigned (except lights, cameras and dummies, of course). 1110| | * Said materials and animators are all collected at the bottom 1111| | */ 1112| | // *********************************************************************** 1113| 63| Node *nd; 1114| 63| pugi::xml_attribute nodeTypeAttrib = node.attribute("type"); 1115| 63| if (!ASSIMP_stricmp(nodeTypeAttrib.value(), "mesh") || !ASSIMP_stricmp(nodeTypeAttrib.value(), "octTree")) { ------------------ | Branch (1115:9): [True: 29, False: 34] | Branch (1115:60): [True: 0, False: 34] ------------------ 1116| | // OctTree's and meshes are treated equally 1117| 29| nd = new Node(Node::MESH); 1118| 34| } else if (!ASSIMP_stricmp(nodeTypeAttrib.value(), "cube")) { ------------------ | Branch (1118:16): [True: 7, False: 27] ------------------ 1119| 7| nd = new Node(Node::CUBE); 1120| 7| guessedMeshCnt += 1; // Cube is only one mesh 1121| 27| } else if (!ASSIMP_stricmp(nodeTypeAttrib.value(), "skybox")) { ------------------ | Branch (1121:16): [True: 1, False: 26] ------------------ 1122| 1| nd = new Node(Node::SKYBOX); 1123| 1| guessedMeshCnt += 6; // Skybox is a box, with 6 meshes? 1124| 26| } else if (!ASSIMP_stricmp(nodeTypeAttrib.value(), "camera")) { ------------------ | Branch (1124:16): [True: 3, False: 23] ------------------ 1125| 3| nd = new Node(Node::CAMERA); 1126| | // Setup a temporary name for the camera 1127| 3| aiCamera *cam = new aiCamera(); 1128| 3| cam->mName.Set(nd->name); 1129| 3| cameras.push_back(cam); 1130| 23| } else if (!ASSIMP_stricmp(nodeTypeAttrib.value(), "light")) { ------------------ | Branch (1130:16): [True: 6, False: 17] ------------------ 1131| 6| nd = new Node(Node::LIGHT); 1132| | // Setup a temporary name for the light 1133| 6| aiLight *cam = new aiLight(); 1134| 6| cam->mName.Set(nd->name); 1135| 6| lights.push_back(cam); 1136| 17| } else if (!ASSIMP_stricmp(nodeTypeAttrib.value(), "sphere")) { ------------------ | Branch (1136:16): [True: 6, False: 11] ------------------ 1137| 6| nd = new Node(Node::SPHERE); 1138| 6| guessedMeshCnt += 1; 1139| 11| } else if (!ASSIMP_stricmp(nodeTypeAttrib.value(), "animatedMesh")) { ------------------ | Branch (1139:16): [True: 5, False: 6] ------------------ 1140| 5| nd = new Node(Node::ANIMMESH); 1141| 6| } else if (!ASSIMP_stricmp(nodeTypeAttrib.value(), "empty")) { ------------------ | Branch (1141:16): [True: 6, False: 0] ------------------ 1142| 6| nd = new Node(Node::DUMMY); 1143| 6| } else if (!ASSIMP_stricmp(nodeTypeAttrib.value(), "terrain")) { ------------------ | Branch (1143:16): [True: 0, False: 0] ------------------ 1144| 0| nd = new Node(Node::TERRAIN); 1145| 0| } else if (!ASSIMP_stricmp(nodeTypeAttrib.value(), "billBoard")) { ------------------ | Branch (1145:16): [True: 0, False: 0] ------------------ 1146| | // We don't support billboards, so ignore them 1147| 0| ASSIMP_LOG_ERROR("IRR: Billboards are not supported by Assimp"); 1148| 0| nd = new Node(Node::DUMMY); 1149| 0| } else { 1150| 0| ASSIMP_LOG_WARN("IRR: Found unknown node: ", nodeTypeAttrib.value()); 1151| | 1152| | /* We skip the contents of nodes we don't know. 1153| | * We parse the transformation and all animators 1154| | * and skip the rest. 1155| | */ 1156| 0| nd = new Node(Node::DUMMY); 1157| 0| } 1158| | 1159| | // TODO: consolidate all into one loop 1160| 147| for (pugi::xml_node subNode : node.children()) { ------------------ | Branch (1160:33): [True: 147, False: 63] ------------------ 1161| | // Collect node attributes first 1162| 147| if (!ASSIMP_stricmp(subNode.name(), "attributes")) { ------------------ | Branch (1162:13): [True: 63, False: 84] ------------------ 1163| 63| ParseNodeAttributes(subNode, nd, batch); // Parse attributes into this node 1164| 84| } else if (!ASSIMP_stricmp(subNode.name(), "animators")) { ------------------ | Branch (1164:20): [True: 12, False: 72] ------------------ 1165| | // Then parse any animators 1166| | // All animators should contain an tag 1167| | 1168| | // This is an animation path - add a new animator 1169| | // to the list. 1170| 12| ParseAnimators(subNode, nd); // Function modifies nd's animator vector 1171| 12| guessedAnimCnt += 1; 1172| 12| } 1173| | 1174| | // Then parse any materials 1175| | // Materials are available to almost all node types 1176| 147| if (nd->type != Node::DUMMY) { ------------------ | Branch (1176:13): [True: 138, False: 9] ------------------ 1177| 138| if (!ASSIMP_stricmp(subNode.name(), "materials")) { ------------------ | Branch (1177:17): [True: 48, False: 90] ------------------ 1178| | // Parse material description directly 1179| | // Each material should contain an node 1180| | // with everything specified 1181| 48| nd->materials.emplace_back(); 1182| 48| std::pair &p = nd->materials.back(); 1183| 48| p.first = ParseMaterial(subNode, p.second); 1184| 48| guessedMatCnt += 1; 1185| 48| } 1186| 138| } 1187| 147| } 1188| | 1189| | // Then parse any child nodes 1190| | // Attach the newly created node to the scene-graph 1191| 147| for (pugi::xml_node child : node.children()) { ------------------ | Branch (1191:31): [True: 147, False: 63] ------------------ 1192| 147| if (!ASSIMP_stricmp(child.name(), "node")) { // Is a child node ------------------ | Branch (1192:13): [True: 6, False: 141] ------------------ 1193| 6| Node *childNd = ParseNode(child, batch); // Repeat this function for all children 1194| 6| nd->children.push_back(childNd); 1195| 6| }; 1196| 147| } 1197| | 1198| | // Return fully specified node 1199| 63| return nd; 1200| 63|} _ZN6Assimp11IRRImporter14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 1204| 11|void IRRImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { 1205| 11| std::unique_ptr file(pIOHandler->Open(pFile)); 1206| | // Check whether we can read from the file 1207| 11| if (file == nullptr) { ------------------ | Branch (1207:9): [True: 0, False: 11] ------------------ 1208| 0| throw DeadlyImportError("Failed to open IRR file ", pFile); 1209| 0| } 1210| | 1211| | // Construct the irrXML parser 1212| 11| XmlParser st; 1213| 11| if (!st.parse(file.get())) { ------------------ | Branch (1213:9): [True: 3, False: 8] ------------------ 1214| 3| throw DeadlyImportError("XML parse error while loading IRR file ", pFile); 1215| 3| } 1216| 8| pugi::xml_node documentRoot = st.getRootNode(); 1217| | 1218| | // The root node of the scene 1219| 8| Node *root = new Node(Node::DUMMY); 1220| 8| root->parent = nullptr; 1221| 8| root->name = ""; 1222| | 1223| | // Batch loader used to load external models 1224| 8| BatchLoader batch(pIOHandler); 1225| | // batch.SetBasePath(pFile); 1226| | 1227| 8| cameras.reserve(1); // Probably only one camera in entire scene 1228| 8| lights.reserve(5); 1229| | 1230| 8| this->guessedAnimCnt = 0; 1231| 8| this->guessedMeshCnt = 0; 1232| 8| this->guessedMatCnt = 0; 1233| | 1234| | // Parse the XML 1235| | // Find the scene root from document root. 1236| 8| const pugi::xml_node &sceneRoot = documentRoot.child("irr_scene"); 1237| 8| if (!sceneRoot) { ------------------ | Branch (1237:9): [True: 0, False: 8] ------------------ 1238| 0| delete root; 1239| 0| throw new DeadlyImportError("IRR: not found in file"); 1240| 0| } 1241| 65| for (pugi::xml_node &child : sceneRoot.children()) { ------------------ | Branch (1241:32): [True: 65, False: 8] ------------------ 1242| | // XML elements are either nodes, animators, attributes, or materials 1243| 65| if (!ASSIMP_stricmp(child.name(), "node")) { ------------------ | Branch (1243:13): [True: 57, False: 8] ------------------ 1244| | // Recursive collect subtree children 1245| 57| Node *nd = ParseNode(child, batch); 1246| | // Attach to root 1247| 57| root->children.push_back(nd); 1248| 57| } 1249| 65| } 1250| | 1251| | // Now iterate through all cameras and compute their final (horizontal) FOV 1252| 8| for (aiCamera *cam : cameras) { ------------------ | Branch (1252:24): [True: 3, False: 8] ------------------ 1253| | // screen aspect could be missing 1254| 3| if (cam->mAspect) { ------------------ | Branch (1254:13): [True: 3, False: 0] ------------------ 1255| 3| cam->mHorizontalFOV *= cam->mAspect; 1256| 3| } else { 1257| 0| ASSIMP_LOG_WARN("IRR: Camera aspect is not given, can't compute horizontal FOV"); 1258| 0| } 1259| 3| } 1260| | 1261| 8| batch.LoadAll(); 1262| | 1263| | // Allocate a temporary scene data structure 1264| 8| aiScene *tempScene = new aiScene(); 1265| 8| tempScene->mRootNode = new aiNode(); 1266| 8| tempScene->mRootNode->mName.Set(""); 1267| | 1268| | // Copy the cameras to the output array 1269| 8| if (!cameras.empty()) { ------------------ | Branch (1269:9): [True: 3, False: 5] ------------------ 1270| 3| tempScene->mNumCameras = (unsigned int)cameras.size(); 1271| 3| tempScene->mCameras = new aiCamera *[tempScene->mNumCameras]; 1272| 3| ::memcpy(tempScene->mCameras, &cameras[0], sizeof(void *) * tempScene->mNumCameras); 1273| 3| } 1274| | 1275| | // Copy the light sources to the output array 1276| 8| if (!lights.empty()) { ------------------ | Branch (1276:9): [True: 3, False: 5] ------------------ 1277| 3| tempScene->mNumLights = (unsigned int)lights.size(); 1278| 3| tempScene->mLights = new aiLight *[tempScene->mNumLights]; 1279| 3| ::memcpy(tempScene->mLights, &lights[0], sizeof(void *) * tempScene->mNumLights); 1280| 3| } 1281| | 1282| | // temporary data 1283| 8| std::vector anims; 1284| 8| std::vector materials; 1285| 8| std::vector attach; 1286| 8| std::vector meshes; 1287| | 1288| | // try to guess how much storage we'll need 1289| 8| anims.reserve(guessedAnimCnt + (guessedAnimCnt >> 2)); 1290| 8| meshes.reserve(guessedMeshCnt + (guessedMeshCnt >> 2)); 1291| 8| materials.reserve(guessedMatCnt + (guessedMatCnt >> 2)); 1292| | 1293| | // Now process our scene-graph recursively: generate final 1294| | // meshes and generate animation channels for all nodes. 1295| 8| unsigned int defMatIdx = UINT_MAX; 1296| 8| GenerateGraph(root, tempScene->mRootNode, tempScene, 1297| 8| batch, meshes, anims, attach, materials, defMatIdx); 1298| | 1299| 8| if (!anims.empty()) { ------------------ | Branch (1299:9): [True: 3, False: 5] ------------------ 1300| 3| tempScene->mNumAnimations = 1; 1301| 3| tempScene->mAnimations = new aiAnimation *[tempScene->mNumAnimations]; 1302| 3| aiAnimation *an = tempScene->mAnimations[0] = new aiAnimation(); 1303| | 1304| | // *********************************************************** 1305| | // This is only the global animation channel of the scene. 1306| | // If there are animated models, they will have separate 1307| | // animation channels in the scene. To display IRR scenes 1308| | // correctly, users will need to combine the global anim 1309| | // channel with all the local animations they want to play 1310| | // *********************************************************** 1311| 3| an->mName.Set("Irr_GlobalAnimChannel"); 1312| | 1313| | // copy all node animation channels to the global channel 1314| 3| an->mNumChannels = (unsigned int)anims.size(); 1315| 3| an->mChannels = new aiNodeAnim *[an->mNumChannels]; 1316| 3| ::memcpy(an->mChannels, &anims[0], sizeof(void *) * an->mNumChannels); 1317| 3| } 1318| 8| if (!meshes.empty()) { ------------------ | Branch (1318:9): [True: 4, False: 4] ------------------ 1319| | // copy all meshes to the temporary scene 1320| 4| tempScene->mNumMeshes = (unsigned int)meshes.size(); 1321| 4| tempScene->mMeshes = new aiMesh *[tempScene->mNumMeshes]; 1322| 4| ::memcpy(tempScene->mMeshes, &meshes[0], tempScene->mNumMeshes * sizeof(void *)); 1323| 4| } 1324| | 1325| | // Copy all materials to the output array 1326| 8| if (!materials.empty()) { ------------------ | Branch (1326:9): [True: 4, False: 4] ------------------ 1327| 4| tempScene->mNumMaterials = (unsigned int)materials.size(); 1328| 4| tempScene->mMaterials = new aiMaterial *[tempScene->mNumMaterials]; 1329| 4| ::memcpy(tempScene->mMaterials, &materials[0], sizeof(void *) * tempScene->mNumMaterials); 1330| 4| } 1331| | 1332| | // Now merge all sub scenes and attach them to the correct 1333| | // attachment points in the scenegraph. 1334| 8| SceneCombiner::MergeScenes(&pScene, tempScene, attach, 1335| 8| AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES | (!configSpeedFlag ? (AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY | AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES) : ------------------ | Branch (1335:52): [True: 8, False: 0] ------------------ 1336| 8| 0)); 1337| | 1338| | // If we have no meshes | no materials now set the INCOMPLETE 1339| | // scene flag. This is necessary if we failed to load all 1340| | // models from external files 1341| 8| if (!pScene->mNumMeshes || !pScene->mNumMaterials) { ------------------ | Branch (1341:9): [True: 4, False: 4] | Branch (1341:32): [True: 0, False: 4] ------------------ 1342| 4| ASSIMP_LOG_WARN("IRR: No meshes loaded, setting AI_SCENE_FLAGS_INCOMPLETE"); 1343| 4| pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; 1344| 4| } 1345| | 1346| | // Finished ... everything destructs automatically and all 1347| | // temporary scenes have already been deleted by MergeScenes() 1348| 8| delete root; 1349| 8|} _Z20FindSuitableMultipleRi: 268| 12|inline void FindSuitableMultiple(int &angle) { 269| 12| if (angle < 3) ------------------ | Branch (269:9): [True: 0, False: 12] ------------------ 270| 0| angle = 3; 271| 12| else if (angle < 10) ------------------ | Branch (271:14): [True: 0, False: 12] ------------------ 272| 0| angle = 10; 273| 12| else if (angle < 20) ------------------ | Branch (273:14): [True: 0, False: 12] ------------------ 274| 0| angle = 20; 275| 12| else if (angle < 30) ------------------ | Branch (275:14): [True: 2, False: 10] ------------------ 276| 2| angle = 30; 277| 12|} _Z11ClampSplineii: 263| 18.0k|inline int ClampSpline(int idx, int size) { 264| 18.0k| return (idx < 0 ? size + idx : (idx >= size ? idx - size : idx)); ------------------ | Branch (264:13): [True: 3.00k, False: 15.0k] | Branch (264:37): [True: 0, False: 15.0k] ------------------ 265| 18.0k|} _ZN6Assimp11IRRImporter8AnimatorC2ENS1_2ATE: 98| 12| type(t), speed(ai_real(0.001)), direction(ai_real(0.0), ai_real(1.0), ai_real(0.0)), circleRadius(ai_real(1.0)), tightness(ai_real(0.5)), loop(true), timeForWay(100) { 99| 12| } _ZN6Assimp11IRRImporter4NodeC2ENS1_2ETE: 138| 71| type(t), scaling(1.0, 1.0, 1.0) // assume uniform scaling by default 139| | , 140| | parent(), 141| 71| framesPerSecond(0.0), 142| | id(), 143| 71| sphereRadius(1.0), 144| 71| spherePolyCountX(100), 145| 71| spherePolyCountY(100) { 146| | 147| | // Generate a default name for the node 148| 71| char buffer[128]; 149| 71| static int cnt; 150| 71| ai_snprintf(buffer, 128, "IrrNode_%i", cnt++); 151| 71| name = std::string(buffer); 152| | 153| | // reserve space for up to 5 materials 154| 71| materials.reserve(5); 155| | 156| | // reserve space for up to 5 children 157| 71| children.reserve(5); 158| 71| } _ZNK6Assimp15IRRMeshImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 74| 347|bool IRRMeshImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 75| | /* NOTE: A simple check for the file extension is not enough 76| | * here. Irrmesh and irr are easy, but xml is too generic 77| | * and could be collada, too. So we need to open the file and 78| | * search for typical tokens. 79| | */ 80| 347| static const char *tokens[] = { "irrmesh" }; 81| | return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); 82| 347|} _ZNK6Assimp15IRRMeshImporter7GetInfoEv: 86| 641|const aiImporterDesc *IRRMeshImporter::GetInfo() const { 87| 641| return &desc; 88| 641|} _ZN6Assimp15IRRMeshImporter14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 107| 7| aiScene *pScene, IOSystem *pIOHandler) { 108| 7| std::unique_ptr file(pIOHandler->Open(pFile)); 109| | 110| | // Check whether we can read from the file 111| 7| if (file == nullptr) { ------------------ | Branch (111:9): [True: 0, False: 7] ------------------ 112| 0| throw DeadlyImportError("Failed to open IRRMESH file ", pFile); 113| 0| } 114| | 115| | // Construct the irrXML parser 116| 7| XmlParser parser; 117| 7| if (!parser.parse(file.get())) { ------------------ | Branch (117:9): [True: 1, False: 6] ------------------ 118| 1| throw DeadlyImportError("XML parse error while loading IRRMESH file ", pFile); 119| 1| } 120| 6| XmlNode root = parser.getRootNode(); 121| | 122| | // final data 123| 6| std::vector materials; 124| 6| std::vector meshes; 125| 6| materials.reserve(5); 126| 6| meshes.reserve(5); 127| | 128| | // temporary data - current mesh buffer 129| | // TODO move all these to inside loop 130| 6| aiMaterial *curMat = nullptr; 131| 6| aiMesh *curMesh = nullptr; 132| 6| unsigned int curMatFlags = 0; 133| | 134| 6| std::vector curVertices, curNormals, curTangents, curBitangents; 135| 6| std::vector curColors; 136| 6| std::vector curUVs, curUV2s; 137| | 138| | // some temporary variables 139| | // textMeaning is a 15 year old variable, that could've been an enum 140| | // int textMeaning = 0; // 0=none? 1=vertices 2=indices 141| | // int vertexFormat = 0; // 0 = normal; 1 = 2 tcoords, 2 = tangents 142| 6| bool useColors = false; 143| | 144| | // irrmesh files have a top level owning multiple nodes. 145| | // Each contains , , and 146| | // tags here directly owns the material data specs 147| | // are a vertex per line, contains position, UV1 coords, maybe UV2, normal, tangent, bitangent 148| | // is ignored, I think assimp recalculates those? 149| | 150| | // Parse the XML file 151| 6| pugi::xml_node const &meshNode = root.child("mesh"); 152| 33| for (pugi::xml_node bufferNode : meshNode.children()) { ------------------ | Branch (152:36): [True: 33, False: 6] ------------------ 153| 33| if (ASSIMP_stricmp(bufferNode.name(), "buffer")) { ------------------ | Branch (153:13): [True: 12, False: 21] ------------------ 154| | // Might be a useless warning 155| 12| ASSIMP_LOG_WARN("IRRMESH: Ignoring non buffer node <", bufferNode.name(), "> in mesh declaration"); 156| 12| continue; 157| 12| } 158| | 159| 21| curMat = nullptr; 160| 21| curMesh = nullptr; 161| | 162| 21| curVertices.clear(); 163| 21| curColors.clear(); 164| 21| curNormals.clear(); 165| 21| curUV2s.clear(); 166| 21| curUVs.clear(); 167| 21| curTangents.clear(); 168| 21| curBitangents.clear(); 169| | 170| | // TODO ensure all three nodes are present and populated 171| | // before allocating everything 172| | 173| | // Get first material node 174| 21| pugi::xml_node materialNode = bufferNode.child("material"); 175| 21| if (materialNode) { ------------------ | Branch (175:13): [True: 21, False: 0] ------------------ 176| 21| curMat = ParseMaterial(materialNode, curMatFlags); 177| | // Warn if there's more materials 178| 21| if (materialNode.next_sibling("material")) { ------------------ | Branch (178:17): [True: 0, False: 21] ------------------ 179| 0| ASSIMP_LOG_WARN("IRRMESH: Only one material description per buffer, please"); 180| 0| } 181| 21| } else { 182| 0| ASSIMP_LOG_ERROR("IRRMESH: Buffer must contain one material"); 183| 0| continue; 184| 0| } 185| | 186| | // Get first vertices node 187| 21| pugi::xml_node verticesNode = bufferNode.child("vertices"); 188| 21| if (verticesNode) { ------------------ | Branch (188:13): [True: 21, False: 0] ------------------ 189| 21| pugi::xml_attribute vertexCountAttrib = verticesNode.attribute("vertexCount"); 190| 21| int vertexCount = vertexCountAttrib.as_int(); 191| 21| if (vertexCount == 0) { ------------------ | Branch (191:17): [True: 0, False: 21] ------------------ 192| | // This is possible ... remove the mesh from the list and skip further reading 193| 0| ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero vertices"); 194| 0| releaseMaterial(&curMat); 195| 0| continue; // Bail out early 196| 21| }; 197| | 198| 21| curVertices.reserve(vertexCount); 199| 21| curNormals.reserve(vertexCount); 200| 21| curColors.reserve(vertexCount); 201| 21| curUVs.reserve(vertexCount); 202| | 203| 21| VertexFormat vertexFormat; 204| | // Determine the file format 205| 21| pugi::xml_attribute typeAttrib = verticesNode.attribute("type"); 206| 21| if (!ASSIMP_stricmp("2tcoords", typeAttrib.value())) { ------------------ | Branch (206:17): [True: 3, False: 18] ------------------ 207| 3| curUV2s.reserve(vertexCount); 208| 3| vertexFormat = VertexFormat::t2coord; 209| 3| if (curMatFlags & AI_IRRMESH_EXTRA_2ND_TEXTURE) { ------------------ | | 51| 3|#define AI_IRRMESH_EXTRA_2ND_TEXTURE 0x100000 ------------------ | Branch (209:21): [True: 3, False: 0] ------------------ 210| | // ********************************************************* 211| | // We have a second texture! So use this UV channel 212| | // for it. The 2nd texture can be either a normal 213| | // texture (solid_2layer or lightmap_xxx) or a normal 214| | // map (normal_..., parallax_...) 215| | // ********************************************************* 216| 3| int idx = 1; 217| 3| aiMaterial *mat = (aiMaterial *)curMat; 218| | 219| 3| if (curMatFlags & AI_IRRMESH_MAT_lightmap) { ------------------ | | 30| 3|#define AI_IRRMESH_MAT_lightmap 0x2 ------------------ | Branch (219:25): [True: 3, False: 0] ------------------ 220| 3| mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_LIGHTMAP(0)); 221| 3| } else if (curMatFlags & AI_IRRMESH_MAT_normalmap_solid) { ------------------ | | 39| 0|#define AI_IRRMESH_MAT_normalmap_solid (0x100) ------------------ | Branch (221:32): [True: 0, False: 0] ------------------ 222| 0| mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_NORMALS(0)); 223| 0| } else if (curMatFlags & AI_IRRMESH_MAT_solid_2layer) { ------------------ | | 23| 0|#define AI_IRRMESH_MAT_solid_2layer 0x10000 ------------------ | Branch (223:32): [True: 0, False: 0] ------------------ 224| 0| mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_DIFFUSE(1)); 225| 0| } 226| 3| } 227| 18| } else if (!ASSIMP_stricmp("tangents", typeAttrib.value())) { ------------------ | Branch (227:24): [True: 0, False: 18] ------------------ 228| 0| curTangents.reserve(vertexCount); 229| 0| curBitangents.reserve(vertexCount); 230| 0| vertexFormat = VertexFormat::tangent; 231| 18| } else if (!ASSIMP_stricmp("standard", typeAttrib.value())) { ------------------ | Branch (231:24): [True: 18, False: 0] ------------------ 232| 18| vertexFormat = VertexFormat::standard; 233| 18| } else { 234| | // Unsupported format, discard whole buffer/mesh 235| | // Assuming we have a correct material, then release it 236| | // We don't have a correct mesh for sure here 237| 0| releaseMaterial(&curMat); 238| 0| ASSIMP_LOG_ERROR("IRRMESH: Unknown vertex format"); 239| 0| continue; // Skip rest of buffer 240| 21| }; 241| | 242| | // We know what format buffer is, collect numbers 243| 21| std::string v = verticesNode.text().get(); 244| 21| const char *end = v.c_str() + v.size(); 245| 21| ParseBufferVertices(v.c_str(), end, vertexFormat, 246| 21| curVertices, curNormals, 247| 21| curTangents, curBitangents, 248| 21| curUVs, curUV2s, curColors, useColors); 249| 21| } 250| | 251| | // Get indices 252| | // At this point we have some vertices and a valid material 253| | // Collect indices and create aiMesh at the same time 254| 21| pugi::xml_node indicesNode = bufferNode.child("indices"); 255| 21| if (indicesNode) { ------------------ | Branch (255:13): [True: 20, False: 1] ------------------ 256| | // start a new mesh 257| 20| curMesh = new aiMesh(); 258| | 259| | // allocate storage for all faces 260| 20| pugi::xml_attribute attr = indicesNode.attribute("indexCount"); 261| 20| curMesh->mNumVertices = attr.as_int(); 262| 20| if (!curMesh->mNumVertices) { ------------------ | Branch (262:17): [True: 0, False: 20] ------------------ 263| | // This is possible ... remove the mesh from the list and skip further reading 264| 0| ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero indices"); 265| | 266| | // mesh - away 267| 0| releaseMesh(&curMesh); 268| | 269| | // material - away 270| 0| releaseMaterial(&curMat); 271| 0| continue; // Go to next buffer 272| 0| } 273| | 274| 20| if (curMesh->mNumVertices % 3) { ------------------ | Branch (274:17): [True: 0, False: 20] ------------------ 275| 0| ASSIMP_LOG_WARN("IRRMESH: Number if indices isn't divisible by 3"); 276| 0| } 277| | 278| 20| curMesh->mNumFaces = curMesh->mNumVertices / 3; 279| 20| curMesh->mFaces = new aiFace[curMesh->mNumFaces]; 280| | 281| | // setup some members 282| 20| curMesh->mMaterialIndex = (unsigned int)materials.size(); 283| 20| curMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; 284| | 285| | // allocate storage for all vertices 286| 20| curMesh->mVertices = new aiVector3D[curMesh->mNumVertices]; 287| | 288| 20| if (curNormals.size() == curVertices.size()) { ------------------ | Branch (288:17): [True: 20, False: 0] ------------------ 289| 20| curMesh->mNormals = new aiVector3D[curMesh->mNumVertices]; 290| 20| } 291| 20| if (curTangents.size() == curVertices.size()) { ------------------ | Branch (291:17): [True: 0, False: 20] ------------------ 292| 0| curMesh->mTangents = new aiVector3D[curMesh->mNumVertices]; 293| 0| } 294| 20| if (curBitangents.size() == curVertices.size()) { ------------------ | Branch (294:17): [True: 0, False: 20] ------------------ 295| 0| curMesh->mBitangents = new aiVector3D[curMesh->mNumVertices]; 296| 0| } 297| 20| if (curColors.size() == curVertices.size() && useColors) { ------------------ | Branch (297:17): [True: 20, False: 0] | Branch (297:59): [True: 0, False: 20] ------------------ 298| 0| curMesh->mColors[0] = new aiColor4D[curMesh->mNumVertices]; 299| 0| } 300| 20| if (curUVs.size() == curVertices.size()) { ------------------ | Branch (300:17): [True: 20, False: 0] ------------------ 301| 20| curMesh->mTextureCoords[0] = new aiVector3D[curMesh->mNumVertices]; 302| 20| } 303| 20| if (curUV2s.size() == curVertices.size()) { ------------------ | Branch (303:17): [True: 2, False: 18] ------------------ 304| 2| curMesh->mTextureCoords[1] = new aiVector3D[curMesh->mNumVertices]; 305| 2| } 306| | 307| | // read indices 308| 20| aiFace *curFace = curMesh->mFaces; 309| 20| aiFace *const faceEnd = curMesh->mFaces + curMesh->mNumFaces; 310| | 311| 20| aiVector3D *pcV = curMesh->mVertices; 312| 20| aiVector3D *pcN = curMesh->mNormals; 313| 20| aiVector3D *pcT = curMesh->mTangents; 314| 20| aiVector3D *pcB = curMesh->mBitangents; 315| 20| aiColor4D *pcC0 = curMesh->mColors[0]; 316| 20| aiVector3D *pcT0 = curMesh->mTextureCoords[0]; 317| 20| aiVector3D *pcT1 = curMesh->mTextureCoords[1]; 318| | 319| 20| unsigned int curIdx = 0; 320| 20| unsigned int total = 0; 321| | 322| | // NOTE this might explode for UTF-16 and wchars 323| 20| const char *sz = indicesNode.text().get(); 324| 20| const char *end = sz + std::strlen(sz); 325| | 326| | // For each index loop over aiMesh faces 327| 9.40k| while (SkipSpacesAndLineEnd(&sz, end)) { ------------------ | Branch (327:20): [True: 9.38k, False: 20] ------------------ 328| 9.38k| if (curFace >= faceEnd) { ------------------ | Branch (328:21): [True: 0, False: 9.38k] ------------------ 329| 0| ASSIMP_LOG_ERROR("IRRMESH: Too many indices"); 330| 0| break; 331| 0| } 332| | // if new face 333| 9.38k| if (!curIdx) { ------------------ | Branch (333:21): [True: 3.12k, False: 6.25k] ------------------ 334| 3.12k| curFace->mNumIndices = 3; 335| 3.12k| curFace->mIndices = new unsigned int[3]; 336| 3.12k| } 337| | 338| | // Read index base 10 339| | // function advances the pointer 340| 9.38k| unsigned int idx = strtoul10(sz, &sz); 341| 9.38k| if (idx >= curVertices.size()) { ------------------ | Branch (341:21): [True: 0, False: 9.38k] ------------------ 342| 0| ASSIMP_LOG_ERROR("IRRMESH: Index out of range"); 343| 0| idx = 0; 344| 0| } 345| | 346| | // make up our own indices? 347| 9.38k| curFace->mIndices[curIdx] = total++; 348| | 349| | // Copy over data to aiMesh 350| 9.38k| *pcV++ = curVertices[idx]; 351| 9.38k| if (pcN) ------------------ | Branch (351:21): [True: 9.38k, False: 0] ------------------ 352| 9.38k| *pcN++ = curNormals[idx]; 353| 9.38k| if (pcT) ------------------ | Branch (353:21): [True: 0, False: 9.38k] ------------------ 354| 0| *pcT++ = curTangents[idx]; 355| 9.38k| if (pcB) ------------------ | Branch (355:21): [True: 0, False: 9.38k] ------------------ 356| 0| *pcB++ = curBitangents[idx]; 357| 9.38k| if (pcC0) ------------------ | Branch (357:21): [True: 0, False: 9.38k] ------------------ 358| 0| *pcC0++ = curColors[idx]; 359| 9.38k| if (pcT0) ------------------ | Branch (359:21): [True: 9.38k, False: 0] ------------------ 360| 9.38k| *pcT0++ = curUVs[idx]; 361| 9.38k| if (pcT1) ------------------ | Branch (361:21): [True: 816, False: 8.56k] ------------------ 362| 816| *pcT1++ = curUV2s[idx]; 363| | 364| | // start new face 365| 9.38k| if (++curIdx == 3) { ------------------ | Branch (365:21): [True: 3.12k, False: 6.25k] ------------------ 366| 3.12k| ++curFace; 367| 3.12k| curIdx = 0; 368| 3.12k| } 369| 9.38k| } 370| | // We should be at the end of mFaces 371| 20| if (curFace != faceEnd) { ------------------ | Branch (371:17): [True: 0, False: 20] ------------------ 372| 0| ASSIMP_LOG_ERROR("IRRMESH: Not enough indices"); 373| 0| } 374| 20| } 375| | 376| | // Finish processing the mesh - do some small material workarounds 377| 21| if (curMatFlags & AI_IRRMESH_MAT_trans_vertex_alpha && !useColors) { ------------------ | | 26| 42|#define AI_IRRMESH_MAT_trans_vertex_alpha 0x1 ------------------ | Branch (377:13): [True: 2, False: 19] | Branch (377:64): [True: 2, False: 0] ------------------ 378| | // Take the opacity value of the current material 379| | // from the common vertex color alpha 380| 2| aiMaterial *mat = (aiMaterial *)curMat; 381| 2| mat->AddProperty(&curColors[0].a, 1, AI_MATKEY_OPACITY); 382| 2| } 383| | 384| | // end of previous buffer. A material and a mesh should be there 385| 21| if (!curMat || !curMesh) { ------------------ | Branch (385:13): [True: 1, False: 20] | Branch (385:24): [True: 0, False: 20] ------------------ 386| 0| ASSIMP_LOG_ERROR("IRRMESH: A buffer must contain a mesh and a material"); 387| 0| releaseMaterial(&curMat); 388| 0| releaseMesh(&curMesh); 389| 21| } else { 390| 21| materials.push_back(curMat); 391| 21| meshes.push_back(curMesh); 392| 21| } 393| 21| } 394| | 395| | // If one is empty then so is the other 396| 6| if (materials.empty() || meshes.empty()) { ------------------ | Branch (396:9): [True: 1, False: 5] | Branch (396:30): [True: 0, False: 5] ------------------ 397| 0| throw DeadlyImportError("IRRMESH: Unable to read a mesh from this file"); 398| 0| } 399| | 400| | // now generate the output scene 401| 6| pScene->mNumMeshes = (unsigned int)meshes.size(); 402| 6| pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]; 403| 26| for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) { ------------------ | Branch (403:30): [True: 20, False: 6] ------------------ 404| 20| pScene->mMeshes[i] = meshes[i]; 405| | 406| | // clean this value ... 407| 20| pScene->mMeshes[i]->mNumUVComponents[3] = 0; 408| 20| } 409| | 410| 6| pScene->mNumMaterials = (unsigned int)materials.size(); 411| 6| pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials]; 412| 6| ::memcpy(pScene->mMaterials, &materials[0], sizeof(void *) * pScene->mNumMaterials); 413| | 414| 6| pScene->mRootNode = new aiNode(); 415| 6| pScene->mRootNode->mName.Set(""); 416| 6| pScene->mRootNode->mNumMeshes = pScene->mNumMeshes; 417| 6| pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes]; 418| | 419| 26| for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) { ------------------ | Branch (419:30): [True: 20, False: 6] ------------------ 420| 20| pScene->mRootNode->mMeshes[i] = i; 421| 20| }; 422| 6|} _ZN6Assimp15IRRMeshImporter19ParseBufferVerticesEPKcS2_NS0_12VertexFormatERNSt3__16vectorI10aiVector3tIfENS4_9allocatorIS7_EEEESB_SB_SB_SB_SB_RNS5_I9aiColor4tIfENS8_ISD_EEEERb: 428| 21| std::vector &colors, bool &useColors) { 429| | // read vertices 430| 4.07k| do { 431| 4.07k| SkipSpacesAndLineEnd(&sz, end); 432| 4.07k| aiVector3D temp; 433| 4.07k| aiColor4D c; 434| | 435| | // Read the vertex position 436| 4.07k| sz = fast_atoreal_move(sz, temp.x); 437| 4.07k| SkipSpaces(&sz, end); 438| | 439| 4.07k| sz = fast_atoreal_move(sz, temp.y); 440| 4.07k| SkipSpaces(&sz, end); 441| | 442| 4.07k| sz = fast_atoreal_move(sz, temp.z); 443| 4.07k| SkipSpaces(&sz, end); 444| 4.07k| vertices.push_back(temp); 445| | 446| | // Read the vertex normals 447| 4.07k| sz = fast_atoreal_move(sz, temp.x); 448| 4.07k| SkipSpaces(&sz, end); 449| | 450| 4.07k| sz = fast_atoreal_move(sz, temp.y); 451| 4.07k| SkipSpaces(&sz, end); 452| | 453| 4.07k| sz = fast_atoreal_move(sz, temp.z); 454| 4.07k| SkipSpaces(&sz, end); 455| 4.07k| normals.push_back(temp); 456| | 457| | // read the vertex colors 458| 4.07k| uint32_t clr = strtoul16(sz, &sz); 459| 4.07k| ColorFromARGBPacked(clr, c); 460| | 461| | // If we're pushing more than one distinct color 462| 4.07k| if (!colors.empty() && c != *(colors.end() - 1)) ------------------ | Branch (462:13): [True: 4.04k, False: 22] | Branch (462:13): [True: 0, False: 4.07k] | Branch (462:32): [True: 0, False: 4.04k] ------------------ 463| 0| useColors = true; 464| | 465| 4.07k| colors.push_back(c); 466| 4.07k| SkipSpaces(&sz, end); 467| | 468| | // read the first UV coordinate set 469| 4.07k| sz = fast_atoreal_move(sz, temp.x); 470| 4.07k| SkipSpaces(&sz, end); 471| | 472| 4.07k| sz = fast_atoreal_move(sz, temp.y); 473| 4.07k| SkipSpaces(&sz, end); 474| 4.07k| temp.z = 0.f; 475| 4.07k| temp.y = 1.f - temp.y; // DX to OGL 476| 4.07k| UVs.push_back(temp); 477| | 478| | // NOTE these correspond to specific S3DVertex* structs in irr sourcecode 479| | // So by definition, all buffers have either UV2 or tangents or neither 480| | // read the (optional) second UV coordinate set 481| 4.07k| if (vertexFormat == VertexFormat::t2coord) { ------------------ | Branch (481:13): [True: 919, False: 3.15k] ------------------ 482| 919| sz = fast_atoreal_move(sz, temp.x); 483| 919| SkipSpaces(&sz, end); 484| | 485| 919| sz = fast_atoreal_move(sz, temp.y); 486| 919| temp.y = 1.f - temp.y; // DX to OGL 487| 919| UV2s.push_back(temp); 488| 919| } 489| | // read optional tangent and bitangent vectors 490| 3.15k| else if (vertexFormat == VertexFormat::tangent) { ------------------ | Branch (490:18): [True: 0, False: 3.15k] ------------------ 491| | // tangents 492| 0| sz = fast_atoreal_move(sz, temp.x); 493| 0| SkipSpaces(&sz, end); 494| | 495| 0| sz = fast_atoreal_move(sz, temp.z); 496| 0| SkipSpaces(&sz, end); 497| | 498| 0| sz = fast_atoreal_move(sz, temp.y); 499| 0| SkipSpaces(&sz, end); 500| 0| temp.y *= -1.0f; 501| 0| tangents.push_back(temp); 502| | 503| | // bitangents 504| 0| sz = fast_atoreal_move(sz, temp.x); 505| 0| SkipSpaces(&sz, end); 506| | 507| 0| sz = fast_atoreal_move(sz, temp.z); 508| 0| SkipSpaces(&sz, end); 509| | 510| 0| sz = fast_atoreal_move(sz, temp.y); 511| 0| SkipSpaces(&sz, end); 512| 0| temp.y *= -1.0f; 513| 0| bitangents.push_back(temp); 514| 0| } 515| 4.07k| } while (SkipLine(&sz, end)); ------------------ | Branch (515:14): [True: 4.04k, False: 21] ------------------ 516| | // IMPORTANT: We assume that each vertex is specified in one 517| | // line. So we can skip the rest of the line - unknown vertex 518| | // elements are ignored. 519| 21|} _ZN6Assimp15IRRMeshImporterC2Ev: 66| 624| IRRMeshImporter() = default; _ZN6Assimp15IRRMeshImporterD2Ev: 69| 624| ~IRRMeshImporter() override = default; _ZN6Assimp12IrrlichtBase15ReadHexPropertyERNS0_8PropertyIjEERN4pugi8xml_nodeE: 66| 84|void IrrlichtBase::ReadHexProperty(HexProperty &out, pugi::xml_node& hexnode) { 67| 168| for (pugi::xml_attribute attrib : hexnode.attributes()) { ------------------ | Branch (67:37): [True: 168, False: 84] ------------------ 68| 168| if (!ASSIMP_stricmp(attrib.name(), "name")) { ------------------ | Branch (68:13): [True: 84, False: 84] ------------------ 69| 84| out.name = std::string(attrib.value()); 70| 84| } else if (!ASSIMP_stricmp(attrib.name(), "value")) { ------------------ | Branch (70:20): [True: 84, False: 0] ------------------ 71| | // parse the hexadecimal value 72| 84| out.value = strtoul16(attrib.value()); 73| 84| } 74| 168| } 75| 84|} _ZN6Assimp12IrrlichtBase15ReadIntPropertyERNS0_8PropertyIiEERN4pugi8xml_nodeE: 79| 24|void IrrlichtBase::ReadIntProperty(IntProperty &out, pugi::xml_node& intnode) { 80| 48| for (pugi::xml_attribute attrib : intnode.attributes()) { ------------------ | Branch (80:37): [True: 48, False: 24] ------------------ 81| 48| if (!ASSIMP_stricmp(attrib.name(), "name")) { ------------------ | Branch (81:13): [True: 24, False: 24] ------------------ 82| 24| out.name = std::string(attrib.value()); 83| 24| } else if (!ASSIMP_stricmp(attrib.name(), "value")) { ------------------ | Branch (83:20): [True: 24, False: 0] ------------------ 84| | // parse the int value 85| 24| out.value = strtol10(attrib.value()); 86| 24| } 87| 48| } 88| 24|} _ZN6Assimp12IrrlichtBase18ReadStringPropertyERNS0_8PropertyINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEEERN4pugi8xml_nodeE: 92| 367|void IrrlichtBase::ReadStringProperty(StringProperty &out, pugi::xml_node& stringnode) { 93| 734| for (pugi::xml_attribute attrib : stringnode.attributes()) { ------------------ | Branch (93:37): [True: 734, False: 367] ------------------ 94| 734| if (!ASSIMP_stricmp(attrib.name(), "name")) { ------------------ | Branch (94:13): [True: 367, False: 367] ------------------ 95| 367| out.name = std::string(attrib.value()); 96| 367| } else if (!ASSIMP_stricmp(attrib.name(), "value")) { ------------------ | Branch (96:20): [True: 367, False: 0] ------------------ 97| | // simple copy the string 98| 367| out.value = std::string(attrib.value()); 99| 367| } 100| 734| } 101| 367|} _ZN6Assimp12IrrlichtBase16ReadBoolPropertyERNS0_8PropertyIbEERN4pugi8xml_nodeE: 105| 399|void IrrlichtBase::ReadBoolProperty(BoolProperty &out, pugi::xml_node& boolnode) { 106| 798| for (pugi::xml_attribute attrib : boolnode.attributes()) { ------------------ | Branch (106:37): [True: 798, False: 399] ------------------ 107| 798| if (!ASSIMP_stricmp(attrib.name(), "name")) { ------------------ | Branch (107:13): [True: 399, False: 399] ------------------ 108| 399| out.name = std::string(attrib.value()); 109| 399| } else if (!ASSIMP_stricmp(attrib.name(), "value")) { ------------------ | Branch (109:20): [True: 399, False: 0] ------------------ 110| | // true or false, case insensitive 111| 399| out.value = (ASSIMP_stricmp(attrib.value(), "true") ? false : true); ------------------ | Branch (111:26): [True: 234, False: 165] ------------------ 112| 399| } 113| 798| } 114| 399|} _ZN6Assimp12IrrlichtBase17ReadFloatPropertyERNS0_8PropertyIfEERN4pugi8xml_nodeE: 118| 113|void IrrlichtBase::ReadFloatProperty(FloatProperty &out, pugi::xml_node &floatnode) { 119| 226| for (pugi::xml_attribute attrib : floatnode.attributes()) { ------------------ | Branch (119:37): [True: 226, False: 113] ------------------ 120| 226| if (!ASSIMP_stricmp(attrib.name(), "name")) { ------------------ | Branch (120:13): [True: 113, False: 113] ------------------ 121| 113| out.name = std::string(attrib.value()); 122| 113| } else if (!ASSIMP_stricmp(attrib.name(), "value")) { ------------------ | Branch (122:20): [True: 113, False: 0] ------------------ 123| | // just parse the float 124| 113| out.value = fast_atof(attrib.value()); 125| 113| } 126| 226| } 127| 113|} _ZN6Assimp12IrrlichtBase18ReadVectorPropertyERNS0_8PropertyI10aiVector3tIfEEERN4pugi8xml_nodeE: 131| 220|void IrrlichtBase::ReadVectorProperty(VectorProperty &out, pugi::xml_node& vectornode) { 132| 438| for (pugi::xml_attribute attrib : vectornode.attributes()) { ------------------ | Branch (132:37): [True: 438, False: 220] ------------------ 133| 438| if (!ASSIMP_stricmp(attrib.name(), "name")) { ------------------ | Branch (133:13): [True: 219, False: 219] ------------------ 134| 219| out.name = std::string(attrib.value()); 135| 219| } else if (!ASSIMP_stricmp(attrib.name(), "value")) { ------------------ | Branch (135:20): [True: 219, False: 0] ------------------ 136| | // three floats, separated with commas 137| 219| const char *ptr = attrib.value(); 138| 219| size_t len = std::strlen(ptr); 139| 219| const char *end = ptr + len; 140| | 141| 219| SkipSpaces(&ptr, end); 142| 219| ptr = fast_atoreal_move(ptr, out.value.x); 143| 219| SkipSpaces(&ptr, end); 144| 219| if (',' != *ptr) { ------------------ | Branch (144:17): [True: 0, False: 219] ------------------ 145| 0| ASSIMP_LOG_ERROR("IRR(MESH): Expected comma in vector definition"); 146| 219| } else { 147| 219| SkipSpaces(ptr + 1, &ptr, end); 148| 219| } 149| 219| ptr = fast_atoreal_move(ptr, out.value.y); 150| 219| SkipSpaces(&ptr, end); 151| 219| if (',' != *ptr) { ------------------ | Branch (151:17): [True: 0, False: 219] ------------------ 152| 0| ASSIMP_LOG_ERROR("IRR(MESH): Expected comma in vector definition"); 153| 219| } else { 154| 219| SkipSpaces(ptr + 1, &ptr, end); 155| 219| } 156| 219| ptr = fast_atoreal_move(ptr, out.value.z); 157| 219| } 158| 438| } 159| 220|} _Z18ConvertMappingModeRKNSt3__112basic_stringIcNS_11char_traitsIcEENS_9allocatorIcEEEE: 163| 24|int ConvertMappingMode(const std::string &mode) { 164| 24| if (mode == "texture_clamp_repeat") { ------------------ | Branch (164:9): [True: 24, False: 0] ------------------ 165| 24| return aiTextureMapMode_Wrap; 166| 24| } else if (mode == "texture_clamp_mirror") { ------------------ | Branch (166:16): [True: 0, False: 0] ------------------ 167| 0| return aiTextureMapMode_Mirror; 168| 0| } 169| | 170| 0| return aiTextureMapMode_Clamp; 171| 24|} _ZN6Assimp12IrrlichtBase13ParseMaterialERN4pugi8xml_nodeERj: 175| 69|aiMaterial *IrrlichtBase::ParseMaterial(pugi::xml_node& materialNode, unsigned int &matFlags) { 176| 69| aiMaterial *mat = new aiMaterial(); 177| 69| aiColor4D clr; 178| 69| aiString s; 179| | 180| 69| matFlags = 0; // zero output flags 181| 69| int cnt = 0; // number of used texture channels 182| 69| unsigned int nd = 0; 183| | 184| 871| for (pugi::xml_node child : materialNode.children()) { ------------------ | Branch (184:31): [True: 871, False: 69] ------------------ 185| 871| if (!ASSIMP_stricmp(child.name(), "color")) { // Hex properties ------------------ | Branch (185:13): [True: 84, False: 787] ------------------ 186| 84| HexProperty prop; 187| 84| ReadHexProperty(prop, child); 188| 84| if (prop.name == "Diffuse") { ------------------ | Branch (188:17): [True: 21, False: 63] ------------------ 189| 21| ColorFromARGBPacked(prop.value, clr); 190| 21| mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE); 191| 63| } else if (prop.name == "Ambient") { ------------------ | Branch (191:24): [True: 21, False: 42] ------------------ 192| 21| ColorFromARGBPacked(prop.value, clr); 193| 21| mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_AMBIENT); 194| 42| } else if (prop.name == "Specular") { ------------------ | Branch (194:24): [True: 21, False: 21] ------------------ 195| 21| ColorFromARGBPacked(prop.value, clr); 196| 21| mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_SPECULAR); 197| 21| } 198| | 199| | // NOTE: The 'emissive' property causes problems. It is 200| | // often != 0, even if there is obviously no light 201| | // emitted by the described surface. In fact I think 202| | // IRRLICHT ignores this property, too. 203| |#if 0 204| | else if (prop.name == "Emissive") { 205| | ColorFromARGBPacked(prop.value,clr); 206| | mat->AddProperty(&clr,1,AI_MATKEY_COLOR_EMISSIVE); 207| | } 208| |#endif 209| 787| } else if (!ASSIMP_stricmp(child.name(), "float")) { // Float properties ------------------ | Branch (209:20): [True: 63, False: 724] ------------------ 210| 63| FloatProperty prop; 211| 63| ReadFloatProperty(prop, child); 212| 63| if (prop.name == "Shininess") { ------------------ | Branch (212:17): [True: 21, False: 42] ------------------ 213| 21| mat->AddProperty(&prop.value, 1, AI_MATKEY_SHININESS); 214| 21| } 215| 724| } else if (!ASSIMP_stricmp(child.name(), "bool")) { // Bool properties ------------------ | Branch (215:20): [True: 399, False: 325] ------------------ 216| 399| BoolProperty prop; 217| 399| ReadBoolProperty(prop, child); 218| 399| if (prop.name == "Wireframe") { ------------------ | Branch (218:17): [True: 21, False: 378] ------------------ 219| 21| int val = (prop.value ? true : false); ------------------ | Branch (219:28): [True: 0, False: 21] ------------------ 220| 21| mat->AddProperty(&val, 1, AI_MATKEY_ENABLE_WIREFRAME); 221| 378| } else if (prop.name == "GouraudShading") { ------------------ | Branch (221:24): [True: 21, False: 357] ------------------ 222| 21| int val = (prop.value ? aiShadingMode_Gouraud : aiShadingMode_NoShading); ------------------ | Branch (222:28): [True: 21, False: 0] ------------------ 223| 21| mat->AddProperty(&val, 1, AI_MATKEY_SHADING_MODEL); 224| 357| } else if (prop.name == "BackfaceCulling") { ------------------ | Branch (224:24): [True: 21, False: 336] ------------------ 225| 21| int val = (!prop.value); 226| 21| mat->AddProperty(&val, 1, AI_MATKEY_TWOSIDED); 227| 21| } 228| 399| } else if (!ASSIMP_stricmp(child.name(), "texture") || ------------------ | Branch (228:20): [True: 84, False: 241] ------------------ 229| 241| !ASSIMP_stricmp(child.name(), "enum")) { // String properties - textures and texture related properties ------------------ | Branch (229:20): [True: 105, False: 136] ------------------ 230| 189| StringProperty prop; 231| 189| ReadStringProperty(prop, child); 232| 189| if (prop.value.length()) { ------------------ | Branch (232:17): [True: 129, False: 60] ------------------ 233| | // material type (shader) 234| 129| if (prop.name == "Type") { ------------------ | Branch (234:21): [True: 21, False: 108] ------------------ 235| 21| if (prop.value == "solid") { ------------------ | Branch (235:25): [True: 16, False: 5] ------------------ 236| | // default material ... 237| 16| } else if (prop.value == "trans_vertex_alpha") { ------------------ | Branch (237:32): [True: 2, False: 3] ------------------ 238| 2| matFlags = AI_IRRMESH_MAT_trans_vertex_alpha; ------------------ | | 26| 2|#define AI_IRRMESH_MAT_trans_vertex_alpha 0x1 ------------------ 239| 3| } else if (prop.value == "lightmap") { ------------------ | Branch (239:32): [True: 0, False: 3] ------------------ 240| 0| matFlags = AI_IRRMESH_MAT_lightmap; ------------------ | | 30| 0|#define AI_IRRMESH_MAT_lightmap 0x2 ------------------ 241| 3| } else if (prop.value == "solid_2layer") { ------------------ | Branch (241:32): [True: 0, False: 3] ------------------ 242| 0| matFlags = AI_IRRMESH_MAT_solid_2layer; ------------------ | | 23| 0|#define AI_IRRMESH_MAT_solid_2layer 0x10000 ------------------ 243| 3| } else if (prop.value == "lightmap_m2") { ------------------ | Branch (243:32): [True: 0, False: 3] ------------------ 244| 0| matFlags = AI_IRRMESH_MAT_lightmap_m2; ------------------ | | 31| 0|#define AI_IRRMESH_MAT_lightmap_m2 (AI_IRRMESH_MAT_lightmap | 0x4) | | ------------------ | | | | 30| 0|#define AI_IRRMESH_MAT_lightmap 0x2 | | ------------------ ------------------ 245| 3| } else if (prop.value == "lightmap_m4") { ------------------ | Branch (245:32): [True: 3, False: 0] ------------------ 246| 3| matFlags = AI_IRRMESH_MAT_lightmap_m4; ------------------ | | 32| 3|#define AI_IRRMESH_MAT_lightmap_m4 (AI_IRRMESH_MAT_lightmap | 0x8) | | ------------------ | | | | 30| 3|#define AI_IRRMESH_MAT_lightmap 0x2 | | ------------------ ------------------ 247| 3| } else if (prop.value == "lightmap_light") { ------------------ | Branch (247:32): [True: 0, False: 0] ------------------ 248| 0| matFlags = AI_IRRMESH_MAT_lightmap_light; ------------------ | | 33| 0|#define AI_IRRMESH_MAT_lightmap_light (AI_IRRMESH_MAT_lightmap | 0x10) | | ------------------ | | | | 30| 0|#define AI_IRRMESH_MAT_lightmap 0x2 | | ------------------ ------------------ 249| 0| } else if (prop.value == "lightmap_light_m2") { ------------------ | Branch (249:32): [True: 0, False: 0] ------------------ 250| 0| matFlags = AI_IRRMESH_MAT_lightmap_light_m2; ------------------ | | 34| 0|#define AI_IRRMESH_MAT_lightmap_light_m2 (AI_IRRMESH_MAT_lightmap | 0x20) | | ------------------ | | | | 30| 0|#define AI_IRRMESH_MAT_lightmap 0x2 | | ------------------ ------------------ 251| 0| } else if (prop.value == "lightmap_light_m4") { ------------------ | Branch (251:32): [True: 0, False: 0] ------------------ 252| 0| matFlags = AI_IRRMESH_MAT_lightmap_light_m4; ------------------ | | 35| 0|#define AI_IRRMESH_MAT_lightmap_light_m4 (AI_IRRMESH_MAT_lightmap | 0x40) | | ------------------ | | | | 30| 0|#define AI_IRRMESH_MAT_lightmap 0x2 | | ------------------ ------------------ 253| 0| } else if (prop.value == "lightmap_add") { ------------------ | Branch (253:32): [True: 0, False: 0] ------------------ 254| 0| matFlags = AI_IRRMESH_MAT_lightmap_add; ------------------ | | 36| 0|#define AI_IRRMESH_MAT_lightmap_add (AI_IRRMESH_MAT_lightmap | 0x80) | | ------------------ | | | | 30| 0|#define AI_IRRMESH_MAT_lightmap 0x2 | | ------------------ ------------------ 255| 0| } else if (prop.value == "normalmap_solid" || ------------------ | Branch (255:32): [True: 0, False: 0] ------------------ 256| 0| prop.value == "parallaxmap_solid") { // Normal and parallax maps are treated equally ------------------ | Branch (256:32): [True: 0, False: 0] ------------------ 257| 0| matFlags = AI_IRRMESH_MAT_normalmap_solid; ------------------ | | 39| 0|#define AI_IRRMESH_MAT_normalmap_solid (0x100) ------------------ 258| 0| } else if (prop.value == "normalmap_trans_vertex_alpha" || ------------------ | Branch (258:32): [True: 0, False: 0] ------------------ 259| 0| prop.value == "parallaxmap_trans_vertex_alpha") { ------------------ | Branch (259:32): [True: 0, False: 0] ------------------ 260| 0| matFlags = AI_IRRMESH_MAT_normalmap_tva; ------------------ | | 43| 0| (AI_IRRMESH_MAT_normalmap_solid | AI_IRRMESH_MAT_trans_vertex_alpha) | | ------------------ | | | | 39| 0|#define AI_IRRMESH_MAT_normalmap_solid (0x100) | | ------------------ | | (AI_IRRMESH_MAT_normalmap_solid | AI_IRRMESH_MAT_trans_vertex_alpha) | | ------------------ | | | | 26| 0|#define AI_IRRMESH_MAT_trans_vertex_alpha 0x1 | | ------------------ ------------------ 261| 0| } else if (prop.value == "normalmap_trans_add" || ------------------ | Branch (261:32): [True: 0, False: 0] ------------------ 262| 0| prop.value == "parallaxmap_trans_add") { ------------------ | Branch (262:32): [True: 0, False: 0] ------------------ 263| 0| matFlags = AI_IRRMESH_MAT_normalmap_ta; ------------------ | | 47| 0| (AI_IRRMESH_MAT_normalmap_solid | AI_IRRMESH_MAT_trans_add) | | ------------------ | | | | 39| 0|#define AI_IRRMESH_MAT_normalmap_solid (0x100) | | ------------------ | | (AI_IRRMESH_MAT_normalmap_solid | AI_IRRMESH_MAT_trans_add) | | ------------------ | | | | 27| 0|#define AI_IRRMESH_MAT_trans_add 0x2 | | ------------------ ------------------ 264| 0| } else { 265| 0| ASSIMP_LOG_WARN("IRRMat: Unrecognized material type: ", prop.value); 266| 0| } 267| 21| } 268| | 269| | // Up to 4 texture channels are supported 270| 129| if (prop.name == "Texture1") { ------------------ | Branch (270:21): [True: 21, False: 108] ------------------ 271| | // Always accept the primary texture channel 272| 21| ++cnt; 273| 21| s.Set(prop.value); 274| 21| mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0)); 275| 108| } else if (prop.name == "Texture2" && cnt == 1) { ------------------ | Branch (275:28): [True: 3, False: 105] | Branch (275:55): [True: 3, False: 0] ------------------ 276| | // 2-layer material lightmapped? 277| 3| if (matFlags & AI_IRRMESH_MAT_lightmap) { ------------------ | | 30| 3|#define AI_IRRMESH_MAT_lightmap 0x2 ------------------ | Branch (277:25): [True: 3, False: 0] ------------------ 278| 3| ++cnt; 279| 3| s.Set(prop.value); 280| 3| mat->AddProperty(&s, AI_MATKEY_TEXTURE_LIGHTMAP(0)); 281| | 282| | // set the corresponding material flag 283| 3| matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE; ------------------ | | 51| 3|#define AI_IRRMESH_EXTRA_2ND_TEXTURE 0x100000 ------------------ 284| 3| } else if (matFlags & AI_IRRMESH_MAT_normalmap_solid) { // alternatively: normal or parallax mapping ------------------ | | 39| 0|#define AI_IRRMESH_MAT_normalmap_solid (0x100) ------------------ | Branch (284:32): [True: 0, False: 0] ------------------ 285| 0| ++cnt; 286| 0| s.Set(prop.value); 287| 0| mat->AddProperty(&s, AI_MATKEY_TEXTURE_NORMALS(0)); 288| | 289| | // set the corresponding material flag 290| 0| matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE; ------------------ | | 51| 0|#define AI_IRRMESH_EXTRA_2ND_TEXTURE 0x100000 ------------------ 291| 0| } else if (matFlags & AI_IRRMESH_MAT_solid_2layer) { // or just as second diffuse texture ------------------ | | 23| 0|#define AI_IRRMESH_MAT_solid_2layer 0x10000 ------------------ | Branch (291:32): [True: 0, False: 0] ------------------ 292| 0| ++cnt; 293| 0| s.Set(prop.value); 294| 0| mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(1)); 295| 0| ++nd; 296| | 297| | // set the corresponding material flag 298| 0| matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE; ------------------ | | 51| 0|#define AI_IRRMESH_EXTRA_2ND_TEXTURE 0x100000 ------------------ 299| 0| } else { 300| 0| ASSIMP_LOG_WARN("IRRmat: Skipping second texture"); 301| 0| } 302| 105| } else if (prop.name == "Texture3" && cnt == 2) { ------------------ | Branch (302:28): [True: 0, False: 105] | Branch (302:55): [True: 0, False: 0] ------------------ 303| | // Irrlicht does not seem to use these channels. 304| 0| ++cnt; 305| 0| s.Set(prop.value); 306| 0| mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(nd + 1)); 307| 105| } else if (prop.name == "Texture4" && cnt == 3) { ------------------ | Branch (307:28): [True: 0, False: 105] | Branch (307:55): [True: 0, False: 0] ------------------ 308| | // Irrlicht does not seem to use these channels. 309| 0| ++cnt; 310| 0| s.Set(prop.value); 311| 0| mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(nd + 2)); 312| 0| } 313| | 314| | // Texture mapping options 315| 129| if (prop.name == "TextureWrap1" && cnt >= 1) { ------------------ | Branch (315:21): [True: 21, False: 108] | Branch (315:52): [True: 21, False: 0] ------------------ 316| 21| int map = ConvertMappingMode(prop.value); 317| 21| mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0)); 318| 21| mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0)); 319| 108| } else if (prop.name == "TextureWrap2" && cnt >= 2) { ------------------ | Branch (319:28): [True: 21, False: 87] | Branch (319:59): [True: 3, False: 18] ------------------ 320| 3| int map = ConvertMappingMode(prop.value); 321| 3| if (matFlags & AI_IRRMESH_MAT_lightmap) { ------------------ | | 30| 3|#define AI_IRRMESH_MAT_lightmap 0x2 ------------------ | Branch (321:25): [True: 3, False: 0] ------------------ 322| 3| mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_LIGHTMAP(0)); 323| 3| mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_LIGHTMAP(0)); 324| 3| } else if (matFlags & (AI_IRRMESH_MAT_normalmap_solid)) { ------------------ | | 39| 0|#define AI_IRRMESH_MAT_normalmap_solid (0x100) ------------------ | Branch (324:32): [True: 0, False: 0] ------------------ 325| 0| mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_NORMALS(0)); 326| 0| mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_NORMALS(0)); 327| 0| } else if (matFlags & AI_IRRMESH_MAT_solid_2layer) { ------------------ | | 23| 0|#define AI_IRRMESH_MAT_solid_2layer 0x10000 ------------------ | Branch (327:32): [True: 0, False: 0] ------------------ 328| 0| mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(1)); 329| 0| mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(1)); 330| 0| } 331| 105| } else if (prop.name == "TextureWrap3" && cnt >= 3) { ------------------ | Branch (331:28): [True: 21, False: 84] | Branch (331:59): [True: 0, False: 21] ------------------ 332| 0| int map = ConvertMappingMode(prop.value); 333| 0| mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(nd + 1)); 334| 0| mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(nd + 1)); 335| 105| } else if (prop.name == "TextureWrap4" && cnt >= 4) { ------------------ | Branch (335:28): [True: 21, False: 84] | Branch (335:59): [True: 0, False: 21] ------------------ 336| 0| int map = ConvertMappingMode(prop.value); 337| 0| mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(nd + 2)); 338| 0| mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(nd + 2)); 339| 0| } 340| 129| } 341| 189| } 342| | // break; 343| | /*case EXN_ELEMENT_END: 344| | 345| | // Assume there are no further nested nodes in elements 346| | if ( !ASSIMP_stricmp(reader->getNodeName(),"material") || 347| | !ASSIMP_stricmp(reader->getNodeName(),"attributes")) 348| | { 349| | // Now process lightmapping flags 350| | // We should have at least one textur to do that .. 351| | if (cnt && matFlags & AI_IRRMESH_MAT_lightmap) 352| | { 353| | float f = 1.f; 354| | unsigned int unmasked = matFlags&~AI_IRRMESH_MAT_lightmap; 355| | 356| | // Additive lightmap? 357| | int op = (unmasked & AI_IRRMESH_MAT_lightmap_add 358| | ? aiTextureOp_Add : aiTextureOp_Multiply); 359| | 360| | // Handle Irrlicht's lightmapping scaling factor 361| | if (unmasked & AI_IRRMESH_MAT_lightmap_m2 || 362| | unmasked & AI_IRRMESH_MAT_lightmap_light_m2) 363| | { 364| | f = 2.f; 365| | } 366| | else if (unmasked & AI_IRRMESH_MAT_lightmap_m4 || 367| | unmasked & AI_IRRMESH_MAT_lightmap_light_m4) 368| | { 369| | f = 4.f; 370| | } 371| | mat->AddProperty( &f, 1, AI_MATKEY_TEXBLEND_LIGHTMAP(0)); 372| | mat->AddProperty( &op,1, AI_MATKEY_TEXOP_LIGHTMAP(0)); 373| | } 374| | 375| | return mat; 376| | } 377| | default: 378| | 379| | // GCC complains here ... 380| | break; 381| | } 382| | }*/ 383| 871| } 384| | //ASSIMP_LOG_ERROR("IRRMESH: Unexpected end of file. Material is not complete"); 385| | 386| 69| return mat; 387| 69|} _ZN6Assimp12IrrlichtBaseC2Ev: 61| 1.24k| IrrlichtBase() { 62| | // empty 63| 1.24k| } _ZN6Assimp19ColorFromARGBPackedEjR9aiColor4tIfE: 107| 4.13k|inline void ColorFromARGBPacked(uint32_t in, aiColor4D &clr) { 108| 4.13k| clr.a = ((in >> 24) & 0xff) / 255.f; 109| 4.13k| clr.r = ((in >> 16) & 0xff) / 255.f; 110| 4.13k| clr.g = ((in >> 8) & 0xff) / 255.f; 111| 4.13k| clr.b = ((in)&0xff) / 255.f; 112| 4.13k|} _ZN6Assimp12IrrlichtBaseD2Ev: 65| 1.24k| ~IrrlichtBase() = default; _ZN6Assimp3LWO12AnimResolverC2ERNSt3__14listINS0_8EnvelopeENS2_9allocatorIS4_EEEEd: 64| 11.0k| envelopes(_envelopes), 65| 11.0k| sample_rate(0.), 66| | envl_x(), 67| | envl_y(), 68| | envl_z(), 69| | end_x(), 70| | end_y(), 71| | end_z(), 72| | flags(), 73| 11.0k| sample_delta() { 74| 11.0k| trans_x = trans_y = trans_z = nullptr; 75| 11.0k| rotat_x = rotat_y = rotat_z = nullptr; 76| 11.0k| scale_x = scale_y = scale_z = nullptr; 77| | 78| 11.0k| first = last = 150392.; 79| | 80| | // find transformation envelopes 81| 12.2k| for (std::list::iterator it = envelopes.begin(); it != envelopes.end(); ++it) { ------------------ | Branch (81:69): [True: 1.19k, False: 11.0k] ------------------ 82| | 83| 1.19k| (*it).old_first = 0; 84| 1.19k| (*it).old_last = (*it).keys.size() - 1; 85| | 86| 1.19k| if ((*it).keys.empty()) { ------------------ | Branch (86:13): [True: 860, False: 336] ------------------ 87| 860| continue; 88| 860| } 89| 336| if ((int)(*it).type < 1 || (int)(*it).type>EnvelopeType_Unknown) { ------------------ | Branch (89:13): [True: 0, False: 336] | Branch (89:36): [True: 0, False: 336] ------------------ 90| 0| continue; 91| 0| } 92| 336| switch ((*it).type) { 93| | // translation 94| 15| case LWO::EnvelopeType_Position_X: ------------------ | Branch (94:9): [True: 15, False: 321] ------------------ 95| 15| trans_x = &*it; 96| 15| break; 97| 270| case LWO::EnvelopeType_Position_Y: ------------------ | Branch (97:9): [True: 270, False: 66] ------------------ 98| 270| trans_y = &*it; 99| 270| break; 100| 13| case LWO::EnvelopeType_Position_Z: ------------------ | Branch (100:9): [True: 13, False: 323] ------------------ 101| 13| trans_z = &*it; 102| 13| break; 103| | 104| | // rotation 105| 14| case LWO::EnvelopeType_Rotation_Heading: ------------------ | Branch (105:9): [True: 14, False: 322] ------------------ 106| 14| rotat_x = &*it; 107| 14| break; 108| 1| case LWO::EnvelopeType_Rotation_Pitch: ------------------ | Branch (108:9): [True: 1, False: 335] ------------------ 109| 1| rotat_y = &*it; 110| 1| break; 111| 2| case LWO::EnvelopeType_Rotation_Bank: ------------------ | Branch (111:9): [True: 2, False: 334] ------------------ 112| 2| rotat_z = &*it; 113| 2| break; 114| | 115| | // scaling 116| 12| case LWO::EnvelopeType_Scaling_X: ------------------ | Branch (116:9): [True: 12, False: 324] ------------------ 117| 12| scale_x = &*it; 118| 12| break; 119| 4| case LWO::EnvelopeType_Scaling_Y: ------------------ | Branch (119:9): [True: 4, False: 332] ------------------ 120| 4| scale_y = &*it; 121| 4| break; 122| 1| case LWO::EnvelopeType_Scaling_Z: ------------------ | Branch (122:9): [True: 1, False: 335] ------------------ 123| 1| scale_z = &*it; 124| 1| break; 125| 4| default: ------------------ | Branch (125:9): [True: 4, False: 332] ------------------ 126| 4| continue; 127| 336| }; 128| | 129| | // convert from seconds to ticks 130| 979| for (std::vector::iterator d = (*it).keys.begin(); d != (*it).keys.end(); ++d) ------------------ | Branch (130:70): [True: 647, False: 332] ------------------ 131| 647| (*d).time *= tick; 132| | 133| | // set default animation range (minimum and maximum time value for which we have a keyframe) 134| 332| first = std::min(first, (*it).keys.front().time); 135| 332| last = std::max(last, (*it).keys.back().time); 136| 332| } 137| | 138| | // deferred setup of animation range to increase performance. 139| | // typically the application will want to specify its own. 140| 11.0k| need_to_setup = true; 141| 11.0k|} _ZN6Assimp3LWO12AnimResolver19ClearAnimRangeSetupEv: 145| 11.0k|void AnimResolver::ClearAnimRangeSetup() { 146| 12.2k| for (std::list::iterator it = envelopes.begin(); it != envelopes.end(); ++it) { ------------------ | Branch (146:69): [True: 1.19k, False: 11.0k] ------------------ 147| | 148| 1.19k| (*it).keys.erase((*it).keys.begin(), (*it).keys.begin() + (*it).old_first); 149| 1.19k| (*it).keys.erase((*it).keys.begin() + (*it).old_last + 1, (*it).keys.end()); 150| 1.19k| } 151| 11.0k|} _ZN6Assimp3LWO12AnimResolver20UpdateAnimRangeSetupEv: 155| 11.3k|void AnimResolver::UpdateAnimRangeSetup() { 156| | // XXX doesn't work yet (hangs if more than one envelope channels needs to be interpolated) 157| | 158| 13.2k| for (std::list::iterator it = envelopes.begin(); it != envelopes.end(); ++it) { ------------------ | Branch (158:69): [True: 1.91k, False: 11.3k] ------------------ 159| 1.91k| if ((*it).keys.empty()) continue; ------------------ | Branch (159:13): [True: 1.24k, False: 672] ------------------ 160| | 161| 672| const double my_first = (*it).keys.front().time; 162| 672| const double my_last = (*it).keys.back().time; 163| | 164| 672| const double delta = my_last - my_first; 165| 672| if (delta == 0.0) { ------------------ | Branch (165:13): [True: 76, False: 596] ------------------ 166| 76| continue; 167| 76| } 168| | 169| 596| const size_t old_size = (*it).keys.size(); 170| 596| const float value_delta = (*it).keys.back().value - (*it).keys.front().value; 171| | 172| | // NOTE: We won't handle reset, linear and constant here. 173| | // See DoInterpolation() for their implementation. 174| | 175| | // process pre behavior 176| 596| switch ((*it).pre) { 177| 0| case LWO::PrePostBehaviour_OffsetRepeat: ------------------ | Branch (177:9): [True: 0, False: 596] ------------------ 178| 0| case LWO::PrePostBehaviour_Repeat: ------------------ | Branch (178:9): [True: 0, False: 596] ------------------ 179| 0| case LWO::PrePostBehaviour_Oscillate: { ------------------ | Branch (179:9): [True: 0, False: 596] ------------------ 180| 0| const double start_time = delta - std::fmod(my_first - first, delta); 181| 0| std::vector::iterator n = std::find_if((*it).keys.begin(), (*it).keys.end(), 182| 0| [start_time](double t) { return start_time > t; }); 183| 0| std::vector::iterator m; 184| | 185| 0| size_t ofs = 0; 186| 0| if (n != (*it).keys.end()) { ------------------ | Branch (186:17): [True: 0, False: 0] ------------------ 187| | // copy from here - don't use iterators, insert() would invalidate them 188| 0| ofs = (*it).keys.end() - n; 189| 0| (*it).keys.insert((*it).keys.begin(), ofs, LWO::Key()); 190| | 191| 0| std::copy((*it).keys.end() - ofs, (*it).keys.end(), (*it).keys.begin()); 192| 0| } 193| | 194| | // do full copies. again, no iterators 195| 0| const unsigned int num = (unsigned int)((my_first - first) / delta); 196| 0| (*it).keys.resize((*it).keys.size() + num * old_size); 197| | 198| 0| n = (*it).keys.begin() + ofs; 199| 0| bool reverse = false; 200| 0| for (unsigned int i = 0; i < num; ++i) { ------------------ | Branch (200:38): [True: 0, False: 0] ------------------ 201| 0| m = n + old_size * (i + 1); 202| 0| std::copy(n, n + old_size, m); 203| 0| const bool res = ((*it).pre == LWO::PrePostBehaviour_Oscillate); 204| 0| reverse = !reverse; 205| 0| if (res && reverse) { ------------------ | Branch (205:21): [True: 0, False: 0] | Branch (205:28): [True: 0, False: 0] ------------------ 206| 0| std::reverse(m, m + old_size - 1); 207| 0| } 208| 0| } 209| | 210| | // update time values 211| 0| n = (*it).keys.end() - (old_size + 1); 212| 0| double cur_minus = delta; 213| 0| unsigned int tt = 1; 214| 0| for (const double tmp = delta * (num + 1); cur_minus <= tmp; cur_minus += delta, ++tt) { ------------------ | Branch (214:56): [True: 0, False: 0] ------------------ 215| 0| if (delta == tmp) { ------------------ | Branch (215:21): [True: 0, False: 0] ------------------ 216| 0| m = it->keys.begin(); 217| 0| } else { 218| 0| ptrdiff_t dist = std::distance((*it).keys.begin(), n); 219| 0| if (dist <= static_cast(old_size)) { ------------------ | Branch (219:25): [True: 0, False: 0] ------------------ 220| | // clamp to begin to avoid seeking before begin 221| 0| m = (*it).keys.begin(); 222| 0| } else { 223| 0| m = n - (old_size + 1); 224| 0| } 225| 0| } 226| 0| for (auto it2 = m; it2 != n; ++it2) { ------------------ | Branch (226:36): [True: 0, False: 0] ------------------ 227| 0| it2->time -= cur_minus; 228| 0| if ((*it).pre == LWO::PrePostBehaviour_OffsetRepeat) { ------------------ | Branch (228:25): [True: 0, False: 0] ------------------ 229| 0| it2->value += tt * value_delta; 230| 0| } 231| 0| } 232| 0| } 233| 0| break; 234| 0| } 235| 596| default: ------------------ | Branch (235:9): [True: 596, False: 0] ------------------ 236| | // silence compiler warning 237| 596| break; 238| 596| } 239| | 240| | // process post behavior 241| 596| switch ((*it).post) { 242| | 243| 0| case LWO::PrePostBehaviour_OffsetRepeat: ------------------ | Branch (243:9): [True: 0, False: 596] ------------------ 244| 0| case LWO::PrePostBehaviour_Repeat: ------------------ | Branch (244:9): [True: 0, False: 596] ------------------ 245| 0| case LWO::PrePostBehaviour_Oscillate: ------------------ | Branch (245:9): [True: 0, False: 596] ------------------ 246| | 247| 0| break; 248| | 249| 596| default: ------------------ | Branch (249:9): [True: 596, False: 0] ------------------ 250| | // silence compiler warning 251| 596| break; 252| 596| } 253| 596| } 254| 11.3k|} _ZN6Assimp3LWO12AnimResolver15ExtractBindPoseER12aiMatrix4x4tIfE: 258| 11.0k|void AnimResolver::ExtractBindPose(aiMatrix4x4 &out) { 259| | // If we have no envelopes, return identity 260| 11.0k| if (envelopes.empty()) { ------------------ | Branch (260:9): [True: 10.5k, False: 520] ------------------ 261| 10.5k| out = aiMatrix4x4(); 262| 10.5k| return; 263| 10.5k| } 264| 520| aiVector3D angles, scaling(1.f, 1.f, 1.f), translation; 265| | 266| 520| if (trans_x) translation.x = trans_x->keys[0].value; ------------------ | Branch (266:9): [True: 14, False: 506] ------------------ 267| 520| if (trans_y) translation.y = trans_y->keys[0].value; ------------------ | Branch (267:9): [True: 269, False: 251] ------------------ 268| 520| if (trans_z) translation.z = trans_z->keys[0].value; ------------------ | Branch (268:9): [True: 12, False: 508] ------------------ 269| | 270| 520| if (rotat_x) angles.x = rotat_x->keys[0].value; ------------------ | Branch (270:9): [True: 13, False: 507] ------------------ 271| 520| if (rotat_y) angles.y = rotat_y->keys[0].value; ------------------ | Branch (271:9): [True: 1, False: 519] ------------------ 272| 520| if (rotat_z) angles.z = rotat_z->keys[0].value; ------------------ | Branch (272:9): [True: 2, False: 518] ------------------ 273| | 274| 520| if (scale_x) scaling.x = scale_x->keys[0].value; ------------------ | Branch (274:9): [True: 11, False: 509] ------------------ 275| 520| if (scale_y) scaling.y = scale_y->keys[0].value; ------------------ | Branch (275:9): [True: 4, False: 516] ------------------ 276| 520| if (scale_z) scaling.z = scale_z->keys[0].value; ------------------ | Branch (276:9): [True: 1, False: 519] ------------------ 277| | 278| | // build the final matrix 279| 520| aiMatrix4x4 s, rx, ry, rz, t; 280| 520| aiMatrix4x4::RotationZ(angles.z, rz); 281| 520| aiMatrix4x4::RotationX(angles.y, rx); 282| 520| aiMatrix4x4::RotationY(angles.x, ry); 283| 520| aiMatrix4x4::Translation(translation, t); 284| 520| aiMatrix4x4::Scaling(scaling, s); 285| 520| out = t * ry * rx * rz * s; 286| 520|} _ZN6Assimp3LWO12AnimResolver15DoInterpolationENSt3__111__wrap_iterIPKNS0_3KeyEEEPNS0_8EnvelopeEdRf: 291| 894| LWO::Envelope *envl, double time, float &fill) { 292| 894| if (envl->keys.size() == 1) { ------------------ | Branch (292:9): [True: 602, False: 292] ------------------ 293| 602| fill = envl->keys[0].value; 294| 602| return; 295| 602| } 296| | 297| | // check whether we're at the beginning of the animation track 298| 292| if (cur == envl->keys.begin()) { ------------------ | Branch (298:9): [True: 281, False: 11] ------------------ 299| | 300| | // ok ... this depends on pre behaviour now 301| | // we don't need to handle repeat&offset repeat&oszillate here, see UpdateAnimRangeSetup() 302| 281| switch (envl->pre) { 303| 0| case LWO::PrePostBehaviour_Linear: ------------------ | Branch (303:9): [True: 0, False: 281] ------------------ 304| 0| DoInterpolation2(cur, cur + 1, time, fill); 305| 0| return; 306| | 307| 2| case LWO::PrePostBehaviour_Reset: ------------------ | Branch (307:9): [True: 2, False: 279] ------------------ 308| 2| fill = 0.f; 309| 2| return; 310| | 311| 279| default: //case LWO::PrePostBehaviour_Constant: ------------------ | Branch (311:9): [True: 279, False: 2] ------------------ 312| 279| fill = (*cur).value; 313| 279| return; 314| 281| } 315| 281| } 316| | // check whether we're at the end of the animation track 317| 11| else if (cur == envl->keys.end() - 1 && time > envl->keys.rbegin()->time) { ------------------ | Branch (317:14): [True: 11, False: 0] | Branch (317:14): [True: 1, False: 10] | Branch (317:45): [True: 1, False: 10] ------------------ 318| | // ok ... this depends on post behaviour now 319| 1| switch (envl->post) { 320| 0| case LWO::PrePostBehaviour_Linear: ------------------ | Branch (320:9): [True: 0, False: 1] ------------------ 321| 0| DoInterpolation2(cur, cur - 1, time, fill); 322| 0| return; 323| | 324| 0| case LWO::PrePostBehaviour_Reset: ------------------ | Branch (324:9): [True: 0, False: 1] ------------------ 325| 0| fill = 0.f; 326| 0| return; 327| | 328| 1| default: //case LWO::PrePostBehaviour_Constant: ------------------ | Branch (328:9): [True: 1, False: 0] ------------------ 329| 1| fill = (*cur).value; 330| 1| return; 331| 1| } 332| 1| } 333| | 334| | // Otherwise do a simple interpolation 335| 10| DoInterpolation2(cur - 1, cur, time, fill); 336| 10|} _ZN6Assimp3LWO12AnimResolver16DoInterpolation2ENSt3__111__wrap_iterIPKNS0_3KeyEEES7_dRf: 341| 10| std::vector::const_iterator end, double time, float &fill) { 342| 10| switch ((*end).inter) { 343| | 344| 0| case LWO::IT_STEP: ------------------ | Branch (344:5): [True: 0, False: 10] ------------------ 345| | // no interpolation at all - take the value of the last key 346| 0| fill = (*beg).value; 347| 0| return; 348| 10| default: ------------------ | Branch (348:5): [True: 10, False: 0] ------------------ 349| | 350| | // silence compiler warning 351| 10| break; 352| 10| } 353| | // linear interpolation - default 354| 10| double duration = (*end).time - (*beg).time; 355| 10| if (duration > 0.0) { ------------------ | Branch (355:9): [True: 10, False: 0] ------------------ 356| 10| fill = (*beg).value + ((*end).value - (*beg).value) * (float)(((time - (*beg).time) / duration)); 357| 10| } else { 358| 0| fill = (*beg).value; 359| 0| } 360| 10|} _ZN6Assimp3LWO12AnimResolver16InterpolateTrackERNSt3__16vectorI11aiVectorKeyNS2_9allocatorIS4_EEEERS4_d: 374| 592|void AnimResolver::InterpolateTrack(std::vector &out, aiVectorKey &fill, double time) { 375| | // subsample animation track? 376| 592| if (flags & AI_LWO_ANIM_FLAG_SAMPLE_ANIMS) { ------------------ | | 177| 592|#define AI_LWO_ANIM_FLAG_SAMPLE_ANIMS 0x1 ------------------ | Branch (376:9): [True: 0, False: 592] ------------------ 377| 0| SubsampleAnimTrack(out, time, sample_delta); 378| 0| } 379| | 380| 592| fill.mTime = time; 381| | 382| | // get x 383| 592| if ((*cur_x).time == time) { ------------------ | Branch (383:9): [True: 286, False: 306] ------------------ 384| 286| fill.mValue.x = (*cur_x).value; 385| | 386| 286| if (cur_x != envl_x->keys.end() - 1) /* increment x */ ------------------ | Branch (386:13): [True: 13, False: 273] ------------------ 387| 13| ++cur_x; 388| 273| else 389| 273| end_x = true; 390| 286| } else 391| 306| DoInterpolation(cur_x, envl_x, time, (float &)fill.mValue.x); 392| | 393| | // get y 394| 592| if ((*cur_y).time == time) { ------------------ | Branch (394:9): [True: 317, False: 275] ------------------ 395| 317| fill.mValue.y = (*cur_y).value; 396| | 397| 317| if (cur_y != envl_y->keys.end() - 1) /* increment y */ ------------------ | Branch (397:13): [True: 285, False: 32] ------------------ 398| 285| ++cur_y; 399| 32| else 400| 32| end_y = true; 401| 317| } else 402| 275| DoInterpolation(cur_y, envl_y, time, (float &)fill.mValue.y); 403| | 404| | // get z 405| 592| if ((*cur_z).time == time) { ------------------ | Branch (405:9): [True: 279, False: 313] ------------------ 406| 279| fill.mValue.z = (*cur_z).value; 407| | 408| 279| if (cur_z != envl_z->keys.end() - 1) /* increment z */ ------------------ | Branch (408:13): [True: 1, False: 278] ------------------ 409| 1| ++cur_z; 410| 278| else 411| 278| end_x = true; 412| 279| } else 413| 313| DoInterpolation(cur_z, envl_z, time, (float &)fill.mValue.z); 414| 592|} _ZN6Assimp3LWO12AnimResolver7GetKeysERNSt3__16vectorI11aiVectorKeyNS2_9allocatorIS4_EEEEPNS0_8EnvelopeESA_SA_j: 422| 292| unsigned int _flags) { 423| 292| envl_x = _envl_x; 424| 292| envl_y = _envl_y; 425| 292| envl_z = _envl_z; 426| 292| flags = _flags; 427| | 428| | // generate default channels if none are given 429| 292| LWO::Envelope def_x, def_y, def_z; 430| 292| LWO::Key key_dummy; 431| 292| key_dummy.time = 0.f; 432| 292| if ((envl_x && envl_x->type == LWO::EnvelopeType_Scaling_X) || ------------------ | Branch (432:10): [True: 23, False: 269] | Branch (432:20): [True: 0, False: 23] ------------------ 433| 292| (envl_y && envl_y->type == LWO::EnvelopeType_Scaling_Y) || ------------------ | Branch (433:14): [True: 274, False: 18] | Branch (433:24): [True: 4, False: 270] ------------------ 434| 288| (envl_z && envl_z->type == LWO::EnvelopeType_Scaling_Z)) { ------------------ | Branch (434:14): [True: 14, False: 274] | Branch (434:24): [True: 0, False: 14] ------------------ 435| 4| key_dummy.value = 1.f; 436| 4| } else 437| 288| key_dummy.value = 0.f; 438| | 439| 292| if (!envl_x) { ------------------ | Branch (439:9): [True: 269, False: 23] ------------------ 440| 269| envl_x = &def_x; 441| 269| envl_x->keys.push_back(key_dummy); 442| 269| } 443| 292| if (!envl_y) { ------------------ | Branch (443:9): [True: 18, False: 274] ------------------ 444| 18| envl_y = &def_y; 445| 18| envl_y->keys.push_back(key_dummy); 446| 18| } 447| 292| if (!envl_z) { ------------------ | Branch (447:9): [True: 278, False: 14] ------------------ 448| 278| envl_z = &def_z; 449| 278| envl_z->keys.push_back(key_dummy); 450| 278| } 451| | 452| | // guess how many keys we'll get 453| 292| size_t reserve; 454| 292| double sr = 1.; 455| 292| if (flags & AI_LWO_ANIM_FLAG_SAMPLE_ANIMS) { ------------------ | | 177| 292|#define AI_LWO_ANIM_FLAG_SAMPLE_ANIMS 0x1 ------------------ | Branch (455:9): [True: 0, False: 292] ------------------ 456| 0| if (!sample_rate) ------------------ | Branch (456:13): [True: 0, False: 0] ------------------ 457| 0| sr = 100.f; 458| 0| else 459| 0| sr = sample_rate; 460| 0| sample_delta = 1.f / sr; 461| | 462| 0| reserve = (size_t)( 463| 0| std::max(envl_x->keys.rbegin()->time, 464| 0| std::max(envl_y->keys.rbegin()->time, envl_z->keys.rbegin()->time)) * 465| 0| sr); 466| 0| } else 467| 292| reserve = std::max(envl_x->keys.size(), std::max(envl_x->keys.size(), envl_z->keys.size())); 468| 292| out.reserve(reserve + (reserve >> 1)); 469| | 470| | // Iterate through all three arrays at once - it's tricky, but 471| | // rather interesting to implement. 472| 292| cur_x = envl_x->keys.begin(); 473| 292| cur_y = envl_y->keys.begin(); 474| 292| cur_z = envl_z->keys.begin(); 475| | 476| 292| end_x = end_y = end_z = false; 477| 593| while (true) { ------------------ | Branch (477:12): [True: 593, Folded] ------------------ 478| | 479| 593| aiVectorKey fill; 480| | 481| 593| if ((*cur_x).time == (*cur_y).time && (*cur_x).time == (*cur_z).time) { ------------------ | Branch (481:13): [True: 21, False: 572] | Branch (481:47): [True: 1, False: 20] ------------------ 482| | 483| | // we have a keyframe for all of them defined .. this means 484| | // we don't need to interpolate here. 485| 1| fill.mTime = (*cur_x).time; 486| | 487| 1| fill.mValue.x = (*cur_x).value; 488| 1| fill.mValue.y = (*cur_y).value; 489| 1| fill.mValue.z = (*cur_z).value; 490| | 491| | // subsample animation track 492| 1| if (flags & AI_LWO_ANIM_FLAG_SAMPLE_ANIMS) { ------------------ | | 177| 1|#define AI_LWO_ANIM_FLAG_SAMPLE_ANIMS 0x1 ------------------ | Branch (492:17): [True: 0, False: 1] ------------------ 493| | //SubsampleAnimTrack(out,cur_x, cur_y, cur_z, d, sample_delta); 494| 0| } 495| 1| } 496| | 497| | // Find key with lowest time value 498| 592| else if ((*cur_x).time <= (*cur_y).time && !end_x) { ------------------ | Branch (498:18): [True: 555, False: 37] | Branch (498:52): [True: 282, False: 273] ------------------ 499| | 500| 282| if ((*cur_z).time <= (*cur_x).time && !end_z) { ------------------ | Branch (500:17): [True: 272, False: 10] | Branch (500:51): [True: 260, False: 12] ------------------ 501| 260| InterpolateTrack(out, fill, (*cur_z).time); 502| 260| } else { 503| 22| InterpolateTrack(out, fill, (*cur_x).time); 504| 22| } 505| 310| } else if ((*cur_z).time <= (*cur_y).time && !end_y) { ------------------ | Branch (505:20): [True: 302, False: 8] | Branch (505:54): [True: 302, False: 0] ------------------ 506| 302| InterpolateTrack(out, fill, (*cur_y).time); 507| 302| } else if (!end_y) { ------------------ | Branch (507:20): [True: 3, False: 5] ------------------ 508| | // welcome on the server, y 509| 3| InterpolateTrack(out, fill, (*cur_y).time); 510| 5| } else { 511| | // we have reached the end of at least 2 channels, 512| | // only one is remaining. Extrapolate the 2. 513| 5| if (end_y) { ------------------ | Branch (513:17): [True: 5, False: 0] ------------------ 514| 5| InterpolateTrack(out, fill, (end_x ? (*cur_z) : (*cur_x)).time); ------------------ | Branch (514:46): [True: 1, False: 4] ------------------ 515| 5| } else if (end_x) { ------------------ | Branch (515:24): [True: 0, False: 0] ------------------ 516| 0| InterpolateTrack(out, fill, (end_z ? (*cur_y) : (*cur_z)).time); ------------------ | Branch (516:46): [True: 0, False: 0] ------------------ 517| 0| } else { // if (end_z) 518| 0| InterpolateTrack(out, fill, (end_y ? (*cur_x) : (*cur_y)).time); ------------------ | Branch (518:46): [True: 0, False: 0] ------------------ 519| 0| } 520| 5| } 521| 593| double lasttime = fill.mTime; 522| 593| out.push_back(fill); 523| | 524| 593| if (lasttime >= (*cur_x).time) { ------------------ | Branch (524:13): [True: 545, False: 48] ------------------ 525| 545| if (cur_x != envl_x->keys.end() - 1) ------------------ | Branch (525:17): [True: 0, False: 545] ------------------ 526| 0| ++cur_x; 527| 545| else 528| 545| end_x = true; 529| 545| } 530| 593| if (lasttime >= (*cur_y).time) { ------------------ | Branch (530:13): [True: 298, False: 295] ------------------ 531| 298| if (cur_y != envl_y->keys.end() - 1) ------------------ | Branch (531:17): [True: 1, False: 297] ------------------ 532| 1| ++cur_y; 533| 297| else 534| 297| end_y = true; 535| 298| } 536| 593| if (lasttime >= (*cur_z).time) { ------------------ | Branch (536:13): [True: 577, False: 16] ------------------ 537| 577| if (cur_z != envl_z->keys.end() - 1) ------------------ | Branch (537:17): [True: 0, False: 577] ------------------ 538| 0| ++cur_z; 539| 577| else 540| 577| end_z = true; 541| 577| } 542| | 543| 593| if (end_x && end_y && end_z) /* finished? */ ------------------ | Branch (543:13): [True: 566, False: 27] | Branch (543:22): [True: 293, False: 273] | Branch (543:31): [True: 292, False: 1] ------------------ 544| 292| break; 545| 593| } 546| | 547| 292| if (flags & AI_LWO_ANIM_FLAG_START_AT_ZERO) { ------------------ | | 183| 292|#define AI_LWO_ANIM_FLAG_START_AT_ZERO 0x2 ------------------ | Branch (547:9): [True: 0, False: 292] ------------------ 548| 0| for (std::vector::iterator it = out.begin(); it != out.end(); ++it) ------------------ | Branch (548:67): [True: 0, False: 0] ------------------ 549| 0| (*it).mTime -= first; 550| 0| } 551| 292|} _ZN6Assimp3LWO12AnimResolver18ExtractAnimChannelEPP10aiNodeAnimj: 555| 11.0k|void AnimResolver::ExtractAnimChannel(aiNodeAnim **out, unsigned int /*= 0*/) { 556| 11.0k| *out = nullptr; 557| | 558| | //FIXME: crashes if more than one component is animated at different timings, to be resolved. 559| | 560| | // If we have no envelopes, return nullptr 561| 11.0k| if (envelopes.empty()) { ------------------ | Branch (561:9): [True: 10.5k, False: 520] ------------------ 562| 10.5k| return; 563| 10.5k| } 564| | 565| | // We won't spawn an animation channel if we don't have at least one envelope with more than one keyframe defined. 566| 520| const bool trans = ((trans_x && trans_x->keys.size() > 1) || (trans_y && trans_y->keys.size() > 1) || (trans_z && trans_z->keys.size() > 1)); ------------------ | Branch (566:26): [True: 14, False: 506] | Branch (566:37): [True: 10, False: 4] | Branch (566:67): [True: 265, False: 245] | Branch (566:78): [True: 265, False: 0] | Branch (566:108): [True: 0, False: 245] | Branch (566:119): [True: 0, False: 0] ------------------ 567| 520| const bool rotat = ((rotat_x && rotat_x->keys.size() > 1) || (rotat_y && rotat_y->keys.size() > 1) || (rotat_z && rotat_z->keys.size() > 1)); ------------------ | Branch (567:26): [True: 13, False: 507] | Branch (567:37): [True: 13, False: 0] | Branch (567:67): [True: 0, False: 507] | Branch (567:78): [True: 0, False: 0] | Branch (567:108): [True: 0, False: 507] | Branch (567:119): [True: 0, False: 0] ------------------ 568| 520| const bool scale = ((scale_x && scale_x->keys.size() > 1) || (scale_y && scale_y->keys.size() > 1) || (scale_z && scale_z->keys.size() > 1)); ------------------ | Branch (568:26): [True: 11, False: 509] | Branch (568:37): [True: 0, False: 11] | Branch (568:67): [True: 4, False: 516] | Branch (568:78): [True: 4, False: 0] | Branch (568:108): [True: 1, False: 515] | Branch (568:119): [True: 0, False: 1] ------------------ 569| 520| if (!trans && !rotat && !scale) ------------------ | Branch (569:9): [True: 245, False: 275] | Branch (569:19): [True: 245, False: 0] | Branch (569:29): [True: 241, False: 4] ------------------ 570| 241| return; 571| | 572| | // Allocate the output animation 573| 279| aiNodeAnim *anim = *out = new aiNodeAnim(); 574| | 575| | // Setup default animation setup if necessary 576| 279| if (need_to_setup) { ------------------ | Branch (576:9): [True: 279, False: 0] ------------------ 577| 279| UpdateAnimRangeSetup(); 578| 279| need_to_setup = false; 579| 279| } 580| | 581| | // copy translation keys 582| 279| if (trans) { ------------------ | Branch (582:9): [True: 275, False: 4] ------------------ 583| 275| std::vector keys; 584| 275| GetKeys(keys, trans_x, trans_y, trans_z, flags); 585| | 586| 275| anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys = static_cast(keys.size())]; 587| 275| std::copy(keys.begin(), keys.end(), anim->mPositionKeys); 588| 275| } 589| | 590| | // copy rotation keys 591| 279| if (rotat) { ------------------ | Branch (591:9): [True: 13, False: 266] ------------------ 592| 13| std::vector keys; 593| 13| GetKeys(keys, rotat_x, rotat_y, rotat_z, flags); 594| | 595| 13| anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys = static_cast(keys.size())]; 596| | 597| | // convert heading, pitch, bank to quaternion 598| | // mValue.x=Heading=Rot(Y), mValue.y=Pitch=Rot(X), mValue.z=Bank=Rot(Z) 599| | // Lightwave's rotation order is ZXY 600| 13| aiVector3D X(1.0, 0.0, 0.0); 601| 13| aiVector3D Y(0.0, 1.0, 0.0); 602| 13| aiVector3D Z(0.0, 0.0, 1.0); 603| 31| for (unsigned int i = 0; i < anim->mNumRotationKeys; ++i) { ------------------ | Branch (603:34): [True: 18, False: 13] ------------------ 604| 18| aiQuatKey &qk = anim->mRotationKeys[i]; 605| 18| qk.mTime = keys[i].mTime; 606| 18| qk.mValue = aiQuaternion(Y, keys[i].mValue.x) * aiQuaternion(X, keys[i].mValue.y) * aiQuaternion(Z, keys[i].mValue.z); 607| 18| } 608| 13| } 609| | 610| | // copy scaling keys 611| 279| if (scale) { ------------------ | Branch (611:9): [True: 4, False: 275] ------------------ 612| 4| std::vector keys; 613| 4| GetKeys(keys, scale_x, scale_y, scale_z, flags); 614| | 615| 4| anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys = static_cast(keys.size())]; 616| 4| std::copy(keys.begin(), keys.end(), anim->mScalingKeys); 617| 4| } 618| 279|} _ZN6Assimp3LWO3KeyC2Ev: 119| 967| , inter(IT_LINE) 120| 967| , params() { 121| | // empty 122| 967| } _ZN6Assimp3LWO8EnvelopeC2Ev: 149| 2.33k| , type(EnvelopeType_Unknown) 150| 2.33k| , pre(PrePostBehaviour_Constant) 151| 2.33k| , post(PrePostBehaviour_Constant) 152| 2.33k| , old_first(0) 153| 2.33k| , old_last(0) { 154| | // empty 155| 2.33k| } _ZN6Assimp3LWO12AnimResolver17SetAnimationRangeEdd: 246| 11.0k| void SetAnimationRange(double _first, double _last) { 247| 11.0k| first = _first; 248| 11.0k| last = _last; 249| | 250| 11.0k| ClearAnimRangeSetup(); 251| 11.0k| UpdateAnimRangeSetup(); 252| 11.0k| } _ZN6Assimp3LWO4FaceC2Ej: 323| 21| surfaceIndex(0), smoothGroup(0), type(_type) {} _ZN6Assimp3LWO4FaceC2ERKS1_: 327| 5.73k| aiFace() { 328| 5.73k| *this = f; 329| 5.73k| } _ZN6Assimp3LWO9VMapEntryC2Ej: 349| 55| dims(_dims) {} _ZN6Assimp3LWO9VMapEntry8AllocateEj: 354| 23| virtual void Allocate(unsigned int num) { 355| 23| if (!rawData.empty()) ------------------ | Branch (355:13): [True: 5, False: 18] ------------------ 356| 5| return; // return if already allocated 357| | 358| 18| const unsigned int m = num * dims; 359| 18| rawData.reserve(m + (m >> 2u)); // 25% as extra storage for VMADs 360| 18| rawData.resize(m, 0.f); 361| 18| abAssigned.resize(num, false); 362| 18| } _ZN6Assimp3LWO13VColorChannelC2Ev: 376| 2| VMapEntry(4) {} _ZN6Assimp3LWO13VColorChannel8AllocateEj: 380| 3| virtual void Allocate(unsigned int num) { 381| 3| if (!rawData.empty()) ------------------ | Branch (381:13): [True: 1, False: 2] ------------------ 382| 1| return; // return if already allocated 383| | 384| 2| unsigned int m = num * dims; 385| 2| rawData.reserve(m + (m >> 2u)); // 25% as extra storage for VMADs 386| 2| rawData.resize(m); 387| | 388| 438| for (aiColor4D *p = (aiColor4D *)&rawData[0]; p < (aiColor4D *)&rawData[m - 1]; ++p) ------------------ | Branch (388:55): [True: 436, False: 2] ------------------ 389| 436| p->a = 1.f; 390| | 391| 2| abAssigned.resize(num, false); 392| 2| } _ZN6Assimp3LWO9UVChannelC2Ev: 400| 8| VMapEntry(2) {} _ZN6Assimp3LWO13WeightChannelC2Ev: 408| 6| VMapEntry(1) {} _ZN6Assimp3LWO13NormalChannelC2Ev: 416| 39| VMapEntry(3) {} _ZN6Assimp3LWO7TextureC2Ev: 458| 2| mClipIdx(UINT_MAX), mStrength(1.0f), type(), mUVChannelIndex("unknown"), mRealUVIndex(UINT_MAX), enabled(true), blendType(Additive), bCanUse(true), mapMode(UV), majorAxis(AXIS_X), wrapAmountH(1.0f), wrapAmountW(1.0f), wrapModeWidth(REPEAT), wrapModeHeight(REPEAT), ordinal("\x00") {} _ZN6Assimp3LWO4ClipC2Ev: 512| 2| type(UNSUPPORTED), clipRef(), idx(0), negate(false) {} _ZN6Assimp3LWO7SurfaceC2Ev: 549| 15| mColor(0.78431f, 0.78431f, 0.78431f), bDoubleSided(false), mDiffuseValue(1.f), mSpecularValue(0.f), mTransparency(0.f), mGlossiness(0.4f), mLuminosity(0.f), mColorHighlights(0.f), mMaximumSmoothAngle(0.f) // 0 == not specified, no smoothing 550| | , 551| 15| mVCMap(), 552| | mVCMapType(AI_LWO_RGBA), 553| 15| mIOR(1.f) // vakuum 554| | , 555| 15| mBumpIntensity(1.f), 556| 15| mWireframe(false), 557| 15| mAdditiveTransparency(0.f) {} _ZN6Assimp3LWO5LayerC2Ev: 654| 39| mFaceIDXOfs(0), mPointIDXOfs(0), mParent(0x0), mIndex(0xffff), skip(false) {} _ZN6Assimp3LWO9VMapEntryD2Ev: 351| 115| virtual ~VMapEntry() = default; _ZN6Assimp3LWO4FaceaSERKS1_: 341| 5.73k| Face &operator=(const LWO::Face &f) = default; _ZNK6Assimp11LWOImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 82| 395|bool LWOImporter::CanRead(const std::string &file, IOSystem *pIOHandler, bool /*checkSig*/) const { 83| 395| static constexpr uint32_t tokens[] = { 84| 395| AI_LWO_FOURCC_LWOB, ------------------ | | 65| 395|#define AI_LWO_FOURCC_LWOB AI_IFF_FOURCC('L', 'W', 'O', 'B') | | ------------------ | | | | 50| 395|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 395| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ 85| 395| AI_LWO_FOURCC_LWO2, ------------------ | | 66| 395|#define AI_LWO_FOURCC_LWO2 AI_IFF_FOURCC('L', 'W', 'O', '2') | | ------------------ | | | | 50| 395|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 395| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ 86| 395| AI_LWO_FOURCC_LXOB ------------------ | | 68| 395|#define AI_LWO_FOURCC_LXOB AI_IFF_FOURCC('L', 'X', 'O', 'B') | | ------------------ | | | | 50| 395|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 395| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ 87| 395| }; 88| | return CheckMagicToken(pIOHandler, file, tokens, AI_COUNT_OF(tokens), 8); 89| 395|} _ZN6Assimp11LWOImporter15SetupPropertiesEPKNS_8ImporterE: 93| 15|void LWOImporter::SetupProperties(const Importer *pImp) { 94| 15| configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 0) ? true : false); ------------------ | Branch (94:24): [True: 0, False: 15] ------------------ 95| 15| configLayerIndex = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY, UINT_MAX); 96| | configLayerName = pImp->GetPropertyString(AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY, ""); 97| 15|} _ZNK6Assimp11LWOImporter7GetInfoEv: 101| 649|const aiImporterDesc *LWOImporter::GetInfo() const { 102| 649| return &desc; 103| 649|} _ZN6Assimp11LWOImporter14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 109| 15| IOSystem *pIOHandler) { 110| 15| std::unique_ptr file(pIOHandler->Open(pFile, "rb")); 111| | 112| | // Check whether we can read from the file 113| 15| if (file == nullptr) { ------------------ | Branch (113:9): [True: 0, False: 15] ------------------ 114| 0| throw DeadlyImportError("Failed to open LWO file ", pFile, "."); 115| 0| } 116| | 117| 15| if ((this->fileSize = (unsigned int)file->FileSize()) < 12) { ------------------ | Branch (117:9): [True: 0, False: 15] ------------------ 118| 0| throw DeadlyImportError("LWO: The file is too small to contain the IFF header"); 119| 0| } 120| | 121| | // Allocate storage and copy the contents of the file to a memory buffer 122| 15| std::vector mBuffer(fileSize); 123| 15| file->Read(&mBuffer[0], 1, fileSize); 124| 15| mScene = pScene; 125| | 126| | // Determine the type of the file 127| 15| uint32_t fileType; 128| 15| const char *sz = IFF::ReadHeader(&mBuffer[0], fileType); 129| 15| if (sz) { ------------------ | Branch (129:9): [True: 0, False: 15] ------------------ 130| 0| throw DeadlyImportError(sz); 131| 0| } 132| | 133| 15| mFileBuffer = &mBuffer[0] + 12; 134| 15| mFileBufferEnd = &mBuffer[0] + fileSize; 135| 15| fileSize -= 12; 136| | 137| | // Initialize some members with their default values 138| 15| hasNamedLayer = false; 139| | 140| | // Create temporary storage on the stack but store pointers to it in the class 141| | // instance. Therefore everything will be destructed properly if an exception 142| | // is thrown and we needn't take care of that. 143| 15| LayerList _mLayers; 144| 15| SurfaceList _mSurfaces; 145| 15| TagList _mTags; 146| 15| TagMappingTable _mMapping; 147| | 148| 15| mLayers = &_mLayers; 149| 15| mTags = &_mTags; 150| 15| mMapping = &_mMapping; 151| 15| mSurfaces = &_mSurfaces; 152| | 153| | // Allocate a default layer (layer indices are 1-based from now) 154| 15| mLayers->push_back(Layer()); 155| 15| mCurLayer = &mLayers->back(); 156| 15| mCurLayer->mName = ""; 157| 15| mCurLayer->mIndex = 1; 158| | 159| | // old lightwave file format (prior to v6) 160| 15| mIsLWO2 = false; 161| 15| mIsLWO3 = false; 162| 15| mIsLXOB = false; 163| | 164| 15| if (AI_LWO_FOURCC_LWOB == fileType) { ------------------ | | 65| 15|#define AI_LWO_FOURCC_LWOB AI_IFF_FOURCC('L', 'W', 'O', 'B') | | ------------------ | | | | 50| 15|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 15| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (164:9): [True: 0, False: 15] ------------------ 165| 0| ASSIMP_LOG_INFO("LWO file format: LWOB (<= LightWave 5.5)"); 166| | 167| 0| LoadLWOBFile(); 168| 15| } else if (AI_LWO_FOURCC_LWO2 == fileType) { ------------------ | | 66| 15|#define AI_LWO_FOURCC_LWO2 AI_IFF_FOURCC('L', 'W', 'O', '2') | | ------------------ | | | | 50| 15|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 15| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (168:16): [True: 8, False: 7] ------------------ 169| | // New lightwave format 170| 8| ASSIMP_LOG_INFO("LWO file format: LWO2 (>= LightWave 6)"); 171| 8| } else if ( AI_LWO_FOURCC_LWO3 == fileType ) { ------------------ | | 67| 7|#define AI_LWO_FOURCC_LWO3 AI_IFF_FOURCC('L', 'W', 'O', '3') | | ------------------ | | | | 50| 7|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 7| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (171:17): [True: 0, False: 7] ------------------ 172| 0| ASSIMP_LOG_INFO("LWO file format: LWO3 (>= LightWave 2018)"); 173| 7| } else if (AI_LWO_FOURCC_LXOB == fileType) { ------------------ | | 68| 7|#define AI_LWO_FOURCC_LXOB AI_IFF_FOURCC('L', 'X', 'O', 'B') | | ------------------ | | | | 50| 7|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 7| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (173:16): [True: 7, False: 0] ------------------ 174| | // MODO file format 175| 7| mIsLXOB = true; 176| 7| ASSIMP_LOG_INFO("LWO file format: LXOB (Modo)"); 177| 7| } 178| 0| else { 179| 0| char szBuff[5]; 180| 0| szBuff[0] = (char)(fileType >> 24u); 181| 0| szBuff[1] = (char)(fileType >> 16u); 182| 0| szBuff[2] = (char)(fileType >> 8u); 183| 0| szBuff[3] = (char)(fileType); 184| 0| szBuff[4] = '\0'; 185| 0| throw DeadlyImportError("Unknown LWO sub format: ", szBuff); 186| 0| } 187| | 188| 15| if (AI_LWO_FOURCC_LWOB != fileType) { // ------------------ | | 65| 15|#define AI_LWO_FOURCC_LWOB AI_IFF_FOURCC('L', 'W', 'O', 'B') | | ------------------ | | | | 50| 15|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 15| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (188:9): [True: 15, False: 0] ------------------ 189| 15| if( AI_LWO_FOURCC_LWO3 == fileType ) { ------------------ | | 67| 15|#define AI_LWO_FOURCC_LWO3 AI_IFF_FOURCC('L', 'W', 'O', '3') | | ------------------ | | | | 50| 15|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 15| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (189:13): [True: 0, False: 15] ------------------ 190| 0| mIsLWO3 = true; 191| 15| } else { 192| 15| mIsLWO2 = true; 193| 15| } 194| | 195| 15| LoadLWO2File(); 196| | 197| | // The newer lightwave format allows the user to configure the 198| | // loader that just one layer is used. If this is the case 199| | // we need to check now whether the requested layer has been found. 200| 15| if (UINT_MAX != configLayerIndex) { ------------------ | Branch (200:13): [True: 0, False: 15] ------------------ 201| 0| unsigned int layerCount = 0; 202| 0| for (std::list::iterator itLayers = mLayers->begin(); itLayers != mLayers->end(); ++itLayers) ------------------ | Branch (202:79): [True: 0, False: 0] ------------------ 203| 0| if (!itLayers->skip) ------------------ | Branch (203:21): [True: 0, False: 0] ------------------ 204| 0| layerCount++; 205| 0| if (layerCount != 2) ------------------ | Branch (205:17): [True: 0, False: 0] ------------------ 206| 0| throw DeadlyImportError("LWO2: The requested layer was not found"); 207| 0| } 208| | 209| 15| if (configLayerName.length() && !hasNamedLayer) { ------------------ | Branch (209:13): [True: 0, False: 15] | Branch (209:41): [True: 0, False: 0] ------------------ 210| 0| throw DeadlyImportError("LWO2: Unable to find the requested layer: ", configLayerName); 211| 0| } 212| 15| } 213| | 214| | // now, as we have loaded all data, we can resolve cross-referenced tags and clips 215| 15| ResolveTags(); 216| 15| ResolveClips(); 217| | 218| | // now process all layers and build meshes and nodes 219| 15| std::vector apcMeshes; 220| 15| std::map apcNodes; 221| | 222| 15| apcMeshes.reserve(mLayers->size() * std::min(((unsigned int)mSurfaces->size() / 2u), 1u)); 223| | 224| 15| unsigned int iDefaultSurface = UINT_MAX; // index of the default surface 225| 25| for (LWO::Layer &layer : *mLayers) { ------------------ | Branch (225:28): [True: 25, False: 15] ------------------ 226| 25| if (layer.skip) ------------------ | Branch (226:13): [True: 0, False: 25] ------------------ 227| 0| continue; 228| | 229| | // I don't know whether there could be dummy layers, but it would be possible 230| 25| const unsigned int meshStart = (unsigned int)apcMeshes.size(); 231| 25| if (!layer.mFaces.empty() && !layer.mTempPoints.empty()) { ------------------ | Branch (231:13): [True: 17, False: 8] | Branch (231:38): [True: 17, False: 0] ------------------ 232| | 233| | // now sort all faces by the surfaces assigned to them 234| 17| std::vector pSorted(mSurfaces->size() + 1); 235| | 236| 17| unsigned int i = 0; 237| 3.24k| for (FaceList::iterator it = layer.mFaces.begin(), end = layer.mFaces.end(); it != end; ++it, ++i) { ------------------ | Branch (237:90): [True: 3.22k, False: 17] ------------------ 238| | // Check whether we support this face's type 239| 3.22k| if ((*it).type != AI_LWO_FACE && (*it).type != AI_LWO_PTCH && ------------------ | | 117| 3.22k|#define AI_LWO_FACE AI_IFF_FOURCC('F', 'A', 'C', 'E') | | ------------------ | | | | 50| 6.45k|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 6.45k| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ if ((*it).type != AI_LWO_FACE && (*it).type != AI_LWO_PTCH && ------------------ | | 119| 0|#define AI_LWO_PTCH AI_IFF_FOURCC('P', 'T', 'C', 'H') | | ------------------ | | | | 50| 3.22k|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 3.22k| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (239:21): [True: 0, False: 3.22k] | Branch (239:50): [True: 0, False: 0] ------------------ 240| 3.22k| (*it).type != AI_LWO_BONE && (*it).type != AI_LWO_SUBD) { ------------------ | | 121| 0|#define AI_LWO_BONE AI_IFF_FOURCC('B', 'O', 'N', 'E') | | ------------------ | | | | 50| 3.22k|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 3.22k| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ (*it).type != AI_LWO_BONE && (*it).type != AI_LWO_SUBD) { ------------------ | | 122| 0|#define AI_LWO_SUBD AI_IFF_FOURCC('S', 'U', 'B', 'D') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (240:25): [True: 0, False: 0] | Branch (240:54): [True: 0, False: 0] ------------------ 241| 0| continue; 242| 0| } 243| | 244| 3.22k| unsigned int idx = (*it).surfaceIndex; 245| 3.22k| if (idx >= mTags->size()) { ------------------ | Branch (245:21): [True: 0, False: 3.22k] ------------------ 246| 0| ASSIMP_LOG_WARN("LWO: Invalid face surface index"); 247| 0| idx = UINT_MAX; 248| 0| } 249| 3.22k| if (UINT_MAX == idx || UINT_MAX == (idx = _mMapping[idx])) { ------------------ | Branch (249:21): [True: 0, False: 3.22k] | Branch (249:40): [True: 1.54k, False: 1.68k] ------------------ 250| 1.54k| if (UINT_MAX == iDefaultSurface) { ------------------ | Branch (250:25): [True: 3, False: 1.53k] ------------------ 251| 3| iDefaultSurface = (unsigned int)mSurfaces->size(); 252| 3| mSurfaces->push_back(LWO::Surface()); 253| 3| LWO::Surface &surf = mSurfaces->back(); 254| 3| surf.mColor.r = surf.mColor.g = surf.mColor.b = 0.6f; 255| 3| surf.mName = "LWODefaultSurface"; 256| 3| } 257| 1.54k| idx = iDefaultSurface; 258| 1.54k| } 259| 3.22k| pSorted[idx].push_back(i); 260| 3.22k| } 261| 17| if (UINT_MAX == iDefaultSurface) { ------------------ | Branch (261:17): [True: 12, False: 5] ------------------ 262| 12| pSorted.erase(pSorted.end() - 1); 263| 12| } 264| 61| for (unsigned int j = 0; j < mSurfaces->size(); ++j) { ------------------ | Branch (264:38): [True: 44, False: 17] ------------------ 265| 44| SortedRep &sorted = pSorted[j]; 266| 44| if (sorted.empty()) ------------------ | Branch (266:21): [True: 26, False: 18] ------------------ 267| 26| continue; 268| | 269| | // generate the mesh 270| 18| aiMesh *mesh = new aiMesh(); 271| 18| apcMeshes.push_back(mesh); 272| 18| mesh->mNumFaces = (unsigned int)sorted.size(); 273| | 274| | // count the number of vertices 275| 18| SortedRep::const_iterator it = sorted.begin(), end = sorted.end(); 276| 3.24k| for (; it != end; ++it) { ------------------ | Branch (276:24): [True: 3.22k, False: 18] ------------------ 277| 3.22k| mesh->mNumVertices += layer.mFaces[*it].mNumIndices; 278| 3.22k| } 279| | 280| 18| aiVector3D *nrm = nullptr, *pv = mesh->mVertices = new aiVector3D[mesh->mNumVertices]; 281| 18| aiFace *pf = mesh->mFaces = new aiFace[mesh->mNumFaces]; 282| 18| mesh->mMaterialIndex = j; 283| | 284| | // find out which vertex color channels and which texture coordinate 285| | // channels are really required by the material attached to this mesh 286| 18| unsigned int vUVChannelIndices[AI_MAX_NUMBER_OF_TEXTURECOORDS]; 287| 18| unsigned int vVColorIndices[AI_MAX_NUMBER_OF_COLOR_SETS]; 288| | 289| 18|#ifdef ASSIMP_BUILD_DEBUG 290| 162| for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++mui) { ------------------ | Branch (290:44): [True: 144, False: 18] ------------------ 291| 144| vUVChannelIndices[mui] = UINT_MAX; 292| 144| } 293| 162| for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_COLOR_SETS; ++mui) { ------------------ | Branch (293:44): [True: 144, False: 18] ------------------ 294| 144| vVColorIndices[mui] = UINT_MAX; 295| 144| } 296| 18|#endif 297| | 298| 18| FindUVChannels(_mSurfaces[j], sorted, layer, vUVChannelIndices); 299| 18| FindVCChannels(_mSurfaces[j], sorted, layer, vVColorIndices); 300| | 301| | // allocate storage for UV and CV channels 302| 18| aiVector3D *pvUV[AI_MAX_NUMBER_OF_TEXTURECOORDS]; 303| 22| for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++mui) { ------------------ | Branch (303:44): [True: 22, False: 0] ------------------ 304| 22| if (UINT_MAX == vUVChannelIndices[mui]) { ------------------ | Branch (304:25): [True: 18, False: 4] ------------------ 305| 18| break; 306| 18| } 307| | 308| 4| pvUV[mui] = mesh->mTextureCoords[mui] = new aiVector3D[mesh->mNumVertices]; 309| | 310| | // LightWave doesn't support more than 2 UV components (?) 311| 4| mesh->mNumUVComponents[0] = 2; 312| 4| } 313| | 314| 18| if (layer.mNormals.name.length()) { ------------------ | Branch (314:21): [True: 2, False: 16] ------------------ 315| 2| nrm = mesh->mNormals = new aiVector3D[mesh->mNumVertices]; 316| 2| } 317| | 318| 18| aiColor4D *pvVC[AI_MAX_NUMBER_OF_COLOR_SETS]; 319| 20| for (unsigned int mui = 0; mui < AI_MAX_NUMBER_OF_COLOR_SETS; ++mui) { ------------------ | Branch (319:44): [True: 20, False: 0] ------------------ 320| 20| if (UINT_MAX == vVColorIndices[mui]) { ------------------ | Branch (320:25): [True: 18, False: 2] ------------------ 321| 18| break; 322| 18| } 323| 2| pvVC[mui] = mesh->mColors[mui] = new aiColor4D[mesh->mNumVertices]; 324| 2| } 325| | 326| | // we would not need this extra array, but the code is much cleaner if we use it 327| 18| std::vector &smoothingGroups = layer.mPointReferrers; 328| 18| smoothingGroups.erase(smoothingGroups.begin(), smoothingGroups.end()); 329| 18| smoothingGroups.resize(mesh->mNumFaces, 0); 330| | 331| | // now convert all faces 332| 18| unsigned int vert = 0; 333| 18| std::vector::iterator outIt = smoothingGroups.begin(); 334| 3.24k| for (it = sorted.begin(); it != end; ++it, ++outIt) { ------------------ | Branch (334:43): [True: 3.22k, False: 18] ------------------ 335| 3.22k| const LWO::Face &face = layer.mFaces[*it]; 336| 3.22k| *outIt = face.smoothGroup; 337| | 338| | // copy all vertices 339| 15.8k| for (unsigned int q = 0; q < face.mNumIndices; ++q, ++vert) { ------------------ | Branch (339:46): [True: 12.6k, False: 3.22k] ------------------ 340| 12.6k| unsigned int idx = face.mIndices[q]; 341| 12.6k| *pv++ = layer.mTempPoints[idx] /*- layer.mPivot*/; 342| | 343| | // process UV coordinates 344| 20.3k| for (unsigned int w = 0; w < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++w) { ------------------ | Branch (344:50): [True: 20.3k, False: 0] ------------------ 345| 20.3k| if (UINT_MAX == vUVChannelIndices[w]) { ------------------ | Branch (345:33): [True: 12.6k, False: 7.71k] ------------------ 346| 12.6k| break; 347| 12.6k| } 348| 7.71k| aiVector3D *&pp = pvUV[w]; 349| 7.71k| const aiVector2D &src = ((aiVector2D *)&layer.mUVChannels[vUVChannelIndices[w]].rawData[0])[idx]; 350| 7.71k| pp->x = src.x; 351| 7.71k| pp->y = src.y; 352| 7.71k| pp++; 353| 7.71k| } 354| | 355| | // process normals (MODO extension) 356| 12.6k| if (nrm) { ------------------ | Branch (356:29): [True: 2.20k, False: 10.4k] ------------------ 357| 2.20k| *nrm = ((aiVector3D *)&layer.mNormals.rawData[0])[idx]; 358| 2.20k| nrm->z *= -1.f; 359| 2.20k| ++nrm; 360| 2.20k| } 361| | 362| | // process vertex colors 363| 14.2k| for (unsigned int w = 0; w < AI_MAX_NUMBER_OF_COLOR_SETS; ++w) { ------------------ | Branch (363:50): [True: 14.2k, False: 0] ------------------ 364| 14.2k| if (UINT_MAX == vVColorIndices[w]) { ------------------ | Branch (364:33): [True: 12.6k, False: 1.64k] ------------------ 365| 12.6k| break; 366| 12.6k| } 367| 1.64k| *pvVC[w] = ((aiColor4D *)&layer.mVColorChannels[vVColorIndices[w]].rawData[0])[idx]; 368| | 369| | // If a RGB color map is explicitly requested delete the 370| | // alpha channel - it could theoretically be != 1. 371| 1.64k| if (_mSurfaces[j].mVCMapType == AI_LWO_RGB) ------------------ | | 243| 1.64k|#define AI_LWO_RGB AI_IFF_FOURCC('R', 'G', 'B', ' ') | | ------------------ | | | | 50| 1.64k|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 1.64k| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (371:33): [True: 1.64k, False: 0] ------------------ 372| 1.64k| pvVC[w]->a = 1.f; 373| | 374| 1.64k| pvVC[w]++; 375| 1.64k| } 376| | 377| 12.6k| face.mIndices[q] = vert; 378| 12.6k| } 379| 3.22k| pf->mIndices = face.mIndices; 380| 3.22k| pf->mNumIndices = face.mNumIndices; 381| 3.22k| unsigned int **facePtr = (unsigned int **)&face.mIndices; 382| 3.22k| *facePtr = nullptr; // HACK: make sure it won't be deleted 383| 3.22k| pf++; 384| 3.22k| } 385| | 386| 18| if (!mesh->mNormals) { ------------------ | Branch (386:21): [True: 16, False: 2] ------------------ 387| | // Compute normal vectors for the mesh - we can't use our GenSmoothNormal- 388| | // Step here since it wouldn't handle smoothing groups correctly for LWO. 389| | // So we use a separate implementation. 390| 16| ComputeNormals(mesh, smoothingGroups, _mSurfaces[j]); 391| 16| } else { 392| 2| ASSIMP_LOG_VERBOSE_DEBUG("LWO2: No need to compute normals, they're already there"); 393| 2| } 394| 18| } 395| 17| } 396| | 397| | // Generate nodes to render the mesh. Store the source layer in the mParent member of the nodes 398| 25| unsigned int num = static_cast(apcMeshes.size() - meshStart); 399| 25| if (layer.mName != "" || num > 0) { ------------------ | Branch (399:13): [True: 17, False: 8] | Branch (399:46): [True: 0, False: 8] ------------------ 400| 17| std::unique_ptr pcNode(new aiNode()); 401| 17| pcNode->mName.Set(layer.mName); 402| 17| pcNode->mParent = (aiNode *)&layer; 403| 17| pcNode->mNumMeshes = num; 404| | 405| 17| if (pcNode->mNumMeshes) { ------------------ | Branch (405:17): [True: 17, False: 0] ------------------ 406| 17| pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes]; 407| 35| for (unsigned int p = 0; p < pcNode->mNumMeshes; ++p) ------------------ | Branch (407:42): [True: 18, False: 17] ------------------ 408| 18| pcNode->mMeshes[p] = p + meshStart; 409| 17| } 410| 17| ASSIMP_LOG_DEBUG("insert apcNode for layer ", layer.mIndex, " \"", layer.mName, "\""); 411| 17| apcNodes[layer.mIndex] = pcNode.release(); 412| 17| } 413| 25| } 414| | 415| 15| if (apcNodes.empty() || apcMeshes.empty()) ------------------ | Branch (415:9): [True: 7, False: 8] | Branch (415:29): [True: 0, False: 8] ------------------ 416| 0| throw DeadlyImportError("LWO: No meshes loaded"); 417| | 418| | // The RemoveRedundantMaterials step will clean this up later 419| 15| pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials = (unsigned int)mSurfaces->size()]; 420| | 421| 30| for (unsigned int mat = 0; mat < pScene->mNumMaterials; ++mat) { ------------------ | Branch (421:32): [True: 15, False: 15] ------------------ 422| 15| aiMaterial *pcMat = new aiMaterial(); 423| 15| pScene->mMaterials[mat] = pcMat; 424| 15| ConvertMaterial((*mSurfaces)[mat], pcMat); 425| 15| } 426| | 427| | // copy the meshes to the output structure 428| 15| pScene->mMeshes = new aiMesh *[pScene->mNumMeshes = (unsigned int)apcMeshes.size()]; 429| 15| ::memcpy(pScene->mMeshes, &apcMeshes[0], pScene->mNumMeshes * sizeof(void *)); 430| | 431| | // generate the final node graph 432| 15| GenerateNodeGraph(apcNodes); 433| 15|} _ZN6Assimp11LWOImporter14ComputeNormalsEP6aiMeshRKNSt3__16vectorIjNS3_9allocatorIjEEEERKNS_3LWO7SurfaceE: 437| 16| const LWO::Surface &surface) { 438| | // Allocate output storage 439| 16| mesh->mNormals = new aiVector3D[mesh->mNumVertices]; 440| | 441| | // First generate per-face normals 442| 16| aiVector3D *out; 443| 16| std::vector faceNormals; 444| | 445| | // ... in some cases that's already enough 446| 16| if (!surface.mMaximumSmoothAngle) ------------------ | Branch (446:9): [True: 6, False: 10] ------------------ 447| 6| out = mesh->mNormals; 448| 10| else { 449| 10| faceNormals.resize(mesh->mNumVertices); 450| 10| out = &faceNormals[0]; 451| 10| } 452| | 453| 16| aiFace *begin = mesh->mFaces, *const end = mesh->mFaces + mesh->mNumFaces; 454| 2.66k| for (; begin != end; ++begin) { ------------------ | Branch (454:12): [True: 2.65k, False: 16] ------------------ 455| 2.65k| aiFace &face = *begin; 456| | 457| 2.65k| if (face.mNumIndices < 3) { ------------------ | Branch (457:13): [True: 0, False: 2.65k] ------------------ 458| 0| continue; 459| 0| } 460| | 461| | // LWO doc: "the normal is defined as the cross product of the first and last edges" 462| 2.65k| aiVector3D *pV1 = mesh->mVertices + face.mIndices[0]; 463| 2.65k| aiVector3D *pV2 = mesh->mVertices + face.mIndices[1]; 464| 2.65k| aiVector3D *pV3 = mesh->mVertices + face.mIndices[face.mNumIndices - 1]; 465| | 466| 2.65k| aiVector3D vNor = ((*pV2 - *pV1) ^ (*pV3 - *pV1)).Normalize(); 467| 13.0k| for (unsigned int i = 0; i < face.mNumIndices; ++i) ------------------ | Branch (467:34): [True: 10.4k, False: 2.65k] ------------------ 468| 10.4k| out[face.mIndices[i]] = vNor; 469| 2.65k| } 470| 16| if (!surface.mMaximumSmoothAngle) return; ------------------ | Branch (470:9): [True: 6, False: 10] ------------------ 471| 10| const float posEpsilon = ComputePositionEpsilon(mesh); 472| | 473| | // Now generate the spatial sort tree 474| 10| SGSpatialSort sSort; 475| 10| std::vector::const_iterator it = smoothingGroups.begin(); 476| 633| for (begin = mesh->mFaces; begin != end; ++begin, ++it) { ------------------ | Branch (476:32): [True: 623, False: 10] ------------------ 477| 623| aiFace &face = *begin; 478| 3.02k| for (unsigned int i = 0; i < face.mNumIndices; ++i) { ------------------ | Branch (478:34): [True: 2.39k, False: 623] ------------------ 479| 2.39k| unsigned int tt = face.mIndices[i]; 480| 2.39k| sSort.Add(mesh->mVertices[tt], tt, *it); 481| 2.39k| } 482| 623| } 483| | // Sort everything - this takes O(nlogn) time 484| 10| sSort.Prepare(); 485| 10| std::vector poResult; 486| 10| poResult.reserve(20); 487| | 488| | // Generate vertex normals. We have O(logn) for the binary lookup, which we need 489| | // for n elements, thus the EXPECTED complexity is O(nlogn) 490| 10| if (surface.mMaximumSmoothAngle < 3.f && !configSpeedFlag) { ------------------ | Branch (490:9): [True: 10, False: 0] | Branch (490:46): [True: 10, False: 0] ------------------ 491| 10| const float fLimit = std::cos(surface.mMaximumSmoothAngle); 492| | 493| 633| for (begin = mesh->mFaces, it = smoothingGroups.begin(); begin != end; ++begin, ++it) { ------------------ | Branch (493:66): [True: 623, False: 10] ------------------ 494| 623| const aiFace &face = *begin; 495| 623| unsigned int *beginIdx = face.mIndices, *const endIdx = face.mIndices + face.mNumIndices; 496| 3.02k| for (; beginIdx != endIdx; ++beginIdx) { ------------------ | Branch (496:20): [True: 2.39k, False: 623] ------------------ 497| 2.39k| unsigned int idx = *beginIdx; 498| 2.39k| sSort.FindPositions(mesh->mVertices[idx], *it, posEpsilon, poResult, true); 499| | 500| 2.39k| aiVector3D vNormals; 501| 13.6k| for (std::vector::const_iterator a = poResult.begin(); a != poResult.end(); ++a) { ------------------ | Branch (501:87): [True: 11.2k, False: 2.39k] ------------------ 502| 11.2k| const aiVector3D &v = faceNormals[*a]; 503| 11.2k| if (v * faceNormals[idx] < fLimit) ------------------ | Branch (503:25): [True: 96, False: 11.1k] ------------------ 504| 96| continue; 505| 11.1k| vNormals += v; 506| 11.1k| } 507| 2.39k| mesh->mNormals[idx] = vNormals.Normalize(); 508| 2.39k| } 509| 623| } 510| 10| } 511| | // faster code path in case there is no smooth angle 512| 0| else { 513| 0| std::vector vertexDone(mesh->mNumVertices, false); 514| 0| for (begin = mesh->mFaces, it = smoothingGroups.begin(); begin != end; ++begin, ++it) { ------------------ | Branch (514:66): [True: 0, False: 0] ------------------ 515| 0| const aiFace &face = *begin; 516| 0| unsigned int *beginIdx = face.mIndices, *const endIdx = face.mIndices + face.mNumIndices; 517| 0| for (; beginIdx != endIdx; ++beginIdx) { ------------------ | Branch (517:20): [True: 0, False: 0] ------------------ 518| 0| unsigned int idx = *beginIdx; 519| 0| if (vertexDone[idx]) ------------------ | Branch (519:21): [True: 0, False: 0] ------------------ 520| 0| continue; 521| 0| sSort.FindPositions(mesh->mVertices[idx], *it, posEpsilon, poResult, true); 522| | 523| 0| aiVector3D vNormals; 524| 0| for (std::vector::const_iterator a = poResult.begin(); a != poResult.end(); ++a) { ------------------ | Branch (524:87): [True: 0, False: 0] ------------------ 525| 0| const aiVector3D &v = faceNormals[*a]; 526| 0| vNormals += v; 527| 0| } 528| 0| vNormals.Normalize(); 529| 0| for (std::vector::const_iterator a = poResult.begin(); a != poResult.end(); ++a) { ------------------ | Branch (529:86): [True: 0, False: 0] ------------------ 530| 0| mesh->mNormals[*a] = vNormals; 531| 0| vertexDone[*a] = true; 532| 0| } 533| 0| } 534| 0| } 535| 0| } 536| 10| GeometryUtils::normalizeVectorArray(mesh->mNormals, mesh->mNormals, mesh->mNumVertices); 537| 10|} _ZN6Assimp11LWOImporter17GenerateNodeGraphERNSt3__13mapItP6aiNodeNS1_4lessItEENS1_9allocatorINS1_4pairIKtS4_EEEEEE: 540| 8|void LWOImporter::GenerateNodeGraph(std::map &apcNodes) { 541| | // now generate the final nodegraph - generate a root node and attach children 542| 8| aiNode *root = mScene->mRootNode = new aiNode(); 543| 8| root->mName.Set(""); 544| | 545| 8| ASSIMP_LOG_DEBUG("apcNodes initial size: ", apcNodes.size()); 546| 8| if (!apcNodes.empty()) { ------------------ | Branch (546:9): [True: 8, False: 0] ------------------ 547| 8| ASSIMP_LOG_DEBUG("first apcNode is: ", apcNodes.begin()->first, " \"", apcNodes.begin()->second->mName.C_Str(), "\""); 548| 8| } 549| | 550| | //Set parent of all children, inserting pivots 551| 8| { 552| 8| std::map mapPivot; 553| 25| for (auto itapcNodes = apcNodes.begin(); itapcNodes != apcNodes.end(); ++itapcNodes) { ------------------ | Branch (553:50): [True: 17, False: 8] ------------------ 554| | 555| | //Get the parent index 556| 17| LWO::Layer *nodeLayer = (LWO::Layer *)(itapcNodes->second->mParent); 557| 17| uint16_t parentIndex = nodeLayer->mParent; 558| | 559| | //Create pivot node, store it into the pivot map, and set the parent as the pivot 560| 17| std::unique_ptr pivotNode(new aiNode()); 561| 17| pivotNode->mName.Set("Pivot-" + std::string(itapcNodes->second->mName.data)); 562| 17| itapcNodes->second->mParent = pivotNode.get(); 563| | 564| | //Look for the parent node to attach the pivot to 565| 17| if (apcNodes.find(parentIndex) != apcNodes.end()) { ------------------ | Branch (565:17): [True: 9, False: 8] ------------------ 566| 9| pivotNode->mParent = apcNodes[parentIndex]; 567| 9| } else { 568| | //If not, attach to the root node 569| 8| pivotNode->mParent = root; 570| 8| } 571| | 572| | //Set the node and the pivot node transformation 573| 17| itapcNodes->second->mTransformation.a4 = -nodeLayer->mPivot.x; 574| 17| itapcNodes->second->mTransformation.b4 = -nodeLayer->mPivot.y; 575| 17| itapcNodes->second->mTransformation.c4 = -nodeLayer->mPivot.z; 576| 17| pivotNode->mTransformation.a4 = nodeLayer->mPivot.x; 577| 17| pivotNode->mTransformation.b4 = nodeLayer->mPivot.y; 578| 17| pivotNode->mTransformation.c4 = nodeLayer->mPivot.z; 579| 17| uint16_t pivotNodeId = static_cast(-(itapcNodes->first + 2)); 580| 17| ASSIMP_LOG_DEBUG("insert pivot node: ", pivotNodeId); 581| 17| auto oldNodeIt = mapPivot.find(pivotNodeId); 582| 17| if (oldNodeIt != mapPivot.end()) { ------------------ | Branch (582:17): [True: 0, False: 17] ------------------ 583| 0| ASSIMP_LOG_ERROR("attempted to insert pivot node which already exists in pivot map ", pivotNodeId, " \"", pivotNode->mName.C_Str(), "\""); 584| 17| } else { 585| 17| mapPivot.emplace(pivotNodeId, pivotNode.release()); 586| 17| } 587| 17| } 588| | 589| 8| ASSIMP_LOG_DEBUG("pivot nodes: ", mapPivot.size()); 590| | //Merge pivot map into node map 591| 25| for (auto itMapPivot = mapPivot.begin(); itMapPivot != mapPivot.end();) { ------------------ | Branch (591:50): [True: 17, False: 8] ------------------ 592| 17| uint16_t pivotNodeId = itMapPivot->first; 593| 17| auto oldApcNodeIt = apcNodes.find(pivotNodeId); 594| 17| if (oldApcNodeIt != apcNodes.end()) { ------------------ | Branch (594:17): [True: 0, False: 17] ------------------ 595| 0| ASSIMP_LOG_ERROR("attempted to insert pivot node which already exists in apc nodes ", pivotNodeId, " \"", itMapPivot->second->mName.C_Str(), "\""); 596| 17| } else { 597| 17| apcNodes.emplace(pivotNodeId, itMapPivot->second); 598| 17| } 599| 17| itMapPivot->second = nullptr; 600| 17| itMapPivot = mapPivot.erase(itMapPivot); 601| 17| } 602| 8| ASSIMP_LOG_DEBUG("total nodes: ", apcNodes.size()); 603| 8| } 604| | 605| | //Set children of all parents 606| 8| apcNodes[(uint16_t)-1] = root; 607| 50| for (auto itMapParentNodes = apcNodes.begin(); itMapParentNodes != apcNodes.end(); ++itMapParentNodes) { ------------------ | Branch (607:52): [True: 42, False: 8] ------------------ 608| 330| for (auto itMapChildNodes = apcNodes.begin(); itMapChildNodes != apcNodes.end(); ++itMapChildNodes) { ------------------ | Branch (608:55): [True: 288, False: 42] ------------------ 609| 288| if ((itMapParentNodes->first != itMapChildNodes->first) && (itMapParentNodes->second == itMapChildNodes->second->mParent)) { ------------------ | Branch (609:17): [True: 246, False: 42] | Branch (609:72): [True: 34, False: 212] ------------------ 610| 34| ++(itMapParentNodes->second->mNumChildren); 611| 34| } 612| 288| } 613| 42| if (itMapParentNodes->second->mNumChildren) { ------------------ | Branch (613:13): [True: 31, False: 11] ------------------ 614| 31| itMapParentNodes->second->mChildren = new aiNode *[itMapParentNodes->second->mNumChildren]; 615| 31| uint16_t p = 0; 616| 250| for (auto itMapChildNodes = apcNodes.begin(); itMapChildNodes != apcNodes.end(); ++itMapChildNodes) { ------------------ | Branch (616:59): [True: 219, False: 31] ------------------ 617| 219| if ((itMapParentNodes->first != itMapChildNodes->first) && (itMapParentNodes->second == itMapChildNodes->second->mParent)) { ------------------ | Branch (617:21): [True: 188, False: 31] | Branch (617:76): [True: 34, False: 154] ------------------ 618| 34| itMapParentNodes->second->mChildren[p++] = itMapChildNodes->second; 619| 34| } 620| 219| } 621| 31| } 622| 42| } 623| | 624| 8| if (!mScene->mRootNode->mNumChildren) { ------------------ | Branch (624:9): [True: 0, False: 8] ------------------ 625| 0| ASSIMP_LOG_DEBUG("All apcNodes:"); 626| 0| for (auto nodeIt = apcNodes.begin(); nodeIt != apcNodes.end(); ) { ------------------ | Branch (626:46): [True: 0, False: 0] ------------------ 627| 0| ASSIMP_LOG_DEBUG("Node ", nodeIt->first, " \"", nodeIt->second->mName.C_Str(), "\""); 628| 0| nodeIt->second = nullptr; 629| 0| nodeIt = apcNodes.erase(nodeIt); 630| 0| } 631| 0| throw DeadlyImportError("LWO: Unable to build a valid node graph"); 632| 0| } 633| | 634| | // Remove a single root node with no meshes assigned to it ... 635| 8| if (1 == mScene->mRootNode->mNumChildren) { ------------------ | Branch (635:9): [True: 8, False: 0] ------------------ 636| 8| aiNode *pc = mScene->mRootNode->mChildren[0]; 637| 8| pc->mParent = mScene->mRootNode->mChildren[0] = nullptr; 638| 8| delete mScene->mRootNode; 639| 8| mScene->mRootNode = pc; 640| 8| } 641| | 642| | // convert the whole stuff to RH with CCW winding 643| 8| MakeLeftHandedProcess maker; 644| 8| maker.Execute(mScene); 645| | 646| 8| FlipWindingOrderProcess flipper; 647| 8| flipper.Execute(mScene); 648| 8|} _ZN6Assimp11LWOImporter11ResolveTagsEv: 651| 8|void LWOImporter::ResolveTags() { 652| | // --- this function is used for both LWO2 and LWOB 653| 8| mMapping->resize(mTags->size(), UINT_MAX); 654| 28| for (unsigned int a = 0; a < mTags->size(); ++a) { ------------------ | Branch (654:30): [True: 20, False: 8] ------------------ 655| | 656| 20| const std::string &c = (*mTags)[a]; 657| 40| for (unsigned int i = 0; i < mSurfaces->size(); ++i) { ------------------ | Branch (657:34): [True: 32, False: 8] ------------------ 658| | 659| 32| const std::string &d = (*mSurfaces)[i].mName; 660| 32| if (!ASSIMP_stricmp(c, d)) { ------------------ | Branch (660:17): [True: 12, False: 20] ------------------ 661| | 662| 12| (*mMapping)[a] = i; 663| 12| break; 664| 12| } 665| 32| } 666| 20| } 667| 8|} _ZN6Assimp11LWOImporter12ResolveClipsEv: 670| 8|void LWOImporter::ResolveClips() { 671| 10| for (unsigned int i = 0; i < mClips.size(); ++i) { ------------------ | Branch (671:30): [True: 2, False: 8] ------------------ 672| | 673| 2| Clip &clip = mClips[i]; 674| 2| if (Clip::REF == clip.type) { ------------------ | Branch (674:13): [True: 0, False: 2] ------------------ 675| | 676| 0| if (clip.clipRef >= mClips.size()) { ------------------ | Branch (676:17): [True: 0, False: 0] ------------------ 677| 0| ASSIMP_LOG_ERROR("LWO2: Clip referrer index is out of range"); 678| 0| clip.clipRef = 0; 679| 0| } 680| | 681| 0| Clip &dest = mClips[clip.clipRef]; 682| 0| if (Clip::REF == dest.type) { ------------------ | Branch (682:17): [True: 0, False: 0] ------------------ 683| 0| ASSIMP_LOG_ERROR("LWO2: Clip references another clip reference"); 684| 0| clip.type = Clip::UNSUPPORTED; 685| 0| } 686| | 687| 0| else { 688| 0| clip.path = dest.path; 689| 0| clip.type = dest.type; 690| 0| } 691| 0| } 692| 2| } 693| 8|} _ZN6Assimp11LWOImporter17AdjustTexturePathERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 696| 2|void LWOImporter::AdjustTexturePath(std::string &out) { 697| | // --- this function is used for both LWO2 and LWOB 698| 2| if (!mIsLWO2 && !mIsLWO3 && ::strstr(out.c_str(), "(sequence)")) { ------------------ | Branch (698:9): [True: 0, False: 2] | Branch (698:21): [True: 0, False: 0] | Branch (698:33): [True: 0, False: 0] ------------------ 699| | 700| | // remove the (sequence) and append 000 701| 0| ASSIMP_LOG_INFO("LWOB: Sequence of animated texture found. It will be ignored"); 702| 0| out = out.substr(0, out.length() - 10) + "000"; 703| 0| } 704| | 705| | // format: drive:path/file - we just need to insert a slash after the drive 706| 2| std::string::size_type n = out.find_first_of(':'); 707| 2| if (std::string::npos != n) { ------------------ | Branch (707:9): [True: 1, False: 1] ------------------ 708| 1| out.insert(n + 1, "/"); 709| 1| } 710| 2|} _ZN6Assimp11LWOImporter11LoadLWOTagsEj: 713| 15|void LWOImporter::LoadLWOTags(unsigned int size) { 714| | // --- this function is used for both LWO2 and LWOB 715| | 716| 15| const char *szCur = (const char *)mFileBuffer, *szLast = szCur; 717| 15| const char *const szEnd = szLast + size; 718| 251| while (szCur < szEnd) { ------------------ | Branch (718:12): [True: 236, False: 15] ------------------ 719| 236| if (!(*szCur)) { ------------------ | Branch (719:13): [True: 32, False: 204] ------------------ 720| 32| const size_t len = (size_t)(szCur - szLast); 721| | // FIX: skip empty-sized tags 722| 32| if (len) ------------------ | Branch (722:17): [True: 32, False: 0] ------------------ 723| 32| mTags->push_back(std::string(szLast, len)); 724| 32| szCur += (len & 0x1 ? 1 : 2); ------------------ | Branch (724:23): [True: 29, False: 3] ------------------ 725| 32| szLast = szCur; 726| 32| } 727| 236| szCur++; 728| 236| } 729| 15|} _ZN6Assimp11LWOImporter13LoadLWOPointsEj: 732| 24|void LWOImporter::LoadLWOPoints(unsigned int length) { 733| | // --- this function is used for both LWO2 and LWOB but for 734| | // LWO2 we need to allocate 25% more storage - it could be we'll 735| | // need to duplicate some points later. 736| 24| const size_t vertexLen = 12; 737| 24| if ((length % vertexLen) != 0) { ------------------ | Branch (737:9): [True: 0, False: 24] ------------------ 738| 0| throw DeadlyImportError("LWO2: Points chunk length is not multiple of vertexLen (12)"); 739| 0| } 740| 24| unsigned int regularSize = (unsigned int)mCurLayer->mTempPoints.size() + length / 12; 741| 24| if (mIsLWO2 || mIsLWO3) { ------------------ | Branch (741:9): [True: 24, False: 0] | Branch (741:20): [True: 0, False: 0] ------------------ 742| 24| mCurLayer->mTempPoints.reserve(regularSize + (regularSize >> 2u)); 743| 24| mCurLayer->mTempPoints.resize(regularSize); 744| | 745| | // initialize all point referrers with the default values 746| 24| mCurLayer->mPointReferrers.reserve(regularSize + (regularSize >> 2u)); 747| 24| mCurLayer->mPointReferrers.resize(regularSize, UINT_MAX); 748| 24| } else 749| 0| mCurLayer->mTempPoints.resize(regularSize); 750| | 751| | // perform endianness conversions 752| 24|#ifndef AI_BUILD_BIG_ENDIAN 753| 26.5k| for (unsigned int i = 0; i> 2; ++i) ------------------ | Branch (753:30): [True: 26.5k, False: 24] ------------------ 754| 26.5k| ByteSwap::Swap4(mFileBuffer + (i << 2)); 755| 24|#endif 756| 24| ::memcpy(&mCurLayer->mTempPoints[0], mFileBuffer, length); 757| 24|} _ZN6Assimp11LWOImporter16LoadLWO2PolygonsEj: 760| 21|void LWOImporter::LoadLWO2Polygons(unsigned int length) { 761| 21| LE_NCONST uint16_t *const end = (LE_NCONST uint16_t *)(mFileBuffer + length); 762| 21| const uint32_t type = GetU4(); 763| | 764| | // Determine the type of the polygons 765| 21| switch (type) { 766| | // read unsupported stuff too (although we won't process it) 767| 0| case AI_LWO_MBAL: ------------------ | | 120| 0|#define AI_LWO_MBAL AI_IFF_FOURCC('M', 'B', 'A', 'L') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (767:9): [True: 0, False: 21] ------------------ 768| 0| ASSIMP_LOG_WARN("LWO2: Encountered unsupported primitive chunk (METABALL)"); 769| 0| break; 770| 0| case AI_LWO_CURV: ------------------ | | 118| 0|#define AI_LWO_CURV AI_IFF_FOURCC('C', 'U', 'R', 'V') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (770:9): [True: 0, False: 21] ------------------ 771| 0| ASSIMP_LOG_WARN("LWO2: Encountered unsupported primitive chunk (SPLINE)"); 772| 0| ; 773| 0| break; 774| | 775| | // These are ok with no restrictions 776| 0| case AI_LWO_PTCH: ------------------ | | 119| 0|#define AI_LWO_PTCH AI_IFF_FOURCC('P', 'T', 'C', 'H') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (776:9): [True: 0, False: 21] ------------------ 777| 21| case AI_LWO_FACE: ------------------ | | 117| 21|#define AI_LWO_FACE AI_IFF_FOURCC('F', 'A', 'C', 'E') | | ------------------ | | | | 50| 21|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 21| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (777:9): [True: 21, False: 0] ------------------ 778| 21| case AI_LWO_BONE: ------------------ | | 121| 21|#define AI_LWO_BONE AI_IFF_FOURCC('B', 'O', 'N', 'E') | | ------------------ | | | | 50| 21|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 21| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (778:9): [True: 0, False: 21] ------------------ 779| 21| case AI_LWO_SUBD: ------------------ | | 122| 21|#define AI_LWO_SUBD AI_IFF_FOURCC('S', 'U', 'B', 'D') | | ------------------ | | | | 50| 21|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 21| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (779:9): [True: 0, False: 21] ------------------ 780| 21| break; 781| 0| default: ------------------ | Branch (781:9): [True: 0, False: 21] ------------------ 782| | 783| | // hm!? wtf is this? ok ... 784| 0| ASSIMP_LOG_ERROR("LWO2: Ignoring unknown polygon type."); 785| 0| break; 786| 21| } 787| | 788| | // first find out how many faces and vertices we'll finally need 789| 21| uint16_t *cursor = (uint16_t *)mFileBuffer; 790| | 791| 21| unsigned int iNumFaces = 0, iNumVertices = 0; 792| 21| CountVertsAndFacesLWO2(iNumVertices, iNumFaces, cursor, end); 793| | 794| | // allocate the output array and copy face indices 795| 21| if (iNumFaces) { ------------------ | Branch (795:9): [True: 21, False: 0] ------------------ 796| 21| cursor = (uint16_t *)mFileBuffer; 797| | 798| 21| mCurLayer->mFaces.resize(iNumFaces, LWO::Face(type)); 799| 21| FaceList::iterator it = mCurLayer->mFaces.begin(); 800| 21| CopyFaceIndicesLWO2(it, cursor, end); 801| 21| } 802| 21|} _ZN6Assimp11LWOImporter22CountVertsAndFacesLWO2ERjS1_RPtPKtj: 806| 21| uint16_t *&cursor, const uint16_t *const end, unsigned int max) { 807| 5.75k| while (cursor < end && max--) { ------------------ | Branch (807:12): [True: 5.73k, False: 21] | Branch (807:28): [True: 5.73k, False: 0] ------------------ 808| 5.73k| uint16_t numIndices; 809| 5.73k| ::memcpy(&numIndices, cursor++, 2); 810| 5.73k| AI_LSWAP2(numIndices); 811| 5.73k| numIndices &= 0x03FF; 812| | 813| 5.73k| verts += numIndices; 814| 5.73k| ++faces; 815| | 816| 31.7k| for (uint16_t i = 0; i < numIndices; i++) { ------------------ | Branch (816:30): [True: 26.0k, False: 5.73k] ------------------ 817| 26.0k| ReadVSizedIntLWO2((uint8_t *&)cursor); 818| 26.0k| } 819| 5.73k| } 820| 21|} _ZN6Assimp11LWOImporter19CopyFaceIndicesLWO2ERNSt3__111__wrap_iterIPNS_3LWO4FaceEEERPtPKt: 825| 21| const uint16_t *const end) { 826| 5.74k| while (cursor < end) { ------------------ | Branch (826:12): [True: 5.72k, False: 20] ------------------ 827| 5.72k| LWO::Face &face = *it++; 828| 5.72k| uint16_t numIndices; 829| 5.72k| ::memcpy(&numIndices, cursor++, 2); 830| 5.72k| AI_LSWAP2(numIndices); 831| 5.72k| face.mNumIndices = numIndices & 0x03FF; 832| | 833| 5.72k| if (face.mNumIndices) /* byte swapping has already been done */ ------------------ | Branch (833:13): [True: 5.72k, False: 1] ------------------ 834| 5.72k| { 835| 5.72k| face.mIndices = new unsigned int[face.mNumIndices]; 836| 28.5k| for (unsigned int i = 0; i < face.mNumIndices; i++) { ------------------ | Branch (836:38): [True: 22.7k, False: 5.72k] ------------------ 837| 22.7k| face.mIndices[i] = ReadVSizedIntLWO2((uint8_t *&)cursor) + mCurLayer->mPointIDXOfs; 838| 22.7k| if (face.mIndices[i] > mCurLayer->mTempPoints.size()) { ------------------ | Branch (838:21): [True: 23, False: 22.7k] ------------------ 839| 23| ASSIMP_LOG_WARN("LWO2: Failure evaluating face record, index is out of range"); 840| 23| face.mIndices[i] = (unsigned int)mCurLayer->mTempPoints.size() - 1; 841| 23| } 842| 22.7k| } 843| 5.72k| } else 844| 1| throw DeadlyImportError("LWO2: Encountered invalid face record with zero indices"); 845| 5.72k| } 846| 21|} _ZN6Assimp11LWOImporter19LoadLWO2PolygonTagsEj: 849| 36|void LWOImporter::LoadLWO2PolygonTags(unsigned int length) { 850| 36| LE_NCONST uint8_t *const end = mFileBuffer + length; 851| | 852| 36| AI_LWO_VALIDATE_CHUNK_LENGTH(length, PTAG, 4); ------------------ | | 631| 36| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 36] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 853| 36| uint32_t type = GetU4(); 854| | 855| 36| if (type != AI_LWO_SURF && type != AI_LWO_SMGP) ------------------ | | 125| 36|#define AI_LWO_SURF AI_IFF_FOURCC('S', 'U', 'R', 'F') | | ------------------ | | | | 50| 72|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 72| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ if (type != AI_LWO_SURF && type != AI_LWO_SMGP) ------------------ | | 127| 20|#define AI_LWO_SMGP AI_IFF_FOURCC('S', 'M', 'G', 'P') | | ------------------ | | | | 50| 20|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 20| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (855:9): [True: 20, False: 16] | Branch (855:32): [True: 20, False: 0] ------------------ 856| 20| return; 857| | 858| 1.99k| while (mFileBuffer < end) { ------------------ | Branch (858:12): [True: 1.97k, False: 16] ------------------ 859| 1.97k| unsigned int i = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mFaceIDXOfs; 860| 1.97k| unsigned int j = GetU2(); 861| | 862| 1.97k| if (i >= mCurLayer->mFaces.size()) { ------------------ | Branch (862:13): [True: 32, False: 1.94k] ------------------ 863| 32| ASSIMP_LOG_WARN("LWO2: face index in PTAG is out of range"); 864| 32| continue; 865| 32| } 866| | 867| 1.94k| switch (type) { ------------------ | Branch (867:17): [True: 1.94k, False: 0] ------------------ 868| | 869| 1.94k| case AI_LWO_SURF: ------------------ | | 125| 1.94k|#define AI_LWO_SURF AI_IFF_FOURCC('S', 'U', 'R', 'F') | | ------------------ | | | | 50| 1.94k|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 1.94k| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (869:13): [True: 1.94k, False: 0] ------------------ 870| 1.94k| mCurLayer->mFaces[i].surfaceIndex = j; 871| 1.94k| break; 872| 0| case AI_LWO_SMGP: /* is that really used? */ ------------------ | | 127| 0|#define AI_LWO_SMGP AI_IFF_FOURCC('S', 'M', 'G', 'P') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (872:13): [True: 0, False: 1.94k] ------------------ 873| 0| mCurLayer->mFaces[i].smoothGroup = j; 874| 0| break; 875| 1.94k| }; 876| 1.94k| } 877| 16|} _ZN6Assimp11LWOImporter17LoadLWO2VertexMapEjb: 948| 29|void LWOImporter::LoadLWO2VertexMap(unsigned int length, bool perPoly) { 949| 29| LE_NCONST uint8_t *const end = mFileBuffer + length; 950| | 951| 29| AI_LWO_VALIDATE_CHUNK_LENGTH(length, VMAP, 6); ------------------ | | 631| 29| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 29] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 952| 29| unsigned int type = GetU4(); 953| 29| unsigned int dims = GetU2(); 954| | 955| 29| VMapEntry *base; 956| | 957| | // read the name of the vertex map 958| 29| std::string name; 959| 29| GetS0(name, length); 960| | 961| 29| switch (type) { 962| 13| case AI_LWO_TXUV: ------------------ | | 242| 13|#define AI_LWO_TXUV AI_IFF_FOURCC('T', 'X', 'U', 'V') | | ------------------ | | | | 50| 13|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 13| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (962:9): [True: 13, False: 16] ------------------ 963| 13| if (dims != 2) { ------------------ | Branch (963:17): [True: 0, False: 13] ------------------ 964| 0| ASSIMP_LOG_WARN("LWO2: Skipping UV channel \'", name, "\' with !2 components"); 965| 0| return; 966| 0| } 967| 13| base = FindEntry(mCurLayer->mUVChannels, name, perPoly); 968| 13| break; 969| 6| case AI_LWO_WGHT: ------------------ | | 245| 6|#define AI_LWO_WGHT AI_IFF_FOURCC('W', 'G', 'H', 'T') | | ------------------ | | | | 50| 6|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 6| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (969:9): [True: 6, False: 23] ------------------ 970| 6| case AI_LWO_MNVW: ------------------ | | 247| 6|#define AI_LWO_MNVW AI_IFF_FOURCC('M', 'N', 'V', 'W') | | ------------------ | | | | 50| 6|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 6| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (970:9): [True: 0, False: 29] ------------------ 971| 6| if (dims != 1) { ------------------ | Branch (971:17): [True: 0, False: 6] ------------------ 972| 0| ASSIMP_LOG_WARN("LWO2: Skipping Weight Channel \'", name, "\' with !1 components"); 973| 0| return; 974| 0| } 975| 6| base = FindEntry((type == AI_LWO_WGHT ? mCurLayer->mWeightChannels : mCurLayer->mSWeightChannels), name, perPoly); ------------------ | | 245| 6|#define AI_LWO_WGHT AI_IFF_FOURCC('W', 'G', 'H', 'T') | | ------------------ | | | | 50| 6|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 6| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (975:31): [True: 6, False: 0] ------------------ 976| 6| break; 977| 0| case AI_LWO_RGB: ------------------ | | 243| 0|#define AI_LWO_RGB AI_IFF_FOURCC('R', 'G', 'B', ' ') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (977:9): [True: 0, False: 29] ------------------ 978| 3| case AI_LWO_RGBA: ------------------ | | 244| 3|#define AI_LWO_RGBA AI_IFF_FOURCC('R', 'G', 'B', 'A') | | ------------------ | | | | 50| 3|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 3| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (978:9): [True: 3, False: 26] ------------------ 979| 3| if (dims != 3 && dims != 4) { ------------------ | Branch (979:17): [True: 3, False: 0] | Branch (979:30): [True: 0, False: 3] ------------------ 980| 0| ASSIMP_LOG_WARN("LWO2: Skipping Color Map \'", name, "\' with a dimension > 4 or < 3"); 981| 0| return; 982| 0| } 983| 3| base = FindEntry(mCurLayer->mVColorChannels, name, perPoly); 984| 3| break; 985| | 986| 7| case AI_LWO_MODO_NORM: ------------------ | | 304| 7|#define AI_LWO_MODO_NORM AI_IFF_FOURCC('N', 'O', 'R', 'M') | | ------------------ | | | | 50| 7|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 7| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (986:9): [True: 7, False: 22] ------------------ 987| | /* This is a non-standard extension chunk used by Luxology's MODO. 988| | * It stores per-vertex normals. This VMAP exists just once, has 989| | * 3 dimensions and is btw extremely beautiful. 990| | */ 991| 7| if (name != "vert_normals" || dims != 3 || mCurLayer->mNormals.name.length()) ------------------ | Branch (991:17): [True: 0, False: 7] | Branch (991:43): [True: 0, False: 7] | Branch (991:56): [True: 3, False: 4] ------------------ 992| 3| return; 993| | 994| 7| ASSIMP_LOG_INFO("Processing non-standard extension: MODO VMAP.NORM.vert_normals"); 995| | 996| 4| mCurLayer->mNormals.name = name; 997| 4| base = &mCurLayer->mNormals; 998| 4| break; 999| | 1000| 0| case AI_LWO_PICK: /* these VMAPs are just silently dropped */ ------------------ | | 250| 0|#define AI_LWO_PICK AI_IFF_FOURCC('P', 'I', 'C', 'K') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1000:9): [True: 0, False: 29] ------------------ 1001| 0| case AI_LWO_MORF: ------------------ | | 248| 0|#define AI_LWO_MORF AI_IFF_FOURCC('M', 'O', 'R', 'F') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1001:9): [True: 0, False: 29] ------------------ 1002| 0| case AI_LWO_SPOT: ------------------ | | 249| 0|#define AI_LWO_SPOT AI_IFF_FOURCC('S', 'P', 'O', 'T') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1002:9): [True: 0, False: 29] ------------------ 1003| 0| return; 1004| | 1005| 0| default: ------------------ | Branch (1005:9): [True: 0, False: 29] ------------------ 1006| 0| if (name == "APS.Level") { ------------------ | Branch (1006:17): [True: 0, False: 0] ------------------ 1007| | // XXX handle this (seems to be subdivision-related). 1008| 0| } 1009| 0| ASSIMP_LOG_WARN("LWO2: Skipping unknown VMAP/VMAD channel \'", name, "\'"); 1010| 0| return; 1011| 29| }; 1012| 26| base->Allocate((unsigned int)mCurLayer->mTempPoints.size()); 1013| | 1014| | // now read all entries in the map 1015| 26| type = std::min(dims, base->dims); 1016| 26| const unsigned int diff = (dims - type) << 2u; 1017| | 1018| 26| LWO::FaceList &list = mCurLayer->mFaces; 1019| 26| LWO::PointList &pointList = mCurLayer->mTempPoints; 1020| 26| LWO::ReferrerList &refList = mCurLayer->mPointReferrers; 1021| | 1022| 26| const unsigned int numPoints = (unsigned int)pointList.size(); 1023| 26| const unsigned int numFaces = (unsigned int)list.size(); 1024| | 1025| 10.4k| while (mFileBuffer < end) { ------------------ | Branch (1025:12): [True: 10.4k, False: 26] ------------------ 1026| | 1027| 10.4k| unsigned int idx = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mPointIDXOfs; 1028| 10.4k| if (idx >= numPoints) { ------------------ | Branch (1028:13): [True: 1.35k, False: 9.05k] ------------------ 1029| 1.35k| ASSIMP_LOG_WARN("LWO2: Failure evaluating VMAP/VMAD entry \'", name, "\', vertex index is out of range"); 1030| 1.35k| mFileBuffer += base->dims << 2u; 1031| 1.35k| continue; 1032| 1.35k| } 1033| 9.05k| if (perPoly) { ------------------ | Branch (1033:13): [True: 454, False: 8.60k] ------------------ 1034| 454| unsigned int polyIdx = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mFaceIDXOfs; 1035| 454| if (base->abAssigned[idx]) { ------------------ | Branch (1035:17): [True: 454, False: 0] ------------------ 1036| | // we have already a VMAP entry for this vertex - thus 1037| | // we need to duplicate the corresponding polygon. 1038| 454| if (polyIdx >= numFaces) { ------------------ | Branch (1038:21): [True: 0, False: 454] ------------------ 1039| 0| ASSIMP_LOG_WARN("LWO2: Failure evaluating VMAD entry \'", name, "\', polygon index is out of range"); 1040| 0| mFileBuffer += base->dims << 2u; 1041| 0| continue; 1042| 0| } 1043| | 1044| 454| LWO::Face &src = list[polyIdx]; 1045| | 1046| | // generate a new unique vertex for the corresponding index - but only 1047| | // if we can find the index in the face 1048| 454| bool had = false; 1049| 4.31k| for (unsigned int i = 0; i < src.mNumIndices; ++i) { ------------------ | Branch (1049:42): [True: 3.86k, False: 454] ------------------ 1050| | 1051| 3.86k| unsigned int srcIdx = src.mIndices[i], tmp = idx; 1052| 4.23k| do { 1053| 4.23k| if (tmp == srcIdx) ------------------ | Branch (1053:29): [True: 454, False: 3.78k] ------------------ 1054| 454| break; 1055| 4.23k| } while ((tmp = refList[tmp]) != UINT_MAX); ------------------ | Branch (1055:30): [True: 376, False: 3.40k] ------------------ 1056| 3.86k| if (tmp == UINT_MAX) { ------------------ | Branch (1056:25): [True: 3.40k, False: 454] ------------------ 1057| 3.40k| continue; 1058| 3.40k| } 1059| | 1060| 454| had = true; 1061| 454| refList.resize(refList.size() + 1, UINT_MAX); 1062| | 1063| 454| idx = (unsigned int)pointList.size(); 1064| 454| src.mIndices[i] = (unsigned int)pointList.size(); 1065| | 1066| | // store the index of the new vertex in the old vertex 1067| | // so we get a single linked list we can traverse in 1068| | // only one direction 1069| 454| AddToSingleLinkedList(refList, srcIdx, src.mIndices[i]); 1070| 454| pointList.push_back(pointList[srcIdx]); 1071| | 1072| 454| CreateNewEntry(mCurLayer->mVColorChannels, srcIdx); 1073| 454| CreateNewEntry(mCurLayer->mUVChannels, srcIdx); 1074| 454| CreateNewEntry(mCurLayer->mWeightChannels, srcIdx); 1075| 454| CreateNewEntry(mCurLayer->mSWeightChannels, srcIdx); 1076| 454| CreateNewEntry(mCurLayer->mNormals, srcIdx); 1077| 454| } 1078| 454| if (!had) { ------------------ | Branch (1078:21): [True: 0, False: 454] ------------------ 1079| 0| ASSIMP_LOG_WARN("LWO2: Failure evaluating VMAD entry \'", name, "\', vertex index wasn't found in that polygon"); 1080| 0| ai_assert(had); 1081| 0| } 1082| 454| } 1083| 454| } 1084| | 1085| 9.05k| std::unique_ptr temp(new float[type]); 1086| 27.5k| for (unsigned int l = 0; l < type; ++l) ------------------ | Branch (1086:34): [True: 18.4k, False: 9.05k] ------------------ 1087| 18.4k| temp[l] = GetF4(); 1088| | 1089| 9.05k| DoRecursiveVMAPAssignment(base, type, idx, temp.get()); 1090| 9.05k| mFileBuffer += diff; 1091| 9.05k| } 1092| 26|} _ZN6Assimp11LWOImporter12LoadLWO2ClipEj: 1096| 2|void LWOImporter::LoadLWO2Clip(unsigned int length) { 1097| 2| AI_LWO_VALIDATE_CHUNK_LENGTH(length, CLIP, 10); ------------------ | | 631| 2| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 2] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1098| | 1099| 2| mClips.emplace_back(); 1100| 2| LWO::Clip &clip = mClips.back(); 1101| | 1102| | // first - get the index of the clip 1103| 2| clip.idx = GetU4(); 1104| | 1105| 2| IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer); 1106| 2| switch (head.type) { 1107| 2| case AI_LWO_STIL: ------------------ | | 142| 2|#define AI_LWO_STIL AI_IFF_FOURCC('S', 'T', 'I', 'L') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1107:9): [True: 2, False: 0] ------------------ 1108| 2| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, STIL, 1); ------------------ | | 631| 2| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 2] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1109| | 1110| | // "Normal" texture 1111| 2| GetS0(clip.path, head.length); 1112| 2| clip.type = Clip::STILL; 1113| 2| break; 1114| | 1115| 0| case AI_LWO_ISEQ: ------------------ | | 143| 0|#define AI_LWO_ISEQ AI_IFF_FOURCC('I', 'S', 'E', 'Q') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1115:9): [True: 0, False: 2] ------------------ 1116| 0| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, ISEQ, 16); ------------------ | | 631| 0| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 0] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1117| | // Image sequence. We'll later take the first. 1118| 0| { 1119| 0| uint8_t digits = GetU1(); 1120| 0| mFileBuffer++; 1121| 0| int16_t offset = GetU2(); 1122| 0| mFileBuffer += 4; 1123| 0| int16_t start = GetU2(); 1124| 0| mFileBuffer += 4; 1125| | 1126| 0| std::string s; 1127| 0| std::ostringstream ss; 1128| 0| GetS0(s, head.length); 1129| | 1130| 0| head.length -= (uint16_t)s.length() + 1; 1131| 0| ss << s; 1132| 0| ss << std::setw(digits) << offset + start; 1133| 0| GetS0(s, head.length); 1134| 0| ss << s; 1135| 0| clip.path = ss.str(); 1136| 0| clip.type = Clip::SEQ; 1137| 0| } 1138| 0| break; 1139| | 1140| 0| case AI_LWO_STCC: ------------------ | | 146| 0|#define AI_LWO_STCC AI_IFF_FOURCC('S', 'T', 'C', 'C') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1140:9): [True: 0, False: 2] ------------------ 1141| 0| ASSIMP_LOG_WARN("LWO2: Color shifted images are not supported"); 1142| 0| break; 1143| | 1144| 0| case AI_LWO_ANIM: ------------------ | | 144| 0|#define AI_LWO_ANIM AI_IFF_FOURCC('A', 'N', 'I', 'M') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1144:9): [True: 0, False: 2] ------------------ 1145| 0| ASSIMP_LOG_WARN("LWO2: Animated textures are not supported"); 1146| 0| break; 1147| | 1148| 0| case AI_LWO_XREF: ------------------ | | 145| 0|#define AI_LWO_XREF AI_IFF_FOURCC('X', 'R', 'E', 'F') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1148:9): [True: 0, False: 2] ------------------ 1149| 0| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, XREF, 4); ------------------ | | 631| 0| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 0] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1150| | 1151| | // Just a cross-reference to another CLIp 1152| 0| clip.type = Clip::REF; 1153| 0| clip.clipRef = GetU4(); 1154| 0| break; 1155| | 1156| 0| case AI_LWO_NEGA: ------------------ | | 153| 0|#define AI_LWO_NEGA AI_IFF_FOURCC('N', 'E', 'G', 'A') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1156:9): [True: 0, False: 2] ------------------ 1157| 0| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, NEGA, 2); ------------------ | | 631| 0| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 0] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1158| 0| clip.negate = (0 != GetU2()); 1159| 0| break; 1160| | 1161| 0| default: ------------------ | Branch (1161:9): [True: 0, False: 2] ------------------ 1162| | ASSIMP_LOG_WARN("LWO2: Encountered unknown CLIP sub-chunk"); 1163| 2| } 1164| 2|} _ZN6Assimp11LWOImporter12LoadLWO2FileEv: 1446| 15|void LWOImporter::LoadLWO2File() { 1447| 15| bool skip = false; 1448| | 1449| 15| LE_NCONST uint8_t *const end = mFileBuffer + fileSize; 1450| 15| unsigned int iUnnamed = 0; 1451| | 1452| 284| while (true) { ------------------ | Branch (1452:12): [True: 284, Folded] ------------------ 1453| 284| if (mFileBuffer + sizeof(IFF::ChunkHeader) > end) break; ------------------ | Branch (1453:13): [True: 8, False: 276] ------------------ 1454| | 1455| 276| IFF::ChunkHeader head = IFF::LoadChunk(mFileBuffer); 1456| | 1457| 276| int bufOffset = 0; 1458| 276| if( head.type == AI_IFF_FOURCC_FORM ) { // not chunk, it's a form ------------------ | | 54| 276|#define AI_IFF_FOURCC_FORM AI_IFF_FOURCC('F','O','R','M') | | ------------------ | | | | 50| 276|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 276| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1458:13): [True: 0, False: 276] ------------------ 1459| 0| mFileBuffer -= 8; 1460| 0| head = IFF::LoadForm(mFileBuffer); 1461| 0| bufOffset = 4; 1462| 0| } 1463| | 1464| 276| if (mFileBuffer + head.length > end) { ------------------ | Branch (1464:13): [True: 6, False: 270] ------------------ 1465| 6| throw DeadlyImportError("LWO2: Chunk length points behind the file"); 1466| 6| } 1467| 270| uint8_t *const next = mFileBuffer + head.length; 1468| 270| mFileBuffer += bufOffset; 1469| 270| if (!head.length) { ------------------ | Branch (1469:13): [True: 0, False: 270] ------------------ 1470| 0| mFileBuffer = next; 1471| 0| continue; 1472| 0| } 1473| | 1474| 270| switch (head.type) { ------------------ | Branch (1474:17): [True: 163, False: 107] ------------------ 1475| | // new layer 1476| 24| case AI_LWO_LAYR: { ------------------ | | 101| 24|#define AI_LWO_LAYR AI_IFF_FOURCC('L', 'A', 'Y', 'R') | | ------------------ | | | | 50| 24|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 24| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1476:13): [True: 24, False: 246] ------------------ 1477| | // add a new layer to the list .... 1478| 24| mLayers->push_back(LWO::Layer()); 1479| 24| LWO::Layer &layer = mLayers->back(); 1480| 24| mCurLayer = &layer; 1481| | 1482| 24| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, LAYR, 16); ------------------ | | 631| 24| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 24] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1483| | 1484| | // layer index. 1485| 24| layer.mIndex = GetU2(); 1486| | 1487| | // Continue loading this layer or ignore it? Check the layer index property 1488| 24| if (UINT_MAX != configLayerIndex && (configLayerIndex - 1) != layer.mIndex) { ------------------ | Branch (1488:21): [True: 0, False: 24] | Branch (1488:53): [True: 0, False: 0] ------------------ 1489| 0| skip = true; 1490| 0| } else 1491| 24| skip = false; 1492| | 1493| | // pivot point 1494| 24| mFileBuffer += 2; /* unknown */ 1495| 24| mCurLayer->mPivot.x = GetF4(); 1496| 24| mCurLayer->mPivot.y = GetF4(); 1497| 24| mCurLayer->mPivot.z = GetF4(); 1498| 24| GetS0(layer.mName, head.length - 16); 1499| | 1500| | // if the name is empty, generate a default name 1501| 24| if (layer.mName.empty()) { ------------------ | Branch (1501:21): [True: 12, False: 12] ------------------ 1502| 12| char buffer[128]; // should be sufficiently large 1503| 12| ::ai_snprintf(buffer, 128, "Layer_%i", iUnnamed++); 1504| 12| layer.mName = buffer; 1505| 12| } 1506| | 1507| | // load this layer or ignore it? Check the layer name property 1508| 24| if (configLayerName.length() && configLayerName != layer.mName) { ------------------ | Branch (1508:21): [True: 0, False: 24] | Branch (1508:49): [True: 0, False: 0] ------------------ 1509| 0| skip = true; 1510| 0| } else 1511| 24| hasNamedLayer = true; 1512| | 1513| | // optional: parent of this layer 1514| 24| if (mFileBuffer + 2 <= next) ------------------ | Branch (1514:21): [True: 16, False: 8] ------------------ 1515| 16| layer.mParent = GetU2(); 1516| 8| else 1517| 8| layer.mParent = (uint16_t) -1; 1518| | 1519| | // Set layer skip parameter 1520| 24| layer.skip = skip; 1521| | 1522| 24| break; 1523| 24| } 1524| | // vertex list 1525| 24| case AI_LWO_PNTS: { ------------------ | | 103| 24|#define AI_LWO_PNTS AI_IFF_FOURCC('P', 'N', 'T', 'S') | | ------------------ | | | | 50| 24|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 24| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1525:13): [True: 24, False: 246] ------------------ 1526| 24| if (skip) ------------------ | Branch (1526:21): [True: 0, False: 24] ------------------ 1527| 0| break; 1528| | 1529| 24| unsigned int old = (unsigned int)mCurLayer->mTempPoints.size(); 1530| 24| LoadLWOPoints(head.length); 1531| 24| mCurLayer->mPointIDXOfs = old; 1532| 24| break; 1533| 24| } 1534| | // vertex tags 1535| 9| case AI_LWO_VMAD: ------------------ | | 106| 9|#define AI_LWO_VMAD AI_IFF_FOURCC('V', 'M', 'A', 'D') | | ------------------ | | | | 50| 9|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 9| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1535:13): [True: 9, False: 261] ------------------ 1536| 9| if (mCurLayer->mFaces.empty()) { ------------------ | Branch (1536:21): [True: 0, False: 9] ------------------ 1537| 0| ASSIMP_LOG_WARN("LWO2: Unexpected VMAD chunk"); 1538| 0| break; 1539| 0| } 1540| | // --- intentionally no break here 1541| | // fallthrough 1542| 29| case AI_LWO_VMAP: { ------------------ | | 214| 29|#define AI_LWO_VMAP AI_IFF_FOURCC('V', 'M', 'A', 'P') | | ------------------ | | | | 50| 29|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 29| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1542:13): [True: 20, False: 250] ------------------ 1543| 29| if (skip) ------------------ | Branch (1543:21): [True: 0, False: 29] ------------------ 1544| 0| break; 1545| | 1546| 29| if (mCurLayer->mTempPoints.empty()) ------------------ | Branch (1546:21): [True: 0, False: 29] ------------------ 1547| 29| ASSIMP_LOG_WARN("LWO2: Unexpected VMAP chunk"); 1548| 29| else 1549| 29| LoadLWO2VertexMap(head.length, head.type == AI_LWO_VMAD); ------------------ | | 106| 29|#define AI_LWO_VMAD AI_IFF_FOURCC('V', 'M', 'A', 'D') | | ------------------ | | | | 50| 29|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 29| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ 1550| 29| break; 1551| 29| } 1552| | // face list 1553| 21| case AI_LWO_POLS: { ------------------ | | 107| 21|#define AI_LWO_POLS AI_IFF_FOURCC('P', 'O', 'L', 'S') | | ------------------ | | | | 50| 21|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 21| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1553:13): [True: 21, False: 249] ------------------ 1554| 21| if (skip) ------------------ | Branch (1554:21): [True: 0, False: 21] ------------------ 1555| 0| break; 1556| | 1557| 21| unsigned int old = (unsigned int)mCurLayer->mFaces.size(); 1558| 21| LoadLWO2Polygons(head.length); 1559| 21| mCurLayer->mFaceIDXOfs = old; 1560| 21| break; 1561| 21| } 1562| | // polygon tags 1563| 36| case AI_LWO_PTAG: { ------------------ | | 108| 36|#define AI_LWO_PTAG AI_IFF_FOURCC('P', 'T', 'A', 'G') | | ------------------ | | | | 50| 36|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 36| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1563:13): [True: 36, False: 234] ------------------ 1564| 36| if (skip) ------------------ | Branch (1564:21): [True: 0, False: 36] ------------------ 1565| 0| break; 1566| | 1567| 36| if (mCurLayer->mFaces.empty()) { ------------------ | Branch (1567:21): [True: 0, False: 36] ------------------ 1568| 0| ASSIMP_LOG_WARN("LWO2: Unexpected PTAG"); 1569| 36| } else { 1570| 36| LoadLWO2PolygonTags(head.length); 1571| 36| } 1572| 36| break; 1573| 36| } 1574| | // list of tags 1575| 15| case AI_LWO_TAGS: { ------------------ | | 102| 15|#define AI_LWO_TAGS AI_IFF_FOURCC('T', 'A', 'G', 'S') | | ------------------ | | | | 50| 15|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 15| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1575:13): [True: 15, False: 255] ------------------ 1576| 15| if (!mTags->empty()) { ------------------ | Branch (1576:21): [True: 0, False: 15] ------------------ 1577| 0| ASSIMP_LOG_WARN("LWO2: SRFS chunk encountered twice"); 1578| 15| } else { 1579| 15| LoadLWOTags(head.length); 1580| 15| } 1581| 15| break; 1582| 36| } 1583| | 1584| | // surface chunk 1585| 12| case AI_LWO_SURF: { ------------------ | | 125| 12|#define AI_LWO_SURF AI_IFF_FOURCC('S', 'U', 'R', 'F') | | ------------------ | | | | 50| 12|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 12| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1585:13): [True: 12, False: 258] ------------------ 1586| 12| if( mIsLWO3 ) ------------------ | Branch (1586:21): [True: 0, False: 12] ------------------ 1587| 0| LoadLWO3Surface(head.length); 1588| 12| else 1589| 12| LoadLWO2Surface(head.length); 1590| | 1591| 12| break; 1592| 36| } 1593| | 1594| | // clip chunk 1595| 2| case AI_LWO_CLIP: { ------------------ | | 110| 2|#define AI_LWO_CLIP AI_IFF_FOURCC('C', 'L', 'I', 'P') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1595:13): [True: 2, False: 268] ------------------ 1596| 2| if( mIsLWO3 ) ------------------ | Branch (1596:21): [True: 0, False: 2] ------------------ 1597| 0| LoadLWO3Clip(head.length); 1598| 2| else 1599| 2| LoadLWO2Clip(head.length); 1600| 2| break; 1601| 36| } 1602| | 1603| | // envelope chunk 1604| 0| case AI_LWO_ENVL: { ------------------ | | 109| 0|#define AI_LWO_ENVL AI_IFF_FOURCC('E', 'N', 'V', 'L') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1604:13): [True: 0, False: 270] ------------------ 1605| 0| if( mIsLWO3 ) ------------------ | Branch (1605:21): [True: 0, False: 0] ------------------ 1606| 0| LoadLWO3Envelope(head.length); 1607| 0| else 1608| 0| LoadLWO2Envelope(head.length); 1609| 0| break; 1610| 36| } 1611| 270| } 1612| 269| mFileBuffer = next; 1613| 269| } 1614| 15|} _Z21AddToSingleLinkedListRNSt3__16vectorIjNS_9allocatorIjEEEEjj: 938| 728|inline void AddToSingleLinkedList(ReferrerList &refList, unsigned int srcIdx, unsigned int destIdx) { 939| 728| if (UINT_MAX == refList[srcIdx]) { ------------------ | Branch (939:9): [True: 454, False: 274] ------------------ 940| 454| refList[srcIdx] = destIdx; 941| 454| return; 942| 454| } 943| 274| AddToSingleLinkedList(refList, refList[srcIdx], destIdx); 944| 274|} _ZN6Assimp11LWOImporter25DoRecursiveVMAPAssignmentEPNS_3LWO9VMapEntryEjjPf: 919| 9.05k| unsigned int idx, float *data) { 920| 9.05k| ai_assert(nullptr != data); 921| 9.05k| LWO::ReferrerList &refList = mCurLayer->mPointReferrers; 922| 9.05k| unsigned int i; 923| | 924| 9.05k| if (idx >= base->abAssigned.size()) { ------------------ | Branch (924:9): [True: 0, False: 9.05k] ------------------ 925| 0| throw DeadlyImportError("Bad index"); 926| 0| } 927| 9.05k| base->abAssigned[idx] = true; 928| 27.5k| for (i = 0; i < numRead; ++i) { ------------------ | Branch (928:17): [True: 18.4k, False: 9.05k] ------------------ 929| 18.4k| base->rawData[idx * base->dims + i] = data[i]; 930| 18.4k| } 931| | 932| 9.05k| if (UINT_MAX != (i = refList[idx])) { ------------------ | Branch (932:9): [True: 0, False: 9.05k] ------------------ 933| 0| DoRecursiveVMAPAssignment(base, numRead, i, data); 934| 0| } 935| 9.05k|} _Z9FindEntryIN6Assimp3LWO9UVChannelEEPNS1_9VMapEntryERNSt3__16vectorIT_NS5_9allocatorIS7_EEEERKNS5_12basic_stringIcNS5_11char_traitsIcEENS8_IcEEEEb: 881| 13|VMapEntry *FindEntry(std::vector &list, const std::string &name, bool perPoly) { 882| 13| for (auto &elem : list) { ------------------ | Branch (882:21): [True: 7, False: 8] ------------------ 883| 7| if (elem.name == name) { ------------------ | Branch (883:13): [True: 5, False: 2] ------------------ 884| 5| if (!perPoly) { ------------------ | Branch (884:17): [True: 0, False: 5] ------------------ 885| 0| ASSIMP_LOG_WARN("LWO2: Found two VMAP sections with equal names"); 886| 0| } 887| 5| return &elem; 888| 5| } 889| 7| } 890| 8| list.push_back(T()); 891| 8| VMapEntry *p = &list.back(); 892| 8| p->name = name; 893| 8| return p; 894| 13|} _Z9FindEntryIN6Assimp3LWO13WeightChannelEEPNS1_9VMapEntryERNSt3__16vectorIT_NS5_9allocatorIS7_EEEERKNS5_12basic_stringIcNS5_11char_traitsIcEENS8_IcEEEEb: 881| 6|VMapEntry *FindEntry(std::vector &list, const std::string &name, bool perPoly) { 882| 6| for (auto &elem : list) { ------------------ | Branch (882:21): [True: 3, False: 6] ------------------ 883| 3| if (elem.name == name) { ------------------ | Branch (883:13): [True: 0, False: 3] ------------------ 884| 0| if (!perPoly) { ------------------ | Branch (884:17): [True: 0, False: 0] ------------------ 885| 0| ASSIMP_LOG_WARN("LWO2: Found two VMAP sections with equal names"); 886| 0| } 887| 0| return &elem; 888| 0| } 889| 3| } 890| 6| list.push_back(T()); 891| 6| VMapEntry *p = &list.back(); 892| 6| p->name = name; 893| 6| return p; 894| 6|} _Z9FindEntryIN6Assimp3LWO13VColorChannelEEPNS1_9VMapEntryERNSt3__16vectorIT_NS5_9allocatorIS7_EEEERKNS5_12basic_stringIcNS5_11char_traitsIcEENS8_IcEEEEb: 881| 3|VMapEntry *FindEntry(std::vector &list, const std::string &name, bool perPoly) { 882| 3| for (auto &elem : list) { ------------------ | Branch (882:21): [True: 3, False: 2] ------------------ 883| 3| if (elem.name == name) { ------------------ | Branch (883:13): [True: 1, False: 2] ------------------ 884| 1| if (!perPoly) { ------------------ | Branch (884:17): [True: 0, False: 1] ------------------ 885| 0| ASSIMP_LOG_WARN("LWO2: Found two VMAP sections with equal names"); 886| 0| } 887| 1| return &elem; 888| 1| } 889| 3| } 890| 2| list.push_back(T()); 891| 2| VMapEntry *p = &list.back(); 892| 2| p->name = name; 893| 2| return p; 894| 3|} _Z14CreateNewEntryIN6Assimp3LWO13VColorChannelEEvRNSt3__16vectorIT_NS3_9allocatorIS5_EEEEj: 911| 454|inline void CreateNewEntry(std::vector &list, unsigned int srcIdx) { 912| 460| for (auto &elem : list) { ------------------ | Branch (912:21): [True: 460, False: 454] ------------------ 913| 460| CreateNewEntry(elem, srcIdx); 914| 460| } 915| 454|} _Z14CreateNewEntryIN6Assimp3LWO13VColorChannelEEvRT_j: 898| 460|inline void CreateNewEntry(T &chan, unsigned int srcIdx) { 899| 460| if (!chan.name.length()) ------------------ | Branch (899:9): [True: 0, False: 460] ------------------ 900| 0| return; 901| | 902| 460| chan.abAssigned[srcIdx] = true; 903| 460| chan.abAssigned.resize(chan.abAssigned.size() + 1, false); 904| | 905| 2.30k| for (unsigned int a = 0; a < chan.dims; ++a) ------------------ | Branch (905:30): [True: 1.84k, False: 460] ------------------ 906| 1.84k| chan.rawData.push_back(chan.rawData[srcIdx * chan.dims + a]); 907| 460|} _Z14CreateNewEntryIN6Assimp3LWO9UVChannelEEvRNSt3__16vectorIT_NS3_9allocatorIS5_EEEEj: 911| 454|inline void CreateNewEntry(std::vector &list, unsigned int srcIdx) { 912| 684| for (auto &elem : list) { ------------------ | Branch (912:21): [True: 684, False: 454] ------------------ 913| 684| CreateNewEntry(elem, srcIdx); 914| 684| } 915| 454|} _Z14CreateNewEntryIN6Assimp3LWO9UVChannelEEvRT_j: 898| 684|inline void CreateNewEntry(T &chan, unsigned int srcIdx) { 899| 684| if (!chan.name.length()) ------------------ | Branch (899:9): [True: 0, False: 684] ------------------ 900| 0| return; 901| | 902| 684| chan.abAssigned[srcIdx] = true; 903| 684| chan.abAssigned.resize(chan.abAssigned.size() + 1, false); 904| | 905| 2.05k| for (unsigned int a = 0; a < chan.dims; ++a) ------------------ | Branch (905:30): [True: 1.36k, False: 684] ------------------ 906| 1.36k| chan.rawData.push_back(chan.rawData[srcIdx * chan.dims + a]); 907| 684|} _Z14CreateNewEntryIN6Assimp3LWO13WeightChannelEEvRNSt3__16vectorIT_NS3_9allocatorIS5_EEEEj: 911| 908|inline void CreateNewEntry(std::vector &list, unsigned int srcIdx) { 912| 908| for (auto &elem : list) { ------------------ | Branch (912:21): [True: 0, False: 908] ------------------ 913| 0| CreateNewEntry(elem, srcIdx); 914| 0| } 915| 908|} _Z14CreateNewEntryIN6Assimp3LWO13NormalChannelEEvRT_j: 898| 454|inline void CreateNewEntry(T &chan, unsigned int srcIdx) { 899| 454| if (!chan.name.length()) ------------------ | Branch (899:9): [True: 454, False: 0] ------------------ 900| 454| return; 901| | 902| 0| chan.abAssigned[srcIdx] = true; 903| 0| chan.abAssigned.resize(chan.abAssigned.size() + 1, false); 904| | 905| 0| for (unsigned int a = 0; a < chan.dims; ++a) ------------------ | Branch (905:30): [True: 0, False: 0] ------------------ 906| 0| chan.rawData.push_back(chan.rawData[srcIdx * chan.dims + a]); 907| 0|} _ZN6Assimp11LWOImporterC2Ev: 77| 624| LWOImporter() = default; _ZN6Assimp11LWOImporter5GetF4Ev: 405| 18.6k|inline float LWOImporter::GetF4() { 406| 18.6k| float f; 407| 18.6k| ::memcpy(&f, mFileBuffer, 4); 408| 18.6k| mFileBuffer += 4; 409| | AI_LSWAP4(f); 410| 18.6k| return f; 411| 18.6k|} _ZN6Assimp11LWOImporter5GetU4Ev: 432| 91|inline uint32_t LWOImporter::GetU4() { 433| 91| uint32_t f; 434| 91| ::memcpy(&f, mFileBuffer, 4); 435| 91| mFileBuffer += 4; 436| | AI_LSWAP4(f); 437| 91| return f; 438| 91|} _ZN6Assimp11LWOImporter5GetU2Ev: 441| 2.06k|inline uint16_t LWOImporter::GetU2() { 442| 2.06k| uint16_t f; 443| 2.06k| ::memcpy(&f, mFileBuffer, 2); 444| 2.06k| mFileBuffer += 2; 445| | AI_LSWAP2(f); 446| 2.06k| return f; 447| 2.06k|} _ZN6Assimp11LWOImporter17ReadVSizedIntLWO2ERPh: 455| 61.6k|inline int LWOImporter::ReadVSizedIntLWO2(uint8_t *&inout) { 456| 61.6k| int i; 457| 61.6k| int c = *inout; 458| 61.6k| inout++; 459| 61.6k| if (c != 0xFF) { ------------------ | Branch (459:9): [True: 61.6k, False: 11] ------------------ 460| 61.6k| i = c << 8; 461| 61.6k| c = *inout; 462| 61.6k| inout++; 463| 61.6k| i |= c; 464| 61.6k| } else { 465| 11| c = *inout; 466| 11| inout++; 467| 11| i = c << 16; 468| 11| c = *inout; 469| 11| inout++; 470| 11| i |= c << 8; 471| 11| c = *inout; 472| 11| inout++; 473| 11| i |= c; 474| 11| } 475| 61.6k| return i; 476| 61.6k|} _ZN6Assimp11LWOImporter5GetS0ERNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEj: 479| 84|inline void LWOImporter::GetS0(std::string &out, unsigned int max) { 480| 84| unsigned int iCursor = 0; 481| 84| const char *sz = (const char *)mFileBuffer; 482| 809| while (mFileBuffer < mFileBufferEnd && *mFileBuffer) { ------------------ | Branch (482:12): [True: 809, False: 0] | Branch (482:44): [True: 725, False: 84] ------------------ 483| 725| if (++iCursor > max) { ------------------ | Branch (483:13): [True: 0, False: 725] ------------------ 484| 0| ASSIMP_LOG_WARN("LWO: Invalid file, string is too long"); 485| 0| break; 486| 0| } 487| 725| ++mFileBuffer; 488| 725| } 489| 84| size_t len = (size_t)((const char *)mFileBuffer - sz); 490| 84| out = std::string(sz, len); 491| | 492| 84| const size_t skip = (len & 0x1 ? 1u : 2u); ------------------ | Branch (492:26): [True: 37, False: 47] ------------------ 493| 84| const size_t remaining = static_cast(mFileBufferEnd - mFileBuffer); 494| 84| if (remaining < skip) { ------------------ | Branch (494:9): [True: 0, False: 84] ------------------ 495| 0| mFileBuffer = mFileBufferEnd; 496| 84| } else { 497| 84| mFileBuffer += skip; 498| 84| } 499| 84|} _ZN6Assimp11LWOImporterD2Ev: 82| 624| ~LWOImporter() override = default; _ZN6Assimp11LWOImporter14HandleTexturesEP10aiMaterialRKNSt3__14listINS_3LWO7TextureENS3_9allocatorIS6_EEEE13aiTextureType: 79| 103|bool LWOImporter::HandleTextures(aiMaterial *pcMat, const TextureList &in, aiTextureType type) { 80| 103| ai_assert(nullptr != pcMat); 81| | 82| 103| unsigned int cur = 0, temp = 0; 83| 103| aiString s; 84| 103| bool ret = false; 85| | 86| 103| for (const auto &texture : in) { ------------------ | Branch (86:30): [True: 2, False: 103] ------------------ 87| 2| if (!texture.enabled || !texture.bCanUse) ------------------ | Branch (87:13): [True: 0, False: 2] | Branch (87:33): [True: 0, False: 2] ------------------ 88| 0| continue; 89| 2| ret = true; 90| | 91| | // Convert lightwave's mapping modes to ours. We let them 92| | // as they are, the GenUVcoords step will compute UV 93| | // channels if they're not there. 94| | 95| 2| aiTextureMapping mapping = aiTextureMapping_OTHER; 96| 2| switch (texture.mapMode) { 97| 0| case LWO::Texture::Planar: ------------------ | Branch (97:13): [True: 0, False: 2] ------------------ 98| 0| mapping = aiTextureMapping_PLANE; 99| 0| break; 100| 0| case LWO::Texture::Cylindrical: ------------------ | Branch (100:13): [True: 0, False: 2] ------------------ 101| 0| mapping = aiTextureMapping_CYLINDER; 102| 0| break; 103| 0| case LWO::Texture::Spherical: ------------------ | Branch (103:13): [True: 0, False: 2] ------------------ 104| 0| mapping = aiTextureMapping_SPHERE; 105| 0| break; 106| 0| case LWO::Texture::Cubic: ------------------ | Branch (106:13): [True: 0, False: 2] ------------------ 107| 0| mapping = aiTextureMapping_BOX; 108| 0| break; 109| 0| case LWO::Texture::FrontProjection: ------------------ | Branch (109:13): [True: 0, False: 2] ------------------ 110| 0| ASSIMP_LOG_ERROR("LWO2: Unsupported texture mapping: FrontProjection"); 111| 0| mapping = aiTextureMapping_OTHER; 112| 0| break; 113| 2| case LWO::Texture::UV: { ------------------ | Branch (113:13): [True: 2, False: 0] ------------------ 114| 2| if (UINT_MAX == texture.mRealUVIndex) { ------------------ | Branch (114:21): [True: 0, False: 2] ------------------ 115| | // We have no UV index for this texture, so we can't display it 116| 0| continue; 117| 0| } 118| | 119| | // add the UV source index 120| 2| temp = texture.mRealUVIndex; 121| 2| pcMat->AddProperty((int *)&temp, 1, AI_MATKEY_UVWSRC(type, cur)); 122| | 123| 2| mapping = aiTextureMapping_UV; 124| 2| } break; 125| 0| default: ------------------ | Branch (125:13): [True: 0, False: 2] ------------------ 126| 0| ai_assert(false); 127| 2| }; 128| | 129| 2| if (mapping != aiTextureMapping_UV) { ------------------ | Branch (129:13): [True: 0, False: 2] ------------------ 130| | // Setup the main axis 131| 0| aiVector3D v; 132| 0| switch (texture.majorAxis) { 133| 0| case Texture::AXIS_X: ------------------ | Branch (133:17): [True: 0, False: 0] ------------------ 134| 0| v = aiVector3D(1.0, 0.0, 0.0); 135| 0| break; 136| 0| case Texture::AXIS_Y: ------------------ | Branch (136:17): [True: 0, False: 0] ------------------ 137| 0| v = aiVector3D(0.0, 1.0, 0.0); 138| 0| break; 139| 0| default: // case Texture::AXIS_Z: ------------------ | Branch (139:17): [True: 0, False: 0] ------------------ 140| 0| v = aiVector3D(0.0, 0.0, 1.0); 141| 0| break; 142| 0| } 143| | 144| 0| pcMat->AddProperty(&v, 1, AI_MATKEY_TEXMAP_AXIS(type, cur)); 145| | 146| | // Setup UV scalings for cylindric and spherical projections 147| 0| if (mapping == aiTextureMapping_CYLINDER || mapping == aiTextureMapping_SPHERE) { ------------------ | Branch (147:17): [True: 0, False: 0] | Branch (147:57): [True: 0, False: 0] ------------------ 148| 0| aiUVTransform trafo; 149| 0| trafo.mScaling.x = texture.wrapAmountW; 150| 0| trafo.mScaling.y = texture.wrapAmountH; 151| | 152| 0| static_assert(sizeof(aiUVTransform) / sizeof(ai_real) == 5, "sizeof(aiUVTransform)/sizeof(ai_real) == 5"); 153| 0| pcMat->AddProperty(&trafo, 1, AI_MATKEY_UVTRANSFORM(type, cur)); 154| 0| } 155| 0| ASSIMP_LOG_VERBOSE_DEBUG("LWO2: Setting up non-UV mapping"); 156| 0| } 157| | 158| | // The older LWOB format does not use indirect references to clips. 159| | // The file name of a texture is directly specified in the tex chunk. 160| 2| if (mIsLWO2 || mIsLWO3) { ------------------ | Branch (160:13): [True: 2, False: 0] | Branch (160:24): [True: 0, False: 0] ------------------ 161| | // find the corresponding clip (take the last one if multiple 162| | // share the same index) 163| 2| ClipList::iterator end = mClips.end(), candidate = end; 164| 2| temp = texture.mClipIdx; 165| 4| for (ClipList::iterator clip = mClips.begin(); clip != end; ++clip) { ------------------ | Branch (165:60): [True: 2, False: 2] ------------------ 166| 2| if ((*clip).idx == temp) { ------------------ | Branch (166:21): [True: 2, False: 0] ------------------ 167| 2| candidate = clip; 168| 2| } 169| 2| } 170| 2| if (candidate == end) { ------------------ | Branch (170:17): [True: 0, False: 2] ------------------ 171| 0| ASSIMP_LOG_ERROR("LWO2: Clip index is out of bounds"); 172| 0| temp = 0; 173| | 174| | // fixme: apparently some LWO files shipping with Doom3 don't 175| | // have clips at all ... check whether that's true or whether 176| | // it's a bug in the loader. 177| | 178| 0| s.Set("$texture.png"); 179| | 180| | //continue; 181| 2| } else { 182| 2| if (Clip::UNSUPPORTED == (*candidate).type) { ------------------ | Branch (182:21): [True: 0, False: 2] ------------------ 183| 0| ASSIMP_LOG_ERROR("LWO2: Clip type is not supported"); 184| 0| continue; 185| 0| } 186| 2| AdjustTexturePath((*candidate).path); 187| 2| s.Set((*candidate).path); 188| | 189| | // Additional image settings 190| 2| int flags = 0; 191| 2| if ((*candidate).negate) { ------------------ | Branch (191:21): [True: 0, False: 2] ------------------ 192| 0| flags |= aiTextureFlags_Invert; 193| 0| } 194| 2| pcMat->AddProperty(&flags, 1, AI_MATKEY_TEXFLAGS(type, cur)); 195| 2| } 196| 2| } else { 197| 0| std::string ss = texture.mFileName; 198| 0| if (!ss.length()) { ------------------ | Branch (198:17): [True: 0, False: 0] ------------------ 199| 0| ASSIMP_LOG_WARN("LWOB: Empty file name"); 200| 0| continue; 201| 0| } 202| 0| AdjustTexturePath(ss); 203| 0| s.Set(ss); 204| 0| } 205| 2| pcMat->AddProperty(&s, AI_MATKEY_TEXTURE(type, cur)); 206| | 207| | // add the blend factor 208| 2| pcMat->AddProperty(&texture.mStrength, 1, AI_MATKEY_TEXBLEND(type, cur)); 209| | 210| | // add the blend operation 211| 2| switch (texture.blendType) { 212| 2| case LWO::Texture::Normal: ------------------ | Branch (212:13): [True: 2, False: 0] ------------------ 213| 2| case LWO::Texture::Multiply: ------------------ | Branch (213:13): [True: 0, False: 2] ------------------ 214| 2| temp = (unsigned int)aiTextureOp_Multiply; 215| 2| break; 216| | 217| 0| case LWO::Texture::Subtractive: ------------------ | Branch (217:13): [True: 0, False: 2] ------------------ 218| 0| case LWO::Texture::Difference: ------------------ | Branch (218:13): [True: 0, False: 2] ------------------ 219| 0| temp = (unsigned int)aiTextureOp_Subtract; 220| 0| break; 221| | 222| 0| case LWO::Texture::Divide: ------------------ | Branch (222:13): [True: 0, False: 2] ------------------ 223| 0| temp = (unsigned int)aiTextureOp_Divide; 224| 0| break; 225| | 226| 0| case LWO::Texture::Additive: ------------------ | Branch (226:13): [True: 0, False: 2] ------------------ 227| 0| temp = (unsigned int)aiTextureOp_Add; 228| 0| break; 229| | 230| 0| default: ------------------ | Branch (230:13): [True: 0, False: 2] ------------------ 231| 0| temp = (unsigned int)aiTextureOp_Multiply; 232| 0| ASSIMP_LOG_WARN("LWO2: Unsupported texture blend mode: alpha or displacement"); 233| 2| } 234| | // Setup texture operation 235| 2| pcMat->AddProperty((int *)&temp, 1, AI_MATKEY_TEXOP(type, cur)); 236| | 237| | // setup the mapping mode 238| 2| int mapping_ = static_cast(mapping); 239| 2| pcMat->AddProperty(&mapping_, 1, AI_MATKEY_MAPPING(type, cur)); 240| | 241| | // add the u-wrapping 242| 2| temp = (unsigned int)GetMapMode(texture.wrapModeWidth); 243| 2| pcMat->AddProperty((int *)&temp, 1, AI_MATKEY_MAPPINGMODE_U(type, cur)); 244| | 245| | // add the v-wrapping 246| 2| temp = (unsigned int)GetMapMode(texture.wrapModeHeight); 247| 2| pcMat->AddProperty((int *)&temp, 1, AI_MATKEY_MAPPINGMODE_V(type, cur)); 248| | 249| 2| ++cur; 250| 2| } 251| 103| return ret; 252| 103|} _ZN6Assimp11LWOImporter15ConvertMaterialERKNS_3LWO7SurfaceEP10aiMaterial: 255| 15|void LWOImporter::ConvertMaterial(const LWO::Surface &surf, aiMaterial *pcMat) { 256| | // copy the name of the surface 257| 15| aiString st; 258| 15| st.Set(surf.mName); 259| 15| pcMat->AddProperty(&st, AI_MATKEY_NAME); 260| | 261| 15| const int i = surf.bDoubleSided ? 1 : 0; ------------------ | Branch (261:19): [True: 0, False: 15] ------------------ 262| 15| pcMat->AddProperty(&i, 1, AI_MATKEY_TWOSIDED); 263| | 264| | // add the refraction index and the bump intensity 265| 15| pcMat->AddProperty(&surf.mIOR, 1, AI_MATKEY_REFRACTI); 266| 15| pcMat->AddProperty(&surf.mBumpIntensity, 1, AI_MATKEY_BUMPSCALING); 267| | 268| 15| aiShadingMode m; 269| 15| if (surf.mSpecularValue && surf.mGlossiness) { ------------------ | Branch (269:9): [True: 1, False: 14] | Branch (269:32): [True: 1, False: 0] ------------------ 270| 1| float fGloss; 271| 1| if (mIsLWO2 || mIsLWO3) { ------------------ | Branch (271:13): [True: 1, False: 0] | Branch (271:24): [True: 0, False: 0] ------------------ 272| 1| fGloss = std::pow(surf.mGlossiness * ai_real(10.0) + ai_real(2.0), ai_real(2.0)); 273| 1| } else { 274| 0| if (16.0 >= surf.mGlossiness) ------------------ | Branch (274:17): [True: 0, False: 0] ------------------ 275| 0| fGloss = 6.0; 276| 0| else if (64.0 >= surf.mGlossiness) ------------------ | Branch (276:22): [True: 0, False: 0] ------------------ 277| 0| fGloss = 20.0; 278| 0| else if (256.0 >= surf.mGlossiness) ------------------ | Branch (278:22): [True: 0, False: 0] ------------------ 279| 0| fGloss = 50.0; 280| 0| else 281| 0| fGloss = 80.0; 282| 0| } 283| | 284| 1| pcMat->AddProperty(&surf.mSpecularValue, 1, AI_MATKEY_SHININESS_STRENGTH); 285| 1| pcMat->AddProperty(&fGloss, 1, AI_MATKEY_SHININESS); 286| 1| m = aiShadingMode_Phong; 287| 1| } else 288| 14| m = aiShadingMode_Gouraud; 289| | 290| | // specular color 291| 15| aiColor3D clr = lerp(aiColor3D(1.0, 1.0, 1.0), surf.mColor, surf.mColorHighlights); 292| 15| pcMat->AddProperty(&clr, 1, AI_MATKEY_COLOR_SPECULAR); 293| 15| pcMat->AddProperty(&surf.mSpecularValue, 1, AI_MATKEY_SHININESS_STRENGTH); 294| | 295| | // emissive color 296| | // luminosity is not really the same but it affects the surface in a similar way. Some scaling looks good. 297| 15| clr.g = clr.b = clr.r = surf.mLuminosity * ai_real(0.8); 298| 15| pcMat->AddProperty(&clr, 1, AI_MATKEY_COLOR_EMISSIVE); 299| | 300| | // opacity ... either additive or default-blended, please 301| 15| if (0.0 != surf.mAdditiveTransparency) { ------------------ | Branch (301:9): [True: 0, False: 15] ------------------ 302| 0| const int add = aiBlendMode_Additive; 303| 0| pcMat->AddProperty(&surf.mAdditiveTransparency, 1, AI_MATKEY_OPACITY); 304| 0| pcMat->AddProperty(&add, 1, AI_MATKEY_BLEND_FUNC); 305| 15| } else if (10e10f != surf.mTransparency) { ------------------ | Branch (305:16): [True: 15, False: 0] ------------------ 306| 15| const int def = aiBlendMode_Default; 307| 15| const float f = 1.0f - surf.mTransparency; 308| 15| pcMat->AddProperty(&f, 1, AI_MATKEY_OPACITY); 309| 15| pcMat->AddProperty(&def, 1, AI_MATKEY_BLEND_FUNC); 310| 15| } 311| | 312| | // ADD TEXTURES to the material 313| | // TODO: find out how we can handle COLOR textures correctly... 314| 15| bool b = HandleTextures(pcMat, surf.mColorTextures, aiTextureType_DIFFUSE); 315| 15| b = (b || HandleTextures(pcMat, surf.mDiffuseTextures, aiTextureType_DIFFUSE)); ------------------ | Branch (315:10): [True: 2, False: 13] | Branch (315:15): [True: 0, False: 13] ------------------ 316| 15| HandleTextures(pcMat, surf.mSpecularTextures, aiTextureType_SPECULAR); 317| 15| HandleTextures(pcMat, surf.mGlossinessTextures, aiTextureType_SHININESS); 318| 15| HandleTextures(pcMat, surf.mBumpTextures, aiTextureType_HEIGHT); 319| 15| HandleTextures(pcMat, surf.mOpacityTextures, aiTextureType_OPACITY); 320| 15| HandleTextures(pcMat, surf.mReflectionTextures, aiTextureType_REFLECTION); 321| | 322| | // Now we need to know which shader to use .. iterate through the shader list of 323| | // the surface and search for a name which we know ... 324| 15| for (const auto &shader : surf.mShaders) { ------------------ | Branch (324:29): [True: 0, False: 15] ------------------ 325| 0| if (shader.functionName == "LW_SuperCelShader" || shader.functionName == "AH_CelShader") { ------------------ | Branch (325:13): [True: 0, False: 0] | Branch (325:59): [True: 0, False: 0] ------------------ 326| 0| ASSIMP_LOG_INFO("LWO2: Mapping LW_SuperCelShader/AH_CelShader to aiShadingMode_Toon"); 327| | 328| 0| m = aiShadingMode_Toon; 329| 0| break; 330| 0| } else if (shader.functionName == "LW_RealFresnel" || shader.functionName == "LW_FastFresnel") { ------------------ | Branch (330:20): [True: 0, False: 0] | Branch (330:63): [True: 0, False: 0] ------------------ 331| 0| ASSIMP_LOG_INFO("LWO2: Mapping LW_RealFresnel/LW_FastFresnel to aiShadingMode_Fresnel"); 332| | 333| 0| m = aiShadingMode_Fresnel; 334| 0| break; 335| 0| } else { 336| 0| ASSIMP_LOG_WARN("LWO2: Unknown surface shader: ", shader.functionName); 337| 0| } 338| 0| } 339| 15| if (surf.mMaximumSmoothAngle <= 0.0) ------------------ | Branch (339:9): [True: 6, False: 9] ------------------ 340| 6| m = aiShadingMode_Flat; 341| 15| int m_ = static_cast(m); 342| 15| pcMat->AddProperty(&m_, 1, AI_MATKEY_SHADING_MODEL); 343| | 344| | // (the diffuse value is just a scaling factor) 345| | // If a diffuse texture is set, we set this value to 1.0 346| 15| clr = (b ? aiColor3D(1.0, 1.0, 1.0) : surf.mColor); ------------------ | Branch (346:12): [True: 2, False: 13] ------------------ 347| 15| clr.r *= surf.mDiffuseValue; 348| 15| clr.g *= surf.mDiffuseValue; 349| 15| clr.b *= surf.mDiffuseValue; 350| | pcMat->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE); 351| 15|} _ZN6Assimp11LWOImporter14FindUVChannelsERNSt3__14listINS_3LWO7TextureENS1_9allocatorIS4_EEEERNS3_5LayerERNS3_9UVChannelEj: 355| 28| LWO::Layer & /*layer*/, LWO::UVChannel &uv, unsigned int next) { 356| 28| char ret = 0; 357| 28| for (auto &texture : list) { ------------------ | Branch (357:24): [True: 3, False: 28] ------------------ 358| | 359| | // Ignore textures with non-UV mappings for the moment. 360| 3| if (!texture.enabled || !texture.bCanUse || texture.mapMode != LWO::Texture::UV) { ------------------ | Branch (360:13): [True: 0, False: 3] | Branch (360:33): [True: 0, False: 3] | Branch (360:53): [True: 0, False: 3] ------------------ 361| 0| continue; 362| 0| } 363| | 364| 3| if (texture.mUVChannelIndex == uv.name) { ------------------ | Branch (364:13): [True: 2, False: 1] ------------------ 365| 2| ret = 1; 366| | 367| | // got it. 368| 2| if (texture.mRealUVIndex == UINT_MAX || texture.mRealUVIndex == next) { ------------------ | Branch (368:17): [True: 2, False: 0] | Branch (368:53): [True: 0, False: 0] ------------------ 369| 2| texture.mRealUVIndex = next; 370| 2| } else { 371| | // channel mismatch. need to duplicate the material. 372| 0| ASSIMP_LOG_WARN("LWO: Channel mismatch, would need to duplicate surface [design bug]"); 373| | 374| | // TODO 375| 0| } 376| 2| } 377| 3| } 378| 28| return ret; 379| 28|} _ZN6Assimp11LWOImporter14FindUVChannelsERNS_3LWO7SurfaceERNSt3__16vectorIjNS4_9allocatorIjEEEERNS1_5LayerEPj: 384| 18| unsigned int out[AI_MAX_NUMBER_OF_TEXTURECOORDS]) { 385| 18| unsigned int next = 0, extra = 0, num_extra = 0; 386| | 387| | // Check whether we have an UV entry != 0 for one of the faces in 'sorted' 388| 22| for (unsigned int i = 0; i < layer.mUVChannels.size(); ++i) { ------------------ | Branch (388:30): [True: 4, False: 18] ------------------ 389| 4| LWO::UVChannel &uv = layer.mUVChannels[i]; 390| | 391| 8| for (LWO::SortedRep::const_iterator it = sorted.begin(); it != sorted.end(); ++it) { ------------------ | Branch (391:66): [True: 4, False: 4] ------------------ 392| | 393| 4| LWO::Face &face = layer.mFaces[*it]; 394| | 395| 4| for (unsigned int n = 0; n < face.mNumIndices; ++n) { ------------------ | Branch (395:38): [True: 4, False: 0] ------------------ 396| 4| unsigned int idx = face.mIndices[n]; 397| | 398| 4| if (uv.abAssigned[idx] && ((aiVector2D *)&uv.rawData[0])[idx] != aiVector2D()) { ------------------ | Branch (398:21): [True: 4, False: 0] | Branch (398:21): [True: 4, False: 0] | Branch (398:43): [True: 4, False: 0] ------------------ 399| | 400| 4| if (extra >= AI_MAX_NUMBER_OF_TEXTURECOORDS) { ------------------ | Branch (400:25): [True: 0, False: 4] ------------------ 401| | 402| 0| ASSIMP_LOG_ERROR("LWO: Maximum number of UV channels for " 403| 0| "this mesh reached. Skipping channel \'" + 404| 0| uv.name + "\'"); 405| | 406| 4| } else { 407| | // Search through all textures assigned to 'surf' and look for this UV channel 408| 4| char had = 0; 409| 4| had |= FindUVChannels(surf.mColorTextures, layer, uv, next); 410| 4| had |= FindUVChannels(surf.mDiffuseTextures, layer, uv, next); 411| 4| had |= FindUVChannels(surf.mSpecularTextures, layer, uv, next); 412| 4| had |= FindUVChannels(surf.mGlossinessTextures, layer, uv, next); 413| 4| had |= FindUVChannels(surf.mOpacityTextures, layer, uv, next); 414| 4| had |= FindUVChannels(surf.mBumpTextures, layer, uv, next); 415| 4| had |= FindUVChannels(surf.mReflectionTextures, layer, uv, next); 416| | 417| | // We have a texture referencing this UV channel so we have to take special care 418| | // and are willing to drop unreferenced channels in favour of it. 419| 4| if (had != 0) { ------------------ | Branch (419:29): [True: 2, False: 2] ------------------ 420| 2| if (num_extra) { ------------------ | Branch (420:33): [True: 0, False: 2] ------------------ 421| | 422| 0| for (unsigned int a = next; a < std::min(extra, AI_MAX_NUMBER_OF_TEXTURECOORDS - 1u); ++a) { ------------------ | Branch (422:61): [True: 0, False: 0] ------------------ 423| 0| out[a + 1] = out[a]; 424| 0| } 425| 0| } 426| 2| ++extra; 427| 2| out[next++] = i; 428| 2| } 429| | // Bah ... seems not to be used at all. Push to end if enough space is available. 430| 2| else { 431| 2| out[extra++] = i; 432| 2| ++num_extra; 433| 2| } 434| 4| } 435| 4| it = sorted.end() - 1; 436| 4| break; 437| 4| } 438| 4| } 439| 4| } 440| 4| } 441| 18| if (extra < AI_MAX_NUMBER_OF_TEXTURECOORDS) { ------------------ | Branch (441:9): [True: 18, False: 0] ------------------ 442| | out[extra] = UINT_MAX; 443| 18| } 444| 18|} _ZN6Assimp11LWOImporter14FindVCChannelsERKNS_3LWO7SurfaceERNSt3__16vectorIjNS5_9allocatorIjEEEERKNS1_5LayerEPj: 448| 18| unsigned int out[AI_MAX_NUMBER_OF_COLOR_SETS]) { 449| 18| unsigned int next = 0; 450| | 451| | // Check whether we have an vc entry != 0 for one of the faces in 'sorted' 452| 20| for (unsigned int i = 0; i < layer.mVColorChannels.size(); ++i) { ------------------ | Branch (452:30): [True: 2, False: 18] ------------------ 453| 2| const LWO::VColorChannel &vc = layer.mVColorChannels[i]; 454| | 455| 2| if (surf.mVCMap == vc.name) { ------------------ | Branch (455:13): [True: 1, False: 1] ------------------ 456| | // The vertex color map is explicitly requested by the surface so we need to take special care of it 457| 1| for (unsigned int a = 0; a < std::min(next, AI_MAX_NUMBER_OF_COLOR_SETS - 1u); ++a) { ------------------ | Branch (457:38): [True: 0, False: 1] ------------------ 458| 0| out[a + 1] = out[a]; 459| 0| } 460| 1| out[0] = i; 461| 1| ++next; 462| 1| } else { 463| | 464| 2| for (LWO::SortedRep::iterator it = sorted.begin(); it != sorted.end(); ++it) { ------------------ | Branch (464:64): [True: 1, False: 1] ------------------ 465| 1| const LWO::Face &face = layer.mFaces[*it]; 466| | 467| 1| for (unsigned int n = 0; n < face.mNumIndices; ++n) { ------------------ | Branch (467:42): [True: 1, False: 0] ------------------ 468| 1| unsigned int idx = face.mIndices[n]; 469| | 470| 1| if (vc.abAssigned[idx] && ((aiColor4D *)&vc.rawData[0])[idx] != aiColor4D(0.0, 0.0, 0.0, 1.0)) { ------------------ | Branch (470:25): [True: 1, False: 0] | Branch (470:25): [True: 1, False: 0] | Branch (470:47): [True: 1, False: 0] ------------------ 471| 1| if (next >= AI_MAX_NUMBER_OF_COLOR_SETS) { ------------------ | Branch (471:29): [True: 0, False: 1] ------------------ 472| | 473| 0| ASSIMP_LOG_ERROR("LWO: Maximum number of vertex color channels for " 474| 0| "this mesh reached. Skipping channel \'" + 475| 0| vc.name + "\'"); 476| | 477| 1| } else { 478| 1| out[next++] = i; 479| 1| } 480| 1| it = sorted.end() - 1; 481| 1| break; 482| 1| } 483| 1| } 484| 1| } 485| 1| } 486| 2| } 487| 18| if (next != AI_MAX_NUMBER_OF_COLOR_SETS) { ------------------ | Branch (487:9): [True: 18, False: 0] ------------------ 488| | out[next] = UINT_MAX; 489| 18| } 490| 18|} _ZN6Assimp11LWOImporter16LoadLWO2ImageMapEjRNS_3LWO7TextureE: 493| 2|void LWOImporter::LoadLWO2ImageMap(unsigned int size, LWO::Texture &tex) { 494| 2| LE_NCONST uint8_t *const end = mFileBuffer + size; 495| 22| while (true) { ------------------ | Branch (495:12): [True: 22, Folded] ------------------ 496| 22| if (mFileBuffer + 6 >= end) break; ------------------ | Branch (496:13): [True: 2, False: 20] ------------------ 497| 20| LE_NCONST IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer); 498| | 499| 20| if (mFileBuffer + head.length > end) ------------------ | Branch (499:13): [True: 0, False: 20] ------------------ 500| 0| throw DeadlyImportError("LWO2: Invalid SURF.BLOCK chunk length"); 501| | 502| 20| uint8_t *const next = mFileBuffer + head.length; 503| 20| switch (head.type) { ------------------ | Branch (503:17): [True: 14, False: 6] ------------------ 504| 2| case AI_LWO_PROJ: ------------------ | | 194| 2|#define AI_LWO_PROJ AI_IFF_FOURCC('P', 'R', 'O', 'J') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (504:13): [True: 2, False: 18] ------------------ 505| 2| tex.mapMode = (Texture::MappingMode)GetU2(); 506| 2| break; 507| 2| case AI_LWO_WRAP: ------------------ | | 211| 2|#define AI_LWO_WRAP AI_IFF_FOURCC('W', 'R', 'A', 'P') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (507:13): [True: 2, False: 18] ------------------ 508| 2| tex.wrapModeWidth = (Texture::Wrap)GetU2(); 509| 2| tex.wrapModeHeight = (Texture::Wrap)GetU2(); 510| 2| break; 511| 2| case AI_LWO_AXIS: ------------------ | | 200| 2|#define AI_LWO_AXIS AI_IFF_FOURCC('A', 'X', 'I', 'S') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (511:13): [True: 2, False: 18] ------------------ 512| 2| tex.majorAxis = (Texture::Axes)GetU2(); 513| 2| break; 514| 2| case AI_LWO_IMAG: ------------------ | | 210| 2|#define AI_LWO_IMAG AI_IFF_FOURCC('I', 'M', 'A', 'G') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (514:13): [True: 2, False: 18] ------------------ 515| 2| tex.mClipIdx = GetU2(); 516| 2| break; 517| 2| case AI_LWO_VMAP: ------------------ | | 214| 2|#define AI_LWO_VMAP AI_IFF_FOURCC('V', 'M', 'A', 'P') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (517:13): [True: 2, False: 18] ------------------ 518| 2| GetS0(tex.mUVChannelIndex, head.length); 519| 2| break; 520| 2| case AI_LWO_WRPH: ------------------ | | 213| 2|#define AI_LWO_WRPH AI_IFF_FOURCC('W', 'R', 'P', 'H') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (520:13): [True: 2, False: 18] ------------------ 521| 2| tex.wrapAmountH = GetF4(); 522| 2| break; 523| 2| case AI_LWO_WRPW: ------------------ | | 212| 2|#define AI_LWO_WRPW AI_IFF_FOURCC('W', 'R', 'P', 'W') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (523:13): [True: 2, False: 18] ------------------ 524| 2| tex.wrapAmountW = GetF4(); 525| 2| break; 526| 20| } 527| 20| mFileBuffer = next; 528| 20| } 529| 2|} _ZN6Assimp11LWOImporter21LoadLWO2TextureHeaderEjRNS_3LWO7TextureE: 546| 2|void LWOImporter::LoadLWO2TextureHeader(unsigned int size, LWO::Texture &tex) { 547| 2| LE_NCONST uint8_t *const end = mFileBuffer + size; 548| | 549| | // get the ordinal string 550| 2| GetS0(tex.ordinal, size); 551| | 552| | // we could crash later if this is an empty string ... 553| 2| if (!tex.ordinal.length()) { ------------------ | Branch (553:9): [True: 0, False: 2] ------------------ 554| 0| ASSIMP_LOG_ERROR("LWO2: Ill-formed SURF.BLOK ordinal string"); 555| 0| tex.ordinal = "\x00"; 556| 0| } 557| 10| while (true) { ------------------ | Branch (557:12): [True: 10, Folded] ------------------ 558| 10| if (mFileBuffer + 6 >= end) break; ------------------ | Branch (558:13): [True: 2, False: 8] ------------------ 559| 8| const IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer); 560| | 561| 8| if (mFileBuffer + head.length > end) ------------------ | Branch (561:13): [True: 0, False: 8] ------------------ 562| 0| throw DeadlyImportError("LWO2: Invalid texture header chunk length"); 563| | 564| 8| uint8_t *const next = mFileBuffer + head.length; 565| 8| switch (head.type) { ------------------ | Branch (565:17): [True: 6, False: 2] ------------------ 566| 2| case AI_LWO_CHAN: ------------------ | | 189| 2|#define AI_LWO_CHAN AI_IFF_FOURCC('C', 'H', 'A', 'N') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (566:13): [True: 2, False: 6] ------------------ 567| 2| tex.type = GetU4(); 568| 2| break; 569| 2| case AI_LWO_ENAB: ------------------ | | 191| 2|#define AI_LWO_ENAB AI_IFF_FOURCC('E', 'N', 'A', 'B') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (569:13): [True: 2, False: 6] ------------------ 570| 2| tex.enabled = GetU2() ? true : false; ------------------ | Branch (570:31): [True: 2, False: 0] ------------------ 571| 2| break; 572| 2| case AI_LWO_OPAC: ------------------ | | 192| 2|#define AI_LWO_OPAC AI_IFF_FOURCC('O', 'P', 'A', 'C') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (572:13): [True: 2, False: 6] ------------------ 573| 2| tex.blendType = (Texture::BlendType)GetU2(); 574| 2| tex.mStrength = GetF4(); 575| 2| break; 576| 8| } 577| 8| mFileBuffer = next; 578| 8| } 579| 2|} _ZN6Assimp11LWOImporter20LoadLWO2TextureBlockEPNS_3IFF14SubChunkHeaderEj: 582| 2|void LWOImporter::LoadLWO2TextureBlock(LE_NCONST IFF::SubChunkHeader *head, unsigned int size) { 583| 2| ai_assert(!mSurfaces->empty()); 584| 2| LWO::Surface &surf = mSurfaces->back(); 585| 2| LWO::Texture tex; 586| | 587| | // load the texture header 588| 2| LoadLWO2TextureHeader(head->length, tex); 589| 2| size -= head->length + 6; 590| | 591| | // now get the exact type of the texture 592| 2| switch (head->type) { ------------------ | Branch (592:13): [True: 2, False: 0] ------------------ 593| 0| case AI_LWO_PROC: ------------------ | | 219| 0|#define AI_LWO_PROC AI_IFF_FOURCC('P', 'R', 'O', 'C') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (593:9): [True: 0, False: 2] ------------------ 594| 0| LoadLWO2Procedural(size, tex); 595| 0| break; 596| 0| case AI_LWO_GRAD: ------------------ | | 228| 0|#define AI_LWO_GRAD AI_IFF_FOURCC('G', 'R', 'A', 'D') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (596:9): [True: 0, False: 2] ------------------ 597| 0| LoadLWO2Gradient(size, tex); 598| 0| break; 599| 2| case AI_LWO_IMAP: ------------------ | | 298| 2|#define AI_LWO_IMAP AI_IFF_FOURCC('I', 'M', 'A', 'P') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (599:9): [True: 2, False: 0] ------------------ 600| 2| LoadLWO2ImageMap(size, tex); 601| 2| } 602| | 603| | // get the destination channel 604| 2| TextureList *listRef = nullptr; 605| 2| switch (tex.type) { 606| 2| case AI_LWO_COLR: ------------------ | | 220| 2|#define AI_LWO_COLR AI_IFF_FOURCC('C', 'O', 'L', 'R') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (606:9): [True: 2, False: 0] ------------------ 607| 2| listRef = &surf.mColorTextures; 608| 2| break; 609| 0| case AI_LWO_DIFF: ------------------ | | 160| 0|#define AI_LWO_DIFF AI_IFF_FOURCC('D', 'I', 'F', 'F') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (609:9): [True: 0, False: 2] ------------------ 610| 0| listRef = &surf.mDiffuseTextures; 611| 0| break; 612| 0| case AI_LWO_SPEC: ------------------ | | 161| 0|#define AI_LWO_SPEC AI_IFF_FOURCC('S', 'P', 'E', 'C') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (612:9): [True: 0, False: 2] ------------------ 613| 0| listRef = &surf.mSpecularTextures; 614| 0| break; 615| 0| case AI_LWO_GLOS: ------------------ | | 162| 0|#define AI_LWO_GLOS AI_IFF_FOURCC('G', 'L', 'O', 'S') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (615:9): [True: 0, False: 2] ------------------ 616| 0| listRef = &surf.mGlossinessTextures; 617| 0| break; 618| 0| case AI_LWO_BUMP: ------------------ | | 172| 0|#define AI_LWO_BUMP AI_IFF_FOURCC('B', 'U', 'M', 'P') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (618:9): [True: 0, False: 2] ------------------ 619| 0| listRef = &surf.mBumpTextures; 620| 0| break; 621| 0| case AI_LWO_TRAN: ------------------ | | 167| 0|#define AI_LWO_TRAN AI_IFF_FOURCC('T', 'R', 'A', 'N') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (621:9): [True: 0, False: 2] ------------------ 622| 0| listRef = &surf.mOpacityTextures; 623| 0| break; 624| 0| case AI_LWO_REFL: ------------------ | | 163| 0|#define AI_LWO_REFL AI_IFF_FOURCC('R', 'E', 'F', 'L') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (624:9): [True: 0, False: 2] ------------------ 625| 0| listRef = &surf.mReflectionTextures; 626| 0| break; 627| 0| default: ------------------ | Branch (627:9): [True: 0, False: 2] ------------------ 628| 0| ASSIMP_LOG_WARN("LWO2: Encountered unknown texture type"); 629| 0| return; 630| 2| } 631| | 632| | // now attach the texture to the parent surface - sort by ordinal string 633| 2| for (TextureList::iterator it = listRef->begin(); it != listRef->end(); ++it) { ------------------ | Branch (633:55): [True: 0, False: 2] ------------------ 634| 0| if (::strcmp(tex.ordinal.c_str(), (*it).ordinal.c_str()) < 0) { ------------------ | Branch (634:13): [True: 0, False: 0] ------------------ 635| 0| listRef->insert(it, tex); 636| 0| return; 637| 0| } 638| 0| } 639| 2| listRef->push_back(tex); 640| 2|} _ZN6Assimp11LWOImporter15LoadLWO2SurfaceEj: 934| 12|void LWOImporter::LoadLWO2Surface(unsigned int size) { 935| 12| LE_NCONST uint8_t *const end = mFileBuffer + size; 936| | 937| 12| mSurfaces->push_back(LWO::Surface()); 938| 12| LWO::Surface &surf = mSurfaces->back(); 939| | 940| 12| GetS0(surf.mName, size); 941| | 942| | // check whether this surface was derived from any other surface 943| 12| std::string derived; 944| 12| GetS0(derived, (unsigned int)(end - mFileBuffer)); 945| 12| if (derived.length()) { ------------------ | Branch (945:9): [True: 0, False: 12] ------------------ 946| | // yes, find this surface 947| 0| for (SurfaceList::iterator it = mSurfaces->begin(), itEnd = mSurfaces->end() - 1; it != itEnd; ++it) { ------------------ | Branch (947:91): [True: 0, False: 0] ------------------ 948| 0| if ((*it).mName == derived) { ------------------ | Branch (948:17): [True: 0, False: 0] ------------------ 949| | // we have it ... 950| 0| surf = *it; 951| 0| derived.clear(); 952| 0| break; 953| 0| } 954| 0| } 955| 0| if (derived.size()) { ------------------ | Branch (955:13): [True: 0, False: 0] ------------------ 956| 0| ASSIMP_LOG_WARN("LWO2: Unable to find source surface: ", derived); 957| 0| } 958| 0| } 959| | 960| 88| while (true) { ------------------ | Branch (960:12): [True: 88, Folded] ------------------ 961| 88| if (mFileBuffer + 6 >= end) ------------------ | Branch (961:13): [True: 12, False: 76] ------------------ 962| 12| break; 963| 76| const IFF::SubChunkHeader head = IFF::LoadSubChunk(mFileBuffer); 964| | 965| 76| if (mFileBuffer + head.length > end) ------------------ | Branch (965:13): [True: 0, False: 76] ------------------ 966| 0| throw DeadlyImportError("LWO2: Invalid surface chunk length"); 967| | 968| 76| uint8_t *const next = mFileBuffer + head.length; 969| 76| switch (head.type) { ------------------ | Branch (969:17): [True: 49, False: 27] ------------------ 970| | // diffuse color 971| 12| case AI_LWO_COLR: { ------------------ | | 220| 12|#define AI_LWO_COLR AI_IFF_FOURCC('C', 'O', 'L', 'R') | | ------------------ | | | | 50| 12|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 12| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (971:13): [True: 12, False: 64] ------------------ 972| 12| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, COLR, 12); ------------------ | | 631| 12| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 12] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 973| 12| surf.mColor.r = GetF4(); 974| 12| surf.mColor.g = GetF4(); 975| 12| surf.mColor.b = GetF4(); 976| 12| break; 977| 12| } 978| | // diffuse strength ... hopefully 979| 12| case AI_LWO_DIFF: { ------------------ | | 160| 12|#define AI_LWO_DIFF AI_IFF_FOURCC('D', 'I', 'F', 'F') | | ------------------ | | | | 50| 12|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 12| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (979:13): [True: 12, False: 64] ------------------ 980| 12| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, DIFF, 4); ------------------ | | 631| 12| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 12] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 981| 12| surf.mDiffuseValue = GetF4(); 982| 12| break; 983| 12| } 984| | // specular strength ... hopefully 985| 7| case AI_LWO_SPEC: { ------------------ | | 161| 7|#define AI_LWO_SPEC AI_IFF_FOURCC('S', 'P', 'E', 'C') | | ------------------ | | | | 50| 7|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 7| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (985:13): [True: 7, False: 69] ------------------ 986| 7| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, SPEC, 4); ------------------ | | 631| 7| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 7] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 987| 7| surf.mSpecularValue = GetF4(); 988| 7| break; 989| 7| } 990| | // transparency 991| 1| case AI_LWO_TRAN: { ------------------ | | 167| 1|#define AI_LWO_TRAN AI_IFF_FOURCC('T', 'R', 'A', 'N') | | ------------------ | | | | 50| 1|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 1| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (991:13): [True: 1, False: 75] ------------------ 992| | // transparency explicitly disabled? 993| 1| if (surf.mTransparency == 10e10f) ------------------ | Branch (993:21): [True: 0, False: 1] ------------------ 994| 0| break; 995| | 996| 1| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, TRAN, 4); ------------------ | | 631| 1| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 1] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 997| 1| surf.mTransparency = GetF4(); 998| 1| break; 999| 1| } 1000| | // additive transparency 1001| 0| case AI_LWO_ADTR: { ------------------ | | 177| 0|#define AI_LWO_ADTR AI_IFF_FOURCC('A', 'D', 'T', 'R') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1001:13): [True: 0, False: 76] ------------------ 1002| 0| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, ADTR, 4); ------------------ | | 631| 0| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 0] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1003| 0| surf.mAdditiveTransparency = GetF4(); 1004| 0| break; 1005| 0| } 1006| | // wireframe mode 1007| 0| case AI_LWO_LINE: { ------------------ | | 179| 0|#define AI_LWO_LINE AI_IFF_FOURCC('L', 'I', 'N', 'E') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1007:13): [True: 0, False: 76] ------------------ 1008| 0| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, LINE, 2); ------------------ | | 631| 0| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 0] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1009| 0| if (GetU2() & 0x1) ------------------ | Branch (1009:21): [True: 0, False: 0] ------------------ 1010| 0| surf.mWireframe = true; 1011| 0| break; 1012| 0| } 1013| | // glossiness 1014| 1| case AI_LWO_GLOS: { ------------------ | | 162| 1|#define AI_LWO_GLOS AI_IFF_FOURCC('G', 'L', 'O', 'S') | | ------------------ | | | | 50| 1|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 1| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1014:13): [True: 1, False: 75] ------------------ 1015| 1| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, GLOS, 4); ------------------ | | 631| 1| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 1] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1016| 1| surf.mGlossiness = GetF4(); 1017| 1| break; 1018| 1| } 1019| | // bump intensity 1020| 1| case AI_LWO_BUMP: { ------------------ | | 172| 1|#define AI_LWO_BUMP AI_IFF_FOURCC('B', 'U', 'M', 'P') | | ------------------ | | | | 50| 1|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 1| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1020:13): [True: 1, False: 75] ------------------ 1021| 1| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, BUMP, 4); ------------------ | | 631| 1| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 1] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1022| 1| surf.mBumpIntensity = GetF4(); 1023| 1| break; 1024| 1| } 1025| | // color highlights 1026| 0| case AI_LWO_CLRH: { ------------------ | | 175| 0|#define AI_LWO_CLRH AI_IFF_FOURCC('C', 'L', 'R', 'H') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1026:13): [True: 0, False: 76] ------------------ 1027| 0| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, CLRH, 4); ------------------ | | 631| 0| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 0] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1028| 0| surf.mColorHighlights = GetF4(); 1029| 0| break; 1030| 0| } 1031| | // index of refraction 1032| 1| case AI_LWO_RIND: { ------------------ | | 170| 1|#define AI_LWO_RIND AI_IFF_FOURCC('R', 'I', 'N', 'D') | | ------------------ | | | | 50| 1|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 1| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1032:13): [True: 1, False: 75] ------------------ 1033| 1| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, RIND, 4); ------------------ | | 631| 1| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 1] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1034| 1| surf.mIOR = GetF4(); 1035| 1| break; 1036| 1| } 1037| | // polygon sidedness 1038| 2| case AI_LWO_SIDE: { ------------------ | | 174| 2|#define AI_LWO_SIDE AI_IFF_FOURCC('S', 'I', 'D', 'E') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1038:13): [True: 2, False: 74] ------------------ 1039| 2| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, SIDE, 2); ------------------ | | 631| 2| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 2] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1040| 2| surf.bDoubleSided = (3 == GetU2()); 1041| 2| break; 1042| 2| } 1043| | // maximum smoothing angle 1044| 9| case AI_LWO_SMAN: { ------------------ | | 173| 9|#define AI_LWO_SMAN AI_IFF_FOURCC('S', 'M', 'A', 'N') | | ------------------ | | | | 50| 9|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 9| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1044:13): [True: 9, False: 67] ------------------ 1045| 9| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, SMAN, 4); ------------------ | | 631| 9| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 9] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1046| 9| surf.mMaximumSmoothAngle = std::fabs(GetF4()); 1047| 9| break; 1048| 9| } 1049| | // vertex color channel to be applied to the surface 1050| 1| case AI_LWO_VCOL: { ------------------ | | 185| 1|#define AI_LWO_VCOL AI_IFF_FOURCC('V', 'C', 'O', 'L') | | ------------------ | | | | 50| 1|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 1| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1050:13): [True: 1, False: 75] ------------------ 1051| 1| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, VCOL, 12); ------------------ | | 631| 1| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 1] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1052| 1| surf.mDiffuseValue *= GetF4(); // strength 1053| 1| ReadVSizedIntLWO2(mFileBuffer); // skip envelope 1054| 1| surf.mVCMapType = GetU4(); // type of the channel 1055| | 1056| | // name of the channel 1057| 1| GetS0(surf.mVCMap, (unsigned int)(next - mFileBuffer)); 1058| 1| break; 1059| 1| } 1060| | // surface bock entry 1061| 2| case AI_LWO_BLOK: { ------------------ | | 184| 2|#define AI_LWO_BLOK AI_IFF_FOURCC('B', 'L', 'O', 'K') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1061:13): [True: 2, False: 74] ------------------ 1062| 2| AI_LWO_VALIDATE_CHUNK_LENGTH(head.length, BLOK, 4); ------------------ | | 631| 2| if (length < size) { \ | | ------------------ | | | Branch (631:9): [True: 0, False: 2] | | ------------------ | | 632| 0| throw DeadlyImportError("LWO: " #name " chunk is too small"); \ | | 633| 0| } ------------------ 1063| 2| IFF::SubChunkHeader head2 = IFF::LoadSubChunk(mFileBuffer); 1064| | 1065| 2| switch (head2.type) { 1066| 0| case AI_LWO_PROC: ------------------ | | 219| 0|#define AI_LWO_PROC AI_IFF_FOURCC('P', 'R', 'O', 'C') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1066:21): [True: 0, False: 2] ------------------ 1067| 0| case AI_LWO_GRAD: ------------------ | | 228| 0|#define AI_LWO_GRAD AI_IFF_FOURCC('G', 'R', 'A', 'D') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1067:21): [True: 0, False: 2] ------------------ 1068| 2| case AI_LWO_IMAP: ------------------ | | 298| 2|#define AI_LWO_IMAP AI_IFF_FOURCC('I', 'M', 'A', 'P') | | ------------------ | | | | 50| 2|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 2| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1068:21): [True: 2, False: 0] ------------------ 1069| 2| LoadLWO2TextureBlock(&head2, head.length); 1070| 2| break; 1071| 0| case AI_LWO_SHDR: ------------------ | | 238| 0|#define AI_LWO_SHDR AI_IFF_FOURCC('S', 'H', 'D', 'R') | | ------------------ | | | | 50| 0|#define AI_IFF_FOURCC(a,b,c,d) ((uint32_t) (((uint8_t)a << 24u) | \ | | | | 51| 0| ((uint8_t)b << 16u) | ((uint8_t)c << 8u) | ((uint8_t)d))) | | ------------------ ------------------ | Branch (1071:21): [True: 0, False: 2] ------------------ 1072| 0| LoadLWO2ShaderBlock(&head2, head.length); 1073| 0| break; 1074| | 1075| 0| default: ------------------ | Branch (1075:21): [True: 0, False: 2] ------------------ 1076| 0| ASSIMP_LOG_WARN("LWO2: Found an unsupported surface BLOK"); 1077| 2| }; 1078| | 1079| 2| break; 1080| 2| } 1081| 76| } 1082| 76| mFileBuffer = next; 1083| 76| } 1084| 12|} _Z10GetMapModeN6Assimp3LWO7Texture4WrapE: 60| 4|inline aiTextureMapMode GetMapMode(LWO::Texture::Wrap in) { 61| 4| switch (in) { ------------------ | Branch (61:13): [True: 4, False: 0] ------------------ 62| 4| case LWO::Texture::REPEAT: ------------------ | Branch (62:9): [True: 4, False: 0] ------------------ 63| 4| return aiTextureMapMode_Wrap; 64| | 65| 0| case LWO::Texture::MIRROR: ------------------ | Branch (65:9): [True: 0, False: 4] ------------------ 66| 0| return aiTextureMapMode_Mirror; 67| | 68| 0| case LWO::Texture::RESET: ------------------ | Branch (68:9): [True: 0, False: 4] ------------------ 69| 0| ASSIMP_LOG_WARN("LWO2: Unsupported texture map mode: RESET"); 70| | 71| | // fall though here 72| 0| case LWO::Texture::EDGE: ------------------ | Branch (72:9): [True: 0, False: 4] ------------------ 73| 0| return aiTextureMapMode_Clamp; 74| 4| } 75| 0| return (aiTextureMapMode)0; 76| 4|} _Z4lerpI9aiColor3DET_RKS1_S3_f: 54| 15|T lerp(const T &one, const T &two, float val) { 55| 15| return one + (two - one) * val; 56| 15|} _ZN6Assimp3LWS7Element5ParseERPKcS3_i: 85| 149|void LWS::Element::Parse(const char *&buffer, const char *end, int depth) { 86| 149| if (depth > MAX_DEPTH) { ------------------ | Branch (86:9): [True: 0, False: 149] ------------------ 87| 0| throw std::runtime_error("Maximum recursion depth exceeded in LWS::Element::Parse"); 88| 0| } 89| | 90| 157k| for (; SkipSpacesAndLineEnd(&buffer, end); SkipLine(&buffer, end)) { ------------------ | Branch (90:12): [True: 157k, False: 149] ------------------ 91| | 92| | // begin of a new element with children 93| 157k| bool sub = false; 94| 157k| if (*buffer == '{') { ------------------ | Branch (94:13): [True: 2, False: 157k] ------------------ 95| 2| ++buffer; 96| 2| SkipSpaces(&buffer, end); 97| 2| sub = true; 98| 157k| } else if (*buffer == '}') ------------------ | Branch (98:20): [True: 0, False: 157k] ------------------ 99| 0| return; 100| | 101| 157k| children.emplace_back(); 102| | 103| | // copy data line - read token per token 104| | 105| 157k| const char *cur = buffer; 106| 1.74M| while (!IsSpaceOrNewLine(*buffer)) ------------------ | Branch (106:16): [True: 1.58M, False: 157k] ------------------ 107| 1.58M| ++buffer; 108| 157k| children.back().tokens[0] = std::string(cur, (size_t)(buffer - cur)); 109| 157k| SkipSpaces(&buffer, end); 110| | 111| 157k| if (children.back().tokens[0] == "Plugin") { ------------------ | Branch (111:13): [True: 0, False: 157k] ------------------ 112| 0| ASSIMP_LOG_VERBOSE_DEBUG("LWS: Skipping over plugin-specific data"); 113| | 114| | // strange stuff inside Plugin/Endplugin blocks. Needn't 115| | // follow LWS syntax, so we skip over it 116| 0| for (; SkipSpacesAndLineEnd(&buffer, end); SkipLine(&buffer, end)) { ------------------ | Branch (116:20): [True: 0, False: 0] ------------------ 117| 0| if (!::strncmp(buffer, "EndPlugin", 9)) { ------------------ | Branch (117:21): [True: 0, False: 0] ------------------ 118| 0| break; 119| 0| } 120| 0| } 121| 0| continue; 122| 0| } 123| | 124| 157k| cur = buffer; 125| 1.92M| while (!IsLineEnd(*buffer)) { ------------------ | Branch (125:16): [True: 1.76M, False: 157k] ------------------ 126| 1.76M| ++buffer; 127| 1.76M| } 128| 157k| children.back().tokens[1] = std::string(cur, (size_t)(buffer - cur)); 129| | 130| | // parse more elements recursively 131| 157k| if (sub) { ------------------ | Branch (131:13): [True: 2, False: 157k] ------------------ 132| 2| children.back().Parse(buffer, end, depth + 1); 133| 2| } 134| 157k| } 135| 149|} _ZN6Assimp11LWSImporterC2Ev: 145| 624| noSkeletonMesh() { 146| | // nothing to do here 147| 624|} _ZNK6Assimp11LWSImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 151| 287|bool LWSImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 152| 287| static constexpr uint32_t tokens[] = { 153| 287| AI_MAKE_MAGIC("LWSC"), 154| 287| AI_MAKE_MAGIC("LWMO") 155| 287| }; 156| | return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); 157| 287|} _ZNK6Assimp11LWSImporter7GetInfoEv: 161| 781|const aiImporterDesc *LWSImporter::GetInfo() const { 162| 781| return &desc; 163| 781|} _ZN6Assimp11LWSImporter15SetupPropertiesEPKNS_8ImporterE: 169| 147|void LWSImporter::SetupProperties(const Importer *pImp) { 170| | // AI_CONFIG_FAVOUR_SPEED 171| 147| configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 0)); 172| | 173| | // AI_CONFIG_IMPORT_LWS_ANIM_START 174| 147| first = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_LWS_ANIM_START, 175| 147| MagicHackNo /* magic hack */); 176| | 177| | // AI_CONFIG_IMPORT_LWS_ANIM_END 178| 147| last = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_LWS_ANIM_END, 179| 147| MagicHackNo /* magic hack */); 180| | 181| 147| if (last < first) { ------------------ | Branch (181:9): [True: 0, False: 147] ------------------ 182| 0| std::swap(last, first); 183| 0| } 184| | 185| | noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, 0) != 0; 186| 147|} _ZN6Assimp11LWSImporter16ReadEnvelope_OldERNSt3__121__list_const_iteratorINS_3LWS7ElementEPvEERKS6_RNS3_8NodeDescEj: 259| 601| LWS::NodeDesc &nodes, unsigned int) { 260| 601| if (++it == endIt) { ------------------ | Branch (260:9): [True: 0, False: 601] ------------------ 261| 0| ASSIMP_LOG_ERROR("LWS: Encountered unexpected end of file while parsing object motion"); 262| 0| return; 263| 0| } 264| | 265| 601| const unsigned int num = strtoul10((*it).tokens[0].c_str()); 266| 1.92k| for (unsigned int i = 0; i < num; ++i) { ------------------ | Branch (266:30): [True: 1.32k, False: 601] ------------------ 267| 1.32k| nodes.channels.emplace_back(); 268| 1.32k| LWO::Envelope &envl = nodes.channels.back(); 269| | 270| 1.32k| envl.index = i; 271| 1.32k| envl.type = (LWO::EnvelopeType)(i + 1); 272| | 273| 1.32k| if (++it == endIt) { ------------------ | Branch (273:13): [True: 0, False: 1.32k] ------------------ 274| 0| ASSIMP_LOG_ERROR("LWS: Encountered unexpected end of file while parsing object motion"); 275| 0| return; 276| 0| } 277| | 278| 1.32k| const unsigned int sub_num = strtoul10((*it).tokens[0].c_str()); 279| 1.99k| for (unsigned int n = 0; n < sub_num; ++n) { ------------------ | Branch (279:34): [True: 675, False: 1.32k] ------------------ 280| 675| if (++it == endIt) { ------------------ | Branch (280:17): [True: 0, False: 675] ------------------ 281| 0| ASSIMP_LOG_ERROR("LWS: Encountered unexpected end of file while parsing object motion"); 282| 0| return; 283| 0| } 284| | 285| | // parse value and time, skip the rest for the moment. 286| 675| LWO::Key key; 287| 675| const char *c = fast_atoreal_move((*it).tokens[0].c_str(), key.value); 288| 675| const char *end = c + (*it).tokens[0].size(); 289| 675| SkipSpaces(&c, end); 290| 675| float f; 291| 675| fast_atoreal_move((*it).tokens[0].c_str(), f); 292| 675| key.time = f; 293| | 294| 675| envl.keys.emplace_back(key); 295| 675| } 296| 1.32k| } 297| 601|} _ZN6Assimp11LWSImporter13SetupNodeNameEP6aiNodeRNS_3LWS8NodeDescE: 301| 22.0k|void LWSImporter::SetupNodeName(aiNode *nd, LWS::NodeDesc &src) { 302| 22.0k| const unsigned int combined = src.number | ((unsigned int)src.type) << 28u; 303| | 304| | // the name depends on the type. We break LWS's strange naming convention 305| | // and return human-readable, but still machine-parsable and unique, strings. 306| 22.0k| if (src.type == LWS::NodeDesc::OBJECT) { ------------------ | Branch (306:9): [True: 22.0k, False: 14] ------------------ 307| 22.0k| if (src.path.length()) { ------------------ | Branch (307:13): [True: 22.0k, False: 4] ------------------ 308| 22.0k| std::string::size_type s = src.path.find_last_of("\\/"); 309| 22.0k| if (s == std::string::npos) { ------------------ | Branch (309:17): [True: 15.2k, False: 6.79k] ------------------ 310| 15.2k| s = 0; 311| 15.2k| } else { 312| 6.79k| ++s; 313| 6.79k| } 314| 22.0k| std::string::size_type t = src.path.substr(s).find_last_of('.'); 315| | 316| 22.0k| nd->mName.length = ::ai_snprintf(nd->mName.data, AI_MAXLEN, "%s_(%08X)", src.path.substr(s).substr(0, t).c_str(), combined); 317| 22.0k| if (nd->mName.length > AI_MAXLEN) { ------------------ | Branch (317:17): [True: 4, False: 22.0k] ------------------ 318| 4| nd->mName.length = AI_MAXLEN; 319| 4| } 320| 22.0k| return; 321| 22.0k| } 322| 22.0k| } 323| 18| nd->mName.length = ::ai_snprintf(nd->mName.data, AI_MAXLEN, "%s_(%08X)", src.name, combined); 324| 18|} _ZN6Assimp11LWSImporter10BuildGraphEP6aiNodeRNS_3LWS8NodeDescERNSt3__16vectorINS_14AttachmentInfoENS6_9allocatorIS8_EEEERNS_11BatchLoaderERPP8aiCameraRPP7aiLightRNS7_IP10aiNodeAnimNS9_ISO_EEEE: 332| 11.0k| std::vector &animOut) { 333| | // Setup a very cryptic name for the node, we want the user to be happy 334| 11.0k| SetupNodeName(nd, src); 335| 11.0k| aiNode *ndAnim = nd; 336| | 337| | // If the node is an object 338| 11.0k| if (src.type == LWS::NodeDesc::OBJECT) { ------------------ | Branch (338:9): [True: 11.0k, False: 14] ------------------ 339| | 340| | // If the object is from an external file, get it 341| 11.0k| aiScene *obj = nullptr; 342| 11.0k| if (src.path.length()) { ------------------ | Branch (342:13): [True: 11.0k, False: 2] ------------------ 343| 11.0k| obj = batch.GetImport(src.id); 344| 11.0k| if (!obj) { ------------------ | Branch (344:17): [True: 10.4k, False: 555] ------------------ 345| 10.4k| ASSIMP_LOG_ERROR("LWS: Failed to read external file ", src.path); 346| 10.4k| } else { 347| 555| if (obj->mRootNode->mNumChildren == 1) { ------------------ | Branch (347:21): [True: 0, False: 555] ------------------ 348| | 349| | //If the pivot is not set for this layer, get it from the external object 350| 0| if (!src.isPivotSet) { ------------------ | Branch (350:25): [True: 0, False: 0] ------------------ 351| 0| src.pivotPos.x = +obj->mRootNode->mTransformation.a4; 352| 0| src.pivotPos.y = +obj->mRootNode->mTransformation.b4; 353| 0| src.pivotPos.z = -obj->mRootNode->mTransformation.c4; //The sign is the RH to LH back conversion 354| 0| } 355| | 356| | //Remove first node from obj (the old pivot), reset transform of second node (the mesh node) 357| 0| aiNode *newRootNode = obj->mRootNode->mChildren[0]; 358| 0| obj->mRootNode->mChildren[0] = nullptr; 359| 0| delete obj->mRootNode; 360| | 361| 0| obj->mRootNode = newRootNode; 362| 0| obj->mRootNode->mTransformation.a4 = 0.0; 363| 0| obj->mRootNode->mTransformation.b4 = 0.0; 364| 0| obj->mRootNode->mTransformation.c4 = 0.0; 365| 0| } 366| 555| } 367| 11.0k| } 368| | 369| | //Setup the pivot node (also the animation node), the one we received 370| 11.0k| nd->mName = std::string("Pivot:") + nd->mName.data; 371| 11.0k| ndAnim = nd; 372| | 373| | //Add the attachment node to it 374| 11.0k| nd->mNumChildren = 1; 375| 11.0k| nd->mChildren = new aiNode *[1]; 376| 11.0k| nd->mChildren[0] = new aiNode(); 377| 11.0k| nd->mChildren[0]->mParent = nd; 378| 11.0k| nd->mChildren[0]->mTransformation.a4 = -src.pivotPos.x; 379| 11.0k| nd->mChildren[0]->mTransformation.b4 = -src.pivotPos.y; 380| 11.0k| nd->mChildren[0]->mTransformation.c4 = -src.pivotPos.z; 381| 11.0k| SetupNodeName(nd->mChildren[0], src); 382| | 383| | //Update the attachment node 384| 11.0k| nd = nd->mChildren[0]; 385| | 386| | //Push attachment, if the object came from an external file 387| 11.0k| if (obj) { ------------------ | Branch (387:13): [True: 555, False: 10.4k] ------------------ 388| 555| attach.emplace_back(obj, nd); 389| 555| } 390| 11.0k| } 391| | 392| | // If object is a light source - setup a corresponding ai structure 393| 14| else if (src.type == LWS::NodeDesc::LIGHT) { ------------------ | Branch (393:14): [True: 6, False: 8] ------------------ 394| 6| aiLight *lit = *lightOut++ = new aiLight(); 395| | 396| | // compute final light color 397| 6| lit->mColorDiffuse = lit->mColorSpecular = src.lightColor * src.lightIntensity; 398| | 399| | // name to attach light to node -> unique due to LWs indexing system 400| 6| lit->mName = nd->mName; 401| | 402| | // determine light type and setup additional members 403| 6| if (src.lightType == 2) { /* spot light */ ------------------ | Branch (403:13): [True: 0, False: 6] ------------------ 404| | 405| 0| lit->mType = aiLightSource_SPOT; 406| 0| lit->mAngleInnerCone = (float)AI_DEG_TO_RAD(src.lightConeAngle); 407| 0| lit->mAngleOuterCone = lit->mAngleInnerCone + (float)AI_DEG_TO_RAD(src.lightEdgeAngle); 408| | 409| 6| } else if (src.lightType == 1) { /* directional light source */ ------------------ | Branch (409:20): [True: 0, False: 6] ------------------ 410| 0| lit->mType = aiLightSource_DIRECTIONAL; 411| 6| } else { 412| 6| lit->mType = aiLightSource_POINT; 413| 6| } 414| | 415| | // fixme: no proper handling of light falloffs yet 416| 6| if (src.lightFalloffType == 1) { ------------------ | Branch (416:13): [True: 0, False: 6] ------------------ 417| 0| lit->mAttenuationConstant = 1.f; 418| 6| } else if (src.lightFalloffType == 2) { ------------------ | Branch (418:20): [True: 0, False: 6] ------------------ 419| 0| lit->mAttenuationLinear = 1.f; 420| 6| } else { 421| 6| lit->mAttenuationQuadratic = 1.f; 422| 6| } 423| 8| } else if (src.type == LWS::NodeDesc::CAMERA) { // If object is a camera - setup a corresponding ai structure ------------------ | Branch (423:16): [True: 8, False: 0] ------------------ 424| 8| aiCamera *cam = *camOut++ = new aiCamera(); 425| | 426| | // name to attach cam to node -> unique due to LWs indexing system 427| 8| cam->mName = nd->mName; 428| 8| } 429| | 430| | // Get the node transformation from the LWO key 431| 11.0k| LWO::AnimResolver resolver(src.channels, fps); 432| 11.0k| resolver.ExtractBindPose(ndAnim->mTransformation); 433| | 434| | // .. and construct animation channels 435| 11.0k| aiNodeAnim *anim = nullptr; 436| | 437| 11.0k| if (first != last) { ------------------ | Branch (437:9): [True: 11.0k, False: 0] ------------------ 438| 11.0k| resolver.SetAnimationRange(first, last); 439| 11.0k| resolver.ExtractAnimChannel(&anim, AI_LWO_ANIM_FLAG_SAMPLE_ANIMS | AI_LWO_ANIM_FLAG_START_AT_ZERO); ------------------ | | 177| 11.0k|#define AI_LWO_ANIM_FLAG_SAMPLE_ANIMS 0x1 ------------------ resolver.ExtractAnimChannel(&anim, AI_LWO_ANIM_FLAG_SAMPLE_ANIMS | AI_LWO_ANIM_FLAG_START_AT_ZERO); ------------------ | | 183| 11.0k|#define AI_LWO_ANIM_FLAG_START_AT_ZERO 0x2 ------------------ 440| 11.0k| if (anim) { ------------------ | Branch (440:13): [True: 279, False: 10.7k] ------------------ 441| 279| anim->mNodeName = ndAnim->mName; 442| 279| animOut.push_back(anim); 443| 279| } 444| 11.0k| } 445| | 446| | // Add children 447| 11.0k| if (!src.children.empty()) { ------------------ | Branch (447:9): [True: 9, False: 11.0k] ------------------ 448| 9| nd->mChildren = new aiNode *[src.children.size()]; 449| 20| for (std::list::iterator it = src.children.begin(); it != src.children.end(); ++it) { ------------------ | Branch (449:78): [True: 11, False: 9] ------------------ 450| 11| aiNode *ndd = nd->mChildren[nd->mNumChildren++] = new aiNode(); 451| 11| ndd->mParent = nd; 452| | 453| 11| BuildGraph(ndd, **it, attach, batch, camOut, lightOut, animOut); 454| 11| } 455| 9| } 456| 11.0k|} _ZN6Assimp11LWSImporter11FindLWOFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEE: 460| 17.7k|std::string LWSImporter::FindLWOFile(const std::string &in) { 461| | // insert missing directory separator if necessary 462| 17.7k| std::string tmp(in); 463| 17.7k| if (in.length() > 3 && in[1] == ':' && in[2] != '\\' && in[2] != '/') { ------------------ | Branch (463:9): [True: 15.1k, False: 2.56k] | Branch (463:28): [True: 2.29k, False: 12.8k] | Branch (463:44): [True: 2.29k, False: 0] | Branch (463:61): [True: 1, False: 2.29k] ------------------ 464| 1| tmp = in[0] + (std::string(":\\") + in.substr(2)); 465| 1| } 466| | 467| 17.7k| if (io->Exists(tmp)) { ------------------ | Branch (467:9): [True: 5.91k, False: 11.8k] ------------------ 468| 5.91k| return in; 469| 5.91k| } 470| | 471| | // file is not accessible for us ... maybe it's packed by 472| | // LightWave's 'Package Scene' command? 473| | 474| | // Relevant for us are the following two directories: 475| | // \Objects\\<*>.lwo 476| | // \Scenes\\<*>.lws 477| | // where is optional. 478| | 479| 11.8k| std::string test = std::string("..") + (io->getOsSeparator() + tmp); 480| 11.8k| if (io->Exists(test)) { ------------------ | Branch (480:9): [True: 824, False: 11.0k] ------------------ 481| 824| return test; 482| 824| } 483| | 484| 11.0k| test = std::string("..") + (io->getOsSeparator() + test); 485| 11.0k| if (io->Exists(test)) { ------------------ | Branch (485:9): [True: 0, False: 11.0k] ------------------ 486| 0| return test; 487| 0| } 488| | 489| | // return original path, maybe the IOsystem knows better 490| 11.0k| return tmp; 491| 11.0k|} _ZN6Assimp11LWSImporter14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 495| 147|void LWSImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { 496| 147| io = pIOHandler; 497| 147| std::unique_ptr file(pIOHandler->Open(pFile, "rb")); 498| | 499| | // Check whether we can read from the file 500| 147| if (file == nullptr) { ------------------ | Branch (500:9): [True: 0, False: 147] ------------------ 501| 0| throw DeadlyImportError("Failed to open LWS file ", pFile, "."); 502| 0| } 503| | 504| | // Allocate storage and copy the contents of the file to a memory buffer 505| 147| std::vector mBuffer; 506| 147| TextFileToBuffer(file.get(), mBuffer); 507| | 508| | // Parse the file structure 509| 147| LWS::Element root; 510| 147| const char *dummy = &mBuffer[0]; 511| 147| const char *dummyEnd = dummy + mBuffer.size(); 512| 147| root.Parse(dummy, dummyEnd); 513| | 514| | // Construct a Batch-importer to read more files recursively 515| 147| BatchLoader batch(pIOHandler); 516| | 517| | // Construct an array to receive the flat output graph 518| 147| std::list nodes; 519| | 520| 147| unsigned int cur_light = 0, cur_camera = 0, cur_object = 0; 521| 147| unsigned int num_light = 0, num_camera = 0; 522| | 523| | // check magic identifier, 'LWSC' 524| 147| bool motion_file = false; 525| 147| std::list::const_iterator it = root.children.begin(); 526| | 527| 147| if ((*it).tokens[0] == "LWMO") { ------------------ | Branch (527:9): [True: 145, False: 2] ------------------ 528| 145| motion_file = true; 529| 145| } 530| | 531| 147| if ((*it).tokens[0] != "LWSC" && !motion_file) { ------------------ | Branch (531:9): [True: 145, False: 2] | Branch (531:38): [True: 0, False: 145] ------------------ 532| 0| throw DeadlyImportError("LWS: Not a LightWave scene, magic tag LWSC not found"); 533| 0| } 534| | 535| | // get file format version and print to log 536| 147| ++it; 537| | 538| 147| if (it == root.children.end() || (*it).tokens[0].empty()) { ------------------ | Branch (538:9): [True: 0, False: 147] | Branch (538:9): [True: 0, False: 147] | Branch (538:38): [True: 0, False: 147] ------------------ 539| 0| ASSIMP_LOG_ERROR("Invalid LWS file detectedm abort import."); 540| 0| return; 541| 0| } 542| 147| unsigned int version = strtoul10((*it).tokens[0].c_str()); 543| 147| ASSIMP_LOG_INFO("LWS file format version is ", (*it).tokens[0]); 544| 147| first = 0.; 545| 147| last = 60.; 546| 147| fps = 25.; // seems to be a good default frame rate 547| | 548| | // Now read all elements in a very straightforward manner 549| 90.1k| for (; it != root.children.end(); ++it) { ------------------ | Branch (549:12): [True: 90.1k, False: 44] ------------------ 550| 90.1k| const char *c = (*it).tokens[1].c_str(); 551| 90.1k| const char *end = c + (*it).tokens[1].size(); 552| | 553| | // 'FirstFrame': begin of animation slice 554| 90.1k| if ((*it).tokens[0] == "FirstFrame") { ------------------ | Branch (554:13): [True: 0, False: 90.1k] ------------------ 555| | // see SetupProperties() 556| 0| if (150392. != first ) { ------------------ | Branch (556:17): [True: 0, False: 0] ------------------ 557| 0| first = strtoul10(c, &c) - 1.; // we're zero-based 558| 0| } 559| 90.1k| } else if ((*it).tokens[0] == "LastFrame") { // 'LastFrame': end of animation slice ------------------ | Branch (559:20): [True: 0, False: 90.1k] ------------------ 560| | // see SetupProperties() 561| 0| if (150392. != last ) { ------------------ | Branch (561:17): [True: 0, False: 0] ------------------ 562| 0| last = strtoul10(c, &c) - 1.; // we're zero-based 563| 0| } 564| 90.1k| } else if ((*it).tokens[0] == "FramesPerSecond") { // 'FramesPerSecond': frames per second ------------------ | Branch (564:20): [True: 0, False: 90.1k] ------------------ 565| 0| fps = strtoul10(c, &c); 566| 90.1k| } else if ((*it).tokens[0] == "LoadObjectLayer") { // 'LoadObjectLayer': load a layer of a specific LWO file ------------------ | Branch (566:20): [True: 5.06k, False: 85.0k] ------------------ 567| | 568| | // get layer index 569| 5.06k| const int layer = strtoul10(c, &c); 570| | 571| | // setup the layer to be loaded 572| 5.06k| BatchLoader::PropertyMap props; 573| 5.06k| SetGenericProperty(props.ints, AI_CONFIG_IMPORT_LWO_ONE_LAYER_ONLY, layer); 574| | 575| | // add node to list 576| 5.06k| LWS::NodeDesc d; 577| 5.06k| d.type = LWS::NodeDesc::OBJECT; 578| 5.06k| if (version >= 4) { // handle LWSC 4 explicit ID ------------------ | Branch (578:17): [True: 0, False: 5.06k] ------------------ 579| 0| SkipSpaces(&c, end); 580| 0| d.number = strtoul16(c, &c) & AI_LWS_MASK; ------------------ | | 82| 0|#define AI_LWS_MASK (0xffffffff >> 4u) ------------------ 581| 5.06k| } else { 582| 5.06k| d.number = cur_object++; 583| 5.06k| } 584| | 585| | // and add the file to the import list 586| 5.06k| SkipSpaces(&c, end); 587| 5.06k| std::string path = FindLWOFile(c); 588| | 589| 5.06k| if (path.empty()) { ------------------ | Branch (589:17): [True: 0, False: 5.06k] ------------------ 590| 0| throw DeadlyImportError("LWS: Invalid LoadObjectLayer: empty path."); 591| 0| } 592| | 593| 5.06k| if (path == pFile) { ------------------ | Branch (593:17): [True: 43, False: 5.01k] ------------------ 594| 43| throw DeadlyImportError("LWS: Invalid LoadObjectLayer: self reference."); 595| 43| } 596| | 597| 5.01k| d.path = path; 598| 5.01k| d.id = batch.AddLoadRequest(path, 0, &props); 599| | 600| 5.01k| nodes.push_back(d); 601| 85.0k| } else if ((*it).tokens[0] == "LoadObject") { // 'LoadObject': load a LWO file into the scene-graph ------------------ | Branch (601:20): [True: 12.6k, False: 72.4k] ------------------ 602| | 603| | // add node to list 604| 12.6k| LWS::NodeDesc d; 605| 12.6k| d.type = LWS::NodeDesc::OBJECT; 606| | 607| 12.6k| if (version >= 4) { // handle LWSC 4 explicit ID ------------------ | Branch (607:17): [True: 3, False: 12.6k] ------------------ 608| 3| d.number = strtoul16(c, &c) & AI_LWS_MASK; ------------------ | | 82| 3|#define AI_LWS_MASK (0xffffffff >> 4u) ------------------ 609| 3| SkipSpaces(&c, end); 610| 12.6k| } else { 611| 12.6k| d.number = cur_object++; 612| 12.6k| } 613| 12.6k| std::string path = FindLWOFile(c); 614| | 615| 12.6k| if (path.empty()) { ------------------ | Branch (615:17): [True: 0, False: 12.6k] ------------------ 616| 0| throw DeadlyImportError("LWS: Invalid LoadObject: empty path."); 617| 0| } 618| | 619| 12.6k| if (path == pFile) { ------------------ | Branch (619:17): [True: 60, False: 12.6k] ------------------ 620| 60| throw DeadlyImportError("LWS: Invalid LoadObject: self reference."); 621| 60| } 622| | 623| 12.6k| d.id = batch.AddLoadRequest(path, 0, nullptr); 624| | 625| 12.6k| d.path = path; 626| 12.6k| nodes.push_back(d); 627| 72.4k| } else if ((*it).tokens[0] == "AddNullObject") { // 'AddNullObject': add a dummy node to the hierarchy ------------------ | Branch (627:20): [True: 0, False: 72.4k] ------------------ 628| | 629| | // add node to list 630| 0| LWS::NodeDesc d; 631| 0| d.type = LWS::NodeDesc::OBJECT; 632| 0| if (version >= 4) { // handle LWSC 4 explicit ID ------------------ | Branch (632:17): [True: 0, False: 0] ------------------ 633| 0| d.number = strtoul16(c, &c) & AI_LWS_MASK; ------------------ | | 82| 0|#define AI_LWS_MASK (0xffffffff >> 4u) ------------------ 634| 0| SkipSpaces(&c, end); 635| 0| } else { 636| 0| d.number = cur_object++; 637| 0| } 638| 0| d.name = c; 639| 0| nodes.push_back(d); 640| 0| } 641| | // 'NumChannels': Number of envelope channels assigned to last layer 642| 72.4k| else if ((*it).tokens[0] == "NumChannels") { ------------------ | Branch (642:18): [True: 0, False: 72.4k] ------------------ 643| | // ignore for now 644| 0| } 645| | // 'Channel': preceedes any envelope description 646| 72.4k| else if ((*it).tokens[0] == "Channel") { ------------------ | Branch (646:18): [True: 162, False: 72.2k] ------------------ 647| 162| if (nodes.empty()) { ------------------ | Branch (647:17): [True: 22, False: 140] ------------------ 648| 22| if (motion_file) { ------------------ | Branch (648:21): [True: 22, False: 0] ------------------ 649| | 650| | // LightWave motion file. Add dummy node 651| 22| LWS::NodeDesc d; 652| 22| d.type = LWS::NodeDesc::OBJECT; 653| 22| d.name = c; 654| 22| d.number = cur_object++; 655| 22| nodes.push_back(d); 656| 22| } 657| 22| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'Channel\'"); 658| 140| } else { 659| | // important: index of channel 660| 140| nodes.back().channels.emplace_back(); 661| 140| LWO::Envelope &env = nodes.back().channels.back(); 662| | 663| 140| env.index = strtoul10(c); 664| | 665| | // currently we can just interpret the standard channels 0...9 666| | // (hack) assume that index-i yields the binary channel type from LWO 667| 140| env.type = (LWO::EnvelopeType)(env.index + 1); 668| 140| } 669| 162| } 670| | // 'Envelope': a single animation channel 671| 72.2k| else if ((*it).tokens[0] == "Envelope") { ------------------ | Branch (671:18): [True: 0, False: 72.2k] ------------------ 672| 0| if (nodes.empty() || nodes.back().channels.empty()) ------------------ | Branch (672:17): [True: 0, False: 0] | Branch (672:34): [True: 0, False: 0] ------------------ 673| 0| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'Envelope\'"); 674| 0| else { 675| 0| ReadEnvelope((*it), nodes.back().channels.back()); 676| 0| } 677| 0| } 678| | // 'ObjectMotion': animation information for older lightwave formats 679| 72.2k| else if (version < 3 && ((*it).tokens[0] == "ObjectMotion" || ------------------ | Branch (679:18): [True: 72.2k, False: 7] | Branch (679:34): [True: 604, False: 71.6k] ------------------ 680| 71.6k| (*it).tokens[0] == "CameraMotion" || ------------------ | Branch (680:41): [True: 0, False: 71.6k] ------------------ 681| 71.6k| (*it).tokens[0] == "LightMotion")) { ------------------ | Branch (681:41): [True: 0, False: 71.6k] ------------------ 682| | 683| 604| if (nodes.empty()) ------------------ | Branch (683:17): [True: 3, False: 601] ------------------ 684| 604| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'Motion\'"); 685| 601| else { 686| 601| ReadEnvelope_Old(it, root.children.end(), nodes.back(), version); 687| 601| } 688| 604| } 689| | // 'Pre/PostBehavior': pre/post animation behaviour for LWSC 2 690| 71.6k| else if (version == 2 && (*it).tokens[0] == "Pre/PostBehavior") { ------------------ | Branch (690:18): [True: 23.0k, False: 48.5k] | Branch (690:34): [True: 203, False: 22.8k] ------------------ 691| 203| if (nodes.empty()) ------------------ | Branch (691:17): [True: 28, False: 175] ------------------ 692| 203| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'Pre/PostBehavior'"); 693| 175| else { 694| 1.38k| for (std::list::iterator envelopeIt = nodes.back().channels.begin(); envelopeIt != nodes.back().channels.end(); ++envelopeIt) { ------------------ | Branch (694:101): [True: 1.21k, False: 175] ------------------ 695| | // two ints per envelope 696| 1.21k| LWO::Envelope &env = *envelopeIt; 697| 1.21k| env.pre = (LWO::PrePostBehaviour)strtoul10(c, &c); 698| 1.21k| SkipSpaces(&c, end); 699| 1.21k| env.post = (LWO::PrePostBehaviour)strtoul10(c, &c); 700| 1.21k| SkipSpaces(&c, end); 701| 1.21k| } 702| 175| } 703| 203| } 704| | // 'ParentItem': specifies the parent of the current element 705| 71.4k| else if ((*it).tokens[0] == "ParentItem") { ------------------ | Branch (705:18): [True: 0, False: 71.4k] ------------------ 706| 0| if (nodes.empty()) { ------------------ | Branch (706:17): [True: 0, False: 0] ------------------ 707| 0| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'ParentItem\'"); 708| 0| } else { 709| 0| nodes.back().parent = strtoul16(c, &c); 710| 0| } 711| 0| } 712| | // 'ParentObject': deprecated one for older formats 713| 71.4k| else if (version < 3 && (*it).tokens[0] == "ParentObject") { ------------------ | Branch (713:18): [True: 71.4k, False: 7] | Branch (713:33): [True: 27, False: 71.4k] ------------------ 714| 27| if (nodes.empty()) { ------------------ | Branch (714:17): [True: 0, False: 27] ------------------ 715| 0| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'ParentObject\'"); 716| 27| } else { 717| 27| nodes.back().parent = strtoul10(c, &c) | (1u << 28u); 718| 27| } 719| 27| } 720| | // 'AddCamera': add a camera to the scenegraph 721| 71.4k| else if ((*it).tokens[0] == "AddCamera") { ------------------ | Branch (721:18): [True: 20, False: 71.3k] ------------------ 722| | 723| | // add node to list 724| 20| LWS::NodeDesc d; 725| 20| d.type = LWS::NodeDesc::CAMERA; 726| | 727| 20| if (version >= 4) { // handle LWSC 4 explicit ID ------------------ | Branch (727:17): [True: 0, False: 20] ------------------ 728| 0| d.number = strtoul16(c, &c) & AI_LWS_MASK; ------------------ | | 82| 0|#define AI_LWS_MASK (0xffffffff >> 4u) ------------------ 729| 20| } else { 730| 20| d.number = cur_camera++; 731| 20| } 732| 20| nodes.push_back(d); 733| | 734| 20| num_camera++; 735| 20| } 736| | // 'CameraName': set name of currently active camera 737| 71.3k| else if ((*it).tokens[0] == "CameraName") { ------------------ | Branch (737:18): [True: 0, False: 71.3k] ------------------ 738| 0| if (nodes.empty() || nodes.back().type != LWS::NodeDesc::CAMERA) { ------------------ | Branch (738:17): [True: 0, False: 0] | Branch (738:34): [True: 0, False: 0] ------------------ 739| 0| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'CameraName\'"); 740| 0| } else { 741| 0| nodes.back().name = c; 742| 0| } 743| 0| } 744| | // 'AddLight': add a light to the scenegraph 745| 71.3k| else if ((*it).tokens[0] == "AddLight") { ------------------ | Branch (745:18): [True: 19, False: 71.3k] ------------------ 746| | 747| | // add node to list 748| 19| LWS::NodeDesc d; 749| 19| d.type = LWS::NodeDesc::LIGHT; 750| | 751| 19| if (version >= 4) { // handle LWSC 4 explicit ID ------------------ | Branch (751:17): [True: 0, False: 19] ------------------ 752| 0| d.number = strtoul16(c, &c) & AI_LWS_MASK; ------------------ | | 82| 0|#define AI_LWS_MASK (0xffffffff >> 4u) ------------------ 753| 19| } else { 754| 19| d.number = cur_light++; 755| 19| } 756| 19| nodes.push_back(d); 757| | 758| 19| num_light++; 759| 19| } 760| | // 'LightName': set name of currently active light 761| 71.3k| else if ((*it).tokens[0] == "LightName") { ------------------ | Branch (761:18): [True: 0, False: 71.3k] ------------------ 762| 0| if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) { ------------------ | Branch (762:17): [True: 0, False: 0] | Branch (762:34): [True: 0, False: 0] ------------------ 763| 0| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightName\'"); 764| 0| } else { 765| 0| nodes.back().name = c; 766| 0| } 767| 0| } 768| | // 'LightIntensity': set intensity of currently active light 769| 71.3k| else if ((*it).tokens[0] == "LightIntensity" || (*it).tokens[0] == "LgtIntensity") { ------------------ | Branch (769:18): [True: 0, False: 71.3k] | Branch (769:57): [True: 0, False: 71.3k] ------------------ 770| 0| if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) { ------------------ | Branch (770:17): [True: 0, False: 0] | Branch (770:34): [True: 0, False: 0] ------------------ 771| 0| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightIntensity\'"); 772| 0| } else { 773| 0| const std::string env = "(envelope)"; 774| 0| if (0 == strncmp(c, env.c_str(), env.size())) { ------------------ | Branch (774:21): [True: 0, False: 0] ------------------ 775| 0| ASSIMP_LOG_ERROR("LWS: envelopes for LightIntensity not supported, set to 1.0"); 776| 0| nodes.back().lightIntensity = (ai_real)1.0; 777| 0| } else { 778| 0| fast_atoreal_move(c, nodes.back().lightIntensity); 779| 0| } 780| 0| } 781| 0| } 782| | // 'LightType': set type of currently active light 783| 71.3k| else if ((*it).tokens[0] == "LightType") { ------------------ | Branch (783:18): [True: 0, False: 71.3k] ------------------ 784| 0| if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) { ------------------ | Branch (784:17): [True: 0, False: 0] | Branch (784:34): [True: 0, False: 0] ------------------ 785| 0| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightType\'"); 786| 0| } else { 787| 0| nodes.back().lightType = strtoul10(c); 788| 0| } 789| 0| } 790| | // 'LightFalloffType': set falloff type of currently active light 791| 71.3k| else if ((*it).tokens[0] == "LightFalloffType") { ------------------ | Branch (791:18): [True: 0, False: 71.3k] ------------------ 792| 0| if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) { ------------------ | Branch (792:17): [True: 0, False: 0] | Branch (792:34): [True: 0, False: 0] ------------------ 793| 0| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightFalloffType\'"); 794| 0| } else { 795| 0| nodes.back().lightFalloffType = strtoul10(c); 796| 0| } 797| 0| } 798| | // 'LightConeAngle': set cone angle of currently active light 799| 71.3k| else if ((*it).tokens[0] == "LightConeAngle") { ------------------ | Branch (799:18): [True: 0, False: 71.3k] ------------------ 800| 0| if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) { ------------------ | Branch (800:17): [True: 0, False: 0] | Branch (800:34): [True: 0, False: 0] ------------------ 801| 0| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightConeAngle\'"); 802| 0| } else { 803| 0| nodes.back().lightConeAngle = fast_atof(c); 804| 0| } 805| 0| } 806| | // 'LightEdgeAngle': set area where we're smoothing from min to max intensity 807| 71.3k| else if ((*it).tokens[0] == "LightEdgeAngle") { ------------------ | Branch (807:18): [True: 0, False: 71.3k] ------------------ 808| 0| if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) { ------------------ | Branch (808:17): [True: 0, False: 0] | Branch (808:34): [True: 0, False: 0] ------------------ 809| 0| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightEdgeAngle\'"); 810| 0| } else { 811| 0| nodes.back().lightEdgeAngle = fast_atof(c); 812| 0| } 813| 0| } 814| | // 'LightColor': set color of currently active light 815| 71.3k| else if ((*it).tokens[0] == "LightColor") { ------------------ | Branch (815:18): [True: 0, False: 71.3k] ------------------ 816| 0| if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) { ------------------ | Branch (816:17): [True: 0, False: 0] | Branch (816:34): [True: 0, False: 0] ------------------ 817| 0| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightColor\'"); 818| 0| } else { 819| 0| c = fast_atoreal_move(c, nodes.back().lightColor.r); 820| 0| SkipSpaces(&c, end); 821| 0| c = fast_atoreal_move(c, nodes.back().lightColor.g); 822| 0| SkipSpaces(&c, end); 823| 0| c = fast_atoreal_move(c, nodes.back().lightColor.b); 824| 0| } 825| 0| } 826| | 827| | // 'PivotPosition': position of local transformation origin 828| 71.3k| else if ((*it).tokens[0] == "PivotPosition" || (*it).tokens[0] == "PivotPoint") { ------------------ | Branch (828:18): [True: 0, False: 71.3k] | Branch (828:56): [True: 0, False: 71.3k] ------------------ 829| 0| if (nodes.empty()) { ------------------ | Branch (829:17): [True: 0, False: 0] ------------------ 830| 0| ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'PivotPosition\'"); 831| 0| } else { 832| 0| c = fast_atoreal_move(c, nodes.back().pivotPos.x); 833| 0| SkipSpaces(&c, end); 834| 0| c = fast_atoreal_move(c, nodes.back().pivotPos.y); 835| 0| SkipSpaces(&c, end); 836| 0| c = fast_atoreal_move(c, nodes.back().pivotPos.z); 837| | // Mark pivotPos as set 838| 0| nodes.back().isPivotSet = true; 839| 0| } 840| 0| } 841| 90.1k| } 842| | 843| | // resolve parenting 844| 11.0k| for (std::list::iterator ndIt = nodes.begin(); ndIt != nodes.end(); ++ndIt) { ------------------ | Branch (844:67): [True: 11.0k, False: 44] ------------------ 845| | // check whether there is another node which calls us a parent 846| 14.1M| for (std::list::iterator dit = nodes.begin(); dit != nodes.end(); ++dit) { ------------------ | Branch (846:70): [True: 14.1M, False: 11.0k] ------------------ 847| 14.1M| if (dit != ndIt && *ndIt == (*dit).parent) { ------------------ | Branch (847:17): [True: 14.1M, False: 11.0k] | Branch (847:32): [True: 15, False: 14.1M] ------------------ 848| 15| if ((*dit).parent_resolved) { ------------------ | Branch (848:21): [True: 0, False: 15] ------------------ 849| | // fixme: it's still possible to produce an overflow due to cross references .. 850| 0| ASSIMP_LOG_ERROR("LWS: Found cross reference in scene-graph"); 851| 0| continue; 852| 0| } 853| | 854| 15| ndIt->children.push_back(&*dit); 855| 15| (*dit).parent_resolved = &*ndIt; 856| 15| } 857| 14.1M| } 858| 11.0k| } 859| | 860| | // find out how many nodes have no parent yet 861| 44| unsigned int no_parent = 0; 862| 11.0k| for (std::list::iterator ndIt = nodes.begin(); ndIt != nodes.end(); ++ndIt) { ------------------ | Branch (862:67): [True: 11.0k, False: 44] ------------------ 863| 11.0k| if (!ndIt->parent_resolved) { ------------------ | Branch (863:13): [True: 11.0k, False: 15] ------------------ 864| 11.0k| ++no_parent; 865| 11.0k| } 866| 11.0k| } 867| 44| if (!no_parent) { ------------------ | Branch (867:9): [True: 2, False: 42] ------------------ 868| 2| throw DeadlyImportError("LWS: Unable to find scene root node"); 869| 2| } 870| | 871| | // Load all subsequent files 872| 42| batch.LoadAll(); 873| | 874| | // and build the final output graph by attaching the loaded external 875| | // files to ourselves. first build a master graph 876| 42| aiScene *master = new aiScene(); 877| 42| aiNode *nd = master->mRootNode = new aiNode(); 878| | 879| | // allocate storage for cameras&lights 880| 42| if (num_camera > 0u) { ------------------ | Branch (880:9): [True: 2, False: 40] ------------------ 881| 2| master->mCameras = new aiCamera *[master->mNumCameras = num_camera]; 882| 2| } 883| 42| aiCamera **cams = master->mCameras; 884| 42| if (num_light) { ------------------ | Branch (884:9): [True: 3, False: 39] ------------------ 885| 3| master->mLights = new aiLight *[master->mNumLights = num_light]; 886| 3| } 887| 42| aiLight **lights = master->mLights; 888| | 889| 42| std::vector attach; 890| 42| std::vector anims; 891| | 892| 42| nd->mName.Set(""); 893| 42| nd->mChildren = new aiNode *[no_parent]; 894| 11.0k| for (std::list::iterator ndIt = nodes.begin(); ndIt != nodes.end(); ++ndIt) { ------------------ | Branch (894:67): [True: 11.0k, False: 42] ------------------ 895| 11.0k| if (!ndIt->parent_resolved) { ------------------ | Branch (895:13): [True: 11.0k, False: 15] ------------------ 896| 11.0k| aiNode *ro = nd->mChildren[nd->mNumChildren++] = new aiNode(); 897| 11.0k| ro->mParent = nd; 898| | 899| | // ... and build the scene graph. If we encounter object nodes, 900| | // add then to our attachment table. 901| 11.0k| BuildGraph(ro, *ndIt, attach, batch, cams, lights, anims); 902| 11.0k| } 903| 11.0k| } 904| | 905| | // create a master animation channel for us 906| 42| if (anims.size()) { ------------------ | Branch (906:9): [True: 7, False: 35] ------------------ 907| 7| master->mAnimations = new aiAnimation *[master->mNumAnimations = 1]; 908| 7| aiAnimation *anim = master->mAnimations[0] = new aiAnimation(); 909| 7| anim->mName.Set("LWSMasterAnim"); 910| | 911| | // LWS uses seconds as time units, but we convert to frames 912| 7| anim->mTicksPerSecond = fps; 913| 7| anim->mDuration = last - (first - 1); /* fixme ... zero or one-based?*/ 914| | 915| 7| anim->mChannels = new aiNodeAnim *[anim->mNumChannels = static_cast(anims.size())]; 916| 7| std::copy(anims.begin(), anims.end(), anim->mChannels); 917| 7| } 918| | 919| | // convert the master scene to RH 920| 42| MakeLeftHandedProcess monster_cheat; 921| 42| monster_cheat.Execute(master); 922| | 923| | // .. ccw 924| 42| FlipWindingOrderProcess flipper; 925| 42| flipper.Execute(master); 926| | 927| | // OK ... finally build the output graph 928| 42| SceneCombiner::MergeScenes(&pScene, master, attach, 929| 42| AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES | (!configSpeedFlag ? ( ------------------ | Branch (929:52): [True: 42, False: 0] ------------------ 930| 42| AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY | AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES) : 931| 42| 0)); 932| | 933| | // Check flags 934| 42| if (!pScene->mNumMeshes || !pScene->mNumMaterials) { ------------------ | Branch (934:9): [True: 37, False: 5] | Branch (934:32): [True: 0, False: 5] ------------------ 935| 37| pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; 936| | 937| 37| if (pScene->mNumAnimations && !noSkeletonMesh) { ------------------ | Branch (937:13): [True: 7, False: 30] | Branch (937:39): [True: 7, False: 0] ------------------ 938| | // construct skeleton mesh 939| 7| SkeletonMeshBuilder builder(pScene); 940| 7| } 941| 37| } 942| 42|} _ZN6Assimp3LWS8NodeDescC2Ev: 91| 17.8k| number(0), 92| 17.8k| parent(0), 93| | name(), 94| 17.8k| isPivotSet(false), 95| 17.8k| lightColor(1.f, 1.f, 1.f), 96| 17.8k| lightIntensity(1.f), 97| 17.8k| lightType(0), 98| 17.8k| lightFalloffType(0), 99| 17.8k| lightConeAngle(45.f), 100| | lightEdgeAngle(), 101| 17.8k| parent_resolved(nullptr) {} _ZNK6Assimp3LWS8NodeDesceqEj: 156| 14.1M| bool operator==(unsigned int num) const { 157| 14.1M| if (!num) ------------------ | Branch (157:13): [True: 14.1M, False: 116] ------------------ 158| 14.1M| return false; 159| 116| unsigned int _type = num >> 28u; 160| | 161| 116| return _type == static_cast(type) && (num & AI_LWS_MASK) == number; ------------------ | | 82| 116|#define AI_LWS_MASK (0xffffffff >> 4u) ------------------ | Branch (161:16): [True: 116, False: 0] | Branch (161:60): [True: 15, False: 101] ------------------ 162| 14.1M| } _ZN6Assimp3LWS7ElementC2Ev: 72| 157k| Element() = default; _ZN6Assimp3MD217LookupNormalIndexEhR10aiVector3tIfE: 81| 12.6k|{ 82| | // make sure the normal index has a valid value 83| 12.6k| if (iNormalIndex >= ARRAYSIZE(g_avNormals)) { ------------------ | | 62| 12.6k|# define ARRAYSIZE(_array) (int(sizeof(_array) / sizeof(_array[0]))) ------------------ | Branch (83:9): [True: 835, False: 11.8k] ------------------ 84| 835| ASSIMP_LOG_WARN("Index overflow in Quake II normal vector list"); 85| 835| iNormalIndex = ARRAYSIZE(g_avNormals) - 1; ------------------ | | 62| 835|# define ARRAYSIZE(_array) (int(sizeof(_array) / sizeof(_array[0]))) ------------------ 86| 835| } 87| 12.6k| vOut = *((const aiVector3D*)(&g_avNormals[iNormalIndex])); 88| 12.6k|} _ZN6Assimp11MD2ImporterC2Ev: 98| 624|{} _ZNK6Assimp11MD2Importer7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 103| 469|{ 104| 469| static constexpr uint32_t tokens[] = { AI_MD2_MAGIC_NUMBER_LE }; ------------------ | | 59| 469|#define AI_MD2_MAGIC_NUMBER_LE AI_MAKE_MAGIC("2PDI") ------------------ 105| | return CheckMagicToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens)); 106| 469|} _ZNK6Assimp11MD2Importer7GetInfoEv: 111| 636|{ 112| 636| return &desc; 113| 636|} _ZN6Assimp11MD2Importer15SetupPropertiesEPKNS_8ImporterE: 118| 2|{ 119| | // The 120| | // AI_CONFIG_IMPORT_MD2_KEYFRAME option overrides the 121| | // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option. 122| 2| configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD2_KEYFRAME,-1); 123| 2| if(static_cast(-1) == configFrameID){ ------------------ | Branch (123:8): [True: 2, False: 0] ------------------ 124| | configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME,0); 125| 2| } 126| 2|} _ZN6Assimp11MD2Importer14ValidateHeaderEv: 130| 2|{ 131| | // check magic number 132| 2| if (m_pcHeader->magic != AI_MD2_MAGIC_NUMBER_BE && ------------------ | | 58| 2|#define AI_MD2_MAGIC_NUMBER_BE AI_MAKE_MAGIC("IDP2") ------------------ | Branch (132:9): [True: 2, False: 0] ------------------ 133| 2| m_pcHeader->magic != AI_MD2_MAGIC_NUMBER_LE) ------------------ | | 59| 2|#define AI_MD2_MAGIC_NUMBER_LE AI_MAKE_MAGIC("2PDI") ------------------ | Branch (133:9): [True: 0, False: 2] ------------------ 134| 0| { 135| 0| throw DeadlyImportError("Invalid MD2 magic word: expected IDP2, found ", 136| 0| ai_str_toprintable((char *)&m_pcHeader->magic, 4)); 137| 0| } 138| | 139| | // check file format version 140| 2| if (m_pcHeader->version != 8) ------------------ | Branch (140:9): [True: 0, False: 2] ------------------ 141| 2| ASSIMP_LOG_WARN( "Unsupported MD2 file version. Continuing happily ..."); 142| | 143| | // check some values whether they are valid 144| 2| if (0 == m_pcHeader->numFrames) ------------------ | Branch (144:9): [True: 0, False: 2] ------------------ 145| 0| throw DeadlyImportError( "Invalid MD2 file: NUM_FRAMES is 0"); 146| | 147| 2| if (m_pcHeader->offsetEnd > (uint32_t)fileSize) ------------------ | Branch (147:9): [True: 0, False: 2] ------------------ 148| 0| throw DeadlyImportError( "Invalid MD2 file: File is too small"); 149| | 150| 2| if (m_pcHeader->numSkins > AI_MAX_ALLOC(MD2::Skin)) { ------------------ | Branch (150:9): [True: 0, False: 2] ------------------ 151| 0| throw DeadlyImportError("Invalid MD2 header: Too many skins, would overflow"); 152| 0| } 153| | 154| 2| if (m_pcHeader->numVertices > AI_MAX_ALLOC(MD2::Vertex)) { ------------------ | Branch (154:9): [True: 0, False: 2] ------------------ 155| 0| throw DeadlyImportError("Invalid MD2 header: Too many vertices, would overflow"); 156| 0| } 157| | 158| 2| if (m_pcHeader->numTexCoords > AI_MAX_ALLOC(MD2::TexCoord)) { ------------------ | Branch (158:9): [True: 0, False: 2] ------------------ 159| 0| throw DeadlyImportError("Invalid MD2 header: Too many texcoords, would overflow"); 160| 0| } 161| | 162| 2| if (m_pcHeader->numTriangles > AI_MAX_ALLOC(MD2::Triangle)) { ------------------ | Branch (162:9): [True: 0, False: 2] ------------------ 163| 0| throw DeadlyImportError("Invalid MD2 header: Too many triangles, would overflow"); 164| 0| } 165| | 166| 2| if (m_pcHeader->numFrames > AI_MAX_ALLOC(MD2::Frame)) { ------------------ | Branch (166:9): [True: 0, False: 2] ------------------ 167| 0| throw DeadlyImportError("Invalid MD2 header: Too many frames, would overflow"); 168| 0| } 169| | 170| | // -1 because Frame already contains one 171| 2| unsigned int frameSize = sizeof (MD2::Frame) + (m_pcHeader->numVertices - 1) * sizeof(MD2::Vertex); 172| | 173| 2| if (m_pcHeader->offsetSkins + m_pcHeader->numSkins * sizeof (MD2::Skin) >= fileSize || ------------------ | Branch (173:9): [True: 0, False: 2] ------------------ 174| 2| m_pcHeader->offsetTexCoords + m_pcHeader->numTexCoords * sizeof (MD2::TexCoord) >= fileSize || ------------------ | Branch (174:9): [True: 0, False: 2] ------------------ 175| 2| m_pcHeader->offsetTriangles + m_pcHeader->numTriangles * sizeof (MD2::Triangle) >= fileSize || ------------------ | Branch (175:9): [True: 0, False: 2] ------------------ 176| 2| m_pcHeader->offsetFrames + m_pcHeader->numFrames * frameSize >= fileSize || ------------------ | Branch (176:9): [True: 0, False: 2] ------------------ 177| 2| m_pcHeader->offsetEnd > fileSize) ------------------ | Branch (177:9): [True: 0, False: 2] ------------------ 178| 0| { 179| 0| throw DeadlyImportError("Invalid MD2 header: Some offsets are outside the file"); 180| 0| } 181| | 182| 2| if (m_pcHeader->numSkins > AI_MD2_MAX_SKINS) ------------------ | | 65| 2|#define AI_MD2_MAX_SKINS 32 ------------------ | Branch (182:9): [True: 0, False: 2] ------------------ 183| 2| ASSIMP_LOG_WARN("The model contains more skins than Quake 2 supports"); 184| 2| if ( m_pcHeader->numFrames > AI_MD2_MAX_FRAMES) ------------------ | | 64| 2|#define AI_MD2_MAX_FRAMES 512 ------------------ | Branch (184:10): [True: 0, False: 2] ------------------ 185| 2| ASSIMP_LOG_WARN("The model contains more frames than Quake 2 supports"); 186| 2| if (m_pcHeader->numVertices > AI_MD2_MAX_VERTS) ------------------ | | 66| 2|#define AI_MD2_MAX_VERTS 2048 ------------------ | Branch (186:9): [True: 0, False: 2] ------------------ 187| 2| ASSIMP_LOG_WARN("The model contains more vertices than Quake 2 supports"); 188| | 189| 2| if (m_pcHeader->numFrames <= configFrameID ) ------------------ | Branch (189:9): [True: 0, False: 2] ------------------ 190| 0| throw DeadlyImportError("MD2: The requested frame (", configFrameID, ") does not exist in the file"); 191| 2|} _ZN6Assimp11MD2Importer14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 197| 2|{ 198| 2| std::unique_ptr file( pIOHandler->Open( pFile)); 199| | 200| | // Check whether we can read from the file 201| 2| if (file == nullptr) { ------------------ | Branch (201:9): [True: 0, False: 2] ------------------ 202| 0| throw DeadlyImportError("Failed to open MD2 file ", pFile, ""); 203| 0| } 204| | 205| | // check whether the md3 file is large enough to contain 206| | // at least the file header 207| 2| fileSize = (unsigned int)file->FileSize(); 208| 2| if (fileSize < sizeof(MD2::Header)) { ------------------ | Branch (208:9): [True: 0, False: 2] ------------------ 209| 0| throw DeadlyImportError("MD2 File is too small"); 210| 0| } 211| | 212| 2| std::vector mBuffer2(fileSize); 213| 2| file->Read(&mBuffer2[0], 1, fileSize); 214| 2| mBuffer = &mBuffer2[0]; 215| | 216| 2| m_pcHeader = (BE_NCONST MD2::Header*)mBuffer; 217| | 218| |#ifdef AI_BUILD_BIG_ENDIAN 219| | 220| | ByteSwap::Swap4(&m_pcHeader->frameSize); 221| | ByteSwap::Swap4(&m_pcHeader->magic); 222| | ByteSwap::Swap4(&m_pcHeader->numFrames); 223| | ByteSwap::Swap4(&m_pcHeader->numGlCommands); 224| | ByteSwap::Swap4(&m_pcHeader->numSkins); 225| | ByteSwap::Swap4(&m_pcHeader->numTexCoords); 226| | ByteSwap::Swap4(&m_pcHeader->numTriangles); 227| | ByteSwap::Swap4(&m_pcHeader->numVertices); 228| | ByteSwap::Swap4(&m_pcHeader->offsetEnd); 229| | ByteSwap::Swap4(&m_pcHeader->offsetFrames); 230| | ByteSwap::Swap4(&m_pcHeader->offsetGlCommands); 231| | ByteSwap::Swap4(&m_pcHeader->offsetSkins); 232| | ByteSwap::Swap4(&m_pcHeader->offsetTexCoords); 233| | ByteSwap::Swap4(&m_pcHeader->offsetTriangles); 234| | ByteSwap::Swap4(&m_pcHeader->skinHeight); 235| | ByteSwap::Swap4(&m_pcHeader->skinWidth); 236| | ByteSwap::Swap4(&m_pcHeader->version); 237| | 238| |#endif 239| | 240| 2| ValidateHeader(); 241| | 242| | // there won't be more than one mesh inside the file 243| 2| pScene->mNumMaterials = 1; 244| 2| pScene->mRootNode = new aiNode(); 245| 2| pScene->mRootNode->mNumMeshes = 1; 246| 2| pScene->mRootNode->mMeshes = new unsigned int[1]; 247| 2| pScene->mRootNode->mMeshes[0] = 0; 248| 2| pScene->mMaterials = new aiMaterial*[1]; 249| 2| pScene->mMaterials[0] = new aiMaterial(); 250| 2| pScene->mNumMeshes = 1; 251| 2| pScene->mMeshes = new aiMesh*[1]; 252| | 253| 2| aiMesh* pcMesh = pScene->mMeshes[0] = new aiMesh(); 254| 2| pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; 255| | 256| | // navigate to the begin of the current frame data 257| 2| BE_NCONST MD2::Frame* pcFrame = (BE_NCONST MD2::Frame*) ((uint8_t*) 258| 2| m_pcHeader + m_pcHeader->offsetFrames + (m_pcHeader->frameSize * configFrameID)); 259| | 260| | // navigate to the begin of the triangle data 261| 2| MD2::Triangle* pcTriangles = (MD2::Triangle*) ((uint8_t*) 262| 2| m_pcHeader + m_pcHeader->offsetTriangles); 263| | 264| | // navigate to the begin of the tex coords data 265| 2| BE_NCONST MD2::TexCoord* pcTexCoords = (BE_NCONST MD2::TexCoord*) ((uint8_t*) 266| 2| m_pcHeader + m_pcHeader->offsetTexCoords); 267| | 268| | // navigate to the begin of the vertex data 269| 2| BE_NCONST MD2::Vertex* pcVerts = (BE_NCONST MD2::Vertex*) (pcFrame->vertices); 270| | 271| |#ifdef AI_BUILD_BIG_ENDIAN 272| | for (uint32_t i = 0; i< m_pcHeader->numTriangles; ++i) 273| | { 274| | for (unsigned int p = 0; p < 3;++p) 275| | { 276| | ByteSwap::Swap2(& pcTriangles[i].textureIndices[p]); 277| | ByteSwap::Swap2(& pcTriangles[i].vertexIndices[p]); 278| | } 279| | } 280| | for (uint32_t i = 0; i < m_pcHeader->offsetTexCoords;++i) 281| | { 282| | ByteSwap::Swap2(& pcTexCoords[i].s); 283| | ByteSwap::Swap2(& pcTexCoords[i].t); 284| | } 285| | ByteSwap::Swap4( & pcFrame->scale[0] ); 286| | ByteSwap::Swap4( & pcFrame->scale[1] ); 287| | ByteSwap::Swap4( & pcFrame->scale[2] ); 288| | ByteSwap::Swap4( & pcFrame->translate[0] ); 289| | ByteSwap::Swap4( & pcFrame->translate[1] ); 290| | ByteSwap::Swap4( & pcFrame->translate[2] ); 291| |#endif 292| | 293| 2| pcMesh->mNumFaces = m_pcHeader->numTriangles; 294| 2| pcMesh->mFaces = new aiFace[m_pcHeader->numTriangles]; 295| | 296| | // allocate output storage 297| 2| pcMesh->mNumVertices = (unsigned int)pcMesh->mNumFaces*3; 298| 2| pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices]; 299| 2| pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices]; 300| | 301| | // Not sure whether there are MD2 files without texture coordinates 302| | // NOTE: texture coordinates can be there without a texture, 303| | // but a texture can't be there without a valid UV channel 304| 2| aiMaterial* pcHelper = (aiMaterial*)pScene->mMaterials[0]; 305| 2| const int iMode = (int)aiShadingMode_Gouraud; 306| 2| pcHelper->AddProperty(&iMode, 1, AI_MATKEY_SHADING_MODEL); 307| | 308| 2| if (m_pcHeader->numTexCoords && m_pcHeader->numSkins) ------------------ | Branch (308:9): [True: 2, False: 0] | Branch (308:37): [True: 0, False: 2] ------------------ 309| 0| { 310| | // navigate to the first texture associated with the mesh 311| 0| const MD2::Skin* pcSkins = (const MD2::Skin*) ((unsigned char*)m_pcHeader + 312| 0| m_pcHeader->offsetSkins); 313| | 314| 0| aiColor3D clr; 315| 0| clr.b = clr.g = clr.r = 1.0f; 316| 0| pcHelper->AddProperty(&clr, 1,AI_MATKEY_COLOR_DIFFUSE); 317| 0| pcHelper->AddProperty(&clr, 1,AI_MATKEY_COLOR_SPECULAR); 318| | 319| 0| clr.b = clr.g = clr.r = 0.05f; 320| 0| pcHelper->AddProperty(&clr, 1,AI_MATKEY_COLOR_AMBIENT); 321| | 322| 0| const ai_uint32 MaxNameLength = AI_MAXLEN - 1; // one byte reserved for \0 323| 0| ai_uint32 iLen = static_cast(::strlen(pcSkins->name)); 324| 0| bool nameTooLong = iLen > MaxNameLength; 325| | 326| 0| if (pcSkins->name[0] && !nameTooLong) ------------------ | Branch (326:13): [True: 0, False: 0] | Branch (326:33): [True: 0, False: 0] ------------------ 327| 0| { 328| 0| aiString szString; 329| 0| ::memcpy(szString.data, pcSkins->name, iLen); 330| 0| szString.data[iLen] = '\0'; 331| 0| szString.length = iLen; 332| | 333| 0| pcHelper->AddProperty(&szString,AI_MATKEY_TEXTURE_DIFFUSE(0)); 334| 0| } 335| 0| else if (nameTooLong) { ------------------ | Branch (335:18): [True: 0, False: 0] ------------------ 336| 0| ASSIMP_LOG_WARN("Texture file name is too long. It will be skipped."); 337| 0| } 338| 0| else{ 339| 0| ASSIMP_LOG_WARN("Texture file name has zero length. It will be skipped."); 340| 0| } 341| 0| } 342| 2| else { 343| | // apply a default material 344| 2| aiColor3D clr; 345| 2| clr.b = clr.g = clr.r = 0.6f; 346| 2| pcHelper->AddProperty(&clr, 1,AI_MATKEY_COLOR_DIFFUSE); 347| 2| pcHelper->AddProperty(&clr, 1,AI_MATKEY_COLOR_SPECULAR); 348| | 349| 2| clr.b = clr.g = clr.r = 0.05f; 350| 2| pcHelper->AddProperty(&clr, 1,AI_MATKEY_COLOR_AMBIENT); 351| | 352| 2| aiString szName; 353| 2| szName.Set(AI_DEFAULT_MATERIAL_NAME); 354| 2| pcHelper->AddProperty(&szName,AI_MATKEY_NAME); 355| | 356| 2| aiString sz; 357| | 358| | // TODO: Try to guess the name of the texture file from the model file name 359| | 360| 2| sz.Set("$texture_dummy.bmp"); 361| 2| pcHelper->AddProperty(&sz,AI_MATKEY_TEXTURE_DIFFUSE(0)); 362| 2| } 363| | 364| | 365| | // now read all triangles of the first frame, apply scaling and translation 366| 2| unsigned int iCurrent = 0; 367| | 368| 2| float fDivisorU = 1.0f,fDivisorV = 1.0f; 369| 2| if (m_pcHeader->numTexCoords) { ------------------ | Branch (369:9): [True: 2, False: 0] ------------------ 370| | // allocate storage for texture coordinates, too 371| 2| pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices]; 372| 2| pcMesh->mNumUVComponents[0] = 2; 373| | 374| | // check whether the skin width or height are zero (this would 375| | // cause a division through zero) 376| 2| if (!m_pcHeader->skinWidth) { ------------------ | Branch (376:13): [True: 0, False: 2] ------------------ 377| 0| ASSIMP_LOG_ERROR("MD2: No valid skin width given"); 378| 0| } 379| 2| else fDivisorU = (float)m_pcHeader->skinWidth; 380| 2| if (!m_pcHeader->skinHeight){ ------------------ | Branch (380:13): [True: 0, False: 2] ------------------ 381| 0| ASSIMP_LOG_ERROR("MD2: No valid skin height given"); 382| 0| } 383| 2| else fDivisorV = (float)m_pcHeader->skinHeight; 384| 2| } 385| | 386| 1.33k| for (unsigned int i = 0; i < (unsigned int)m_pcHeader->numTriangles;++i) { ------------------ | Branch (386:30): [True: 1.33k, False: 2] ------------------ 387| | // Allocate the face 388| 1.33k| pScene->mMeshes[0]->mFaces[i].mIndices = new unsigned int[3]; 389| 1.33k| pScene->mMeshes[0]->mFaces[i].mNumIndices = 3; 390| | 391| | // copy texture coordinates 392| | // check whether they are different from the previous value at this index. 393| | // In this case, create a full separate set of vertices/normals/texcoords 394| 5.33k| for (unsigned int c = 0; c < 3;++c,++iCurrent) { ------------------ | Branch (394:34): [True: 3.99k, False: 1.33k] ------------------ 395| | 396| | // validate vertex indices 397| 3.99k| unsigned int iIndex = (unsigned int)pcTriangles[i].vertexIndices[c]; 398| 3.99k| if (iIndex >= m_pcHeader->numVertices) { ------------------ | Branch (398:17): [True: 0, False: 3.99k] ------------------ 399| 0| ASSIMP_LOG_ERROR("MD2: Vertex index is outside the allowed range"); 400| 0| iIndex = m_pcHeader->numVertices-1; 401| 0| } 402| | 403| | // read x,y, and z component of the vertex 404| 3.99k| aiVector3D& vec = pcMesh->mVertices[iCurrent]; 405| | 406| 3.99k| vec.x = (float)pcVerts[iIndex].vertex[0] * pcFrame->scale[0]; 407| 3.99k| vec.x += pcFrame->translate[0]; 408| | 409| 3.99k| vec.y = (float)pcVerts[iIndex].vertex[1] * pcFrame->scale[1]; 410| 3.99k| vec.y += pcFrame->translate[1]; 411| | 412| 3.99k| vec.z = (float)pcVerts[iIndex].vertex[2] * pcFrame->scale[2]; 413| 3.99k| vec.z += pcFrame->translate[2]; 414| | 415| | // read the normal vector from the precalculated normal table 416| 3.99k| aiVector3D& vNormal = pcMesh->mNormals[iCurrent]; 417| 3.99k| LookupNormalIndex(pcVerts[iIndex].lightNormalIndex,vNormal); 418| | 419| 3.99k| if (m_pcHeader->numTexCoords) { ------------------ | Branch (419:17): [True: 3.99k, False: 0] ------------------ 420| | // validate texture coordinates 421| 3.99k| iIndex = pcTriangles[i].textureIndices[c]; 422| 3.99k| if (iIndex >= m_pcHeader->numTexCoords) { ------------------ | Branch (422:21): [True: 0, False: 3.99k] ------------------ 423| 0| ASSIMP_LOG_ERROR("MD2: UV index is outside the allowed range"); 424| 0| iIndex = m_pcHeader->numTexCoords-1; 425| 0| } 426| | 427| 3.99k| aiVector3D& pcOut = pcMesh->mTextureCoords[0][iCurrent]; 428| | 429| | // the texture coordinates are absolute values but we 430| | // need relative values between 0 and 1 431| 3.99k| pcOut.x = pcTexCoords[iIndex].s / fDivisorU; 432| 3.99k| pcOut.y = 1.f-pcTexCoords[iIndex].t / fDivisorV; 433| 3.99k| } 434| 3.99k| pScene->mMeshes[0]->mFaces[i].mIndices[c] = iCurrent; 435| 3.99k| } 436| | // flip the face order 437| 1.33k| std::swap( pScene->mMeshes[0]->mFaces[i].mIndices[0], pScene->mMeshes[0]->mFaces[i].mIndices[2] ); 438| 1.33k| } 439| | // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system 440| 2| pScene->mRootNode->mTransformation = aiMatrix4x4( 441| 2| 1.f, 0.f, 0.f, 0.f, 442| 2| 0.f, 0.f, 1.f, 0.f, 443| 2| 0.f, -1.f, 0.f, 0.f, 444| 2| 0.f, 0.f, 0.f, 1.f); 445| 2|} _ZN6Assimp3MD318LatLngNormalToVec3EtPf: 259| 4.10k|{ 260| 4.10k| ai_real lat = (ai_real)(( p_iNormal >> 8u ) & 0xff); 261| 4.10k| ai_real lng = (ai_real)(( p_iNormal & 0xff )); 262| 4.10k| const ai_real invVal( ai_real( 1.0 ) / ai_real( 128.0 ) ); 263| 4.10k| lat *= ai_real( 3.141926 ) * invVal; 264| 4.10k| lng *= ai_real( 3.141926 ) * invVal; 265| | 266| 4.10k| p_afOut[ 0 ] = std::cos(lat) * std::sin(lng); 267| 4.10k| p_afOut[ 1 ] = std::sin(lat) * std::sin(lng); 268| 4.10k| p_afOut[ 2 ] = std::cos(lng); 269| 4.10k|} _ZN6Assimp11MD3ImporterC2Ev: 344| 624| configFrameID(0), configHandleMP(true), configSpeedFlag(), pcHeader(), mBuffer(), fileSize(), mScene(), mIOHandler() {} _ZN6Assimp11MD3ImporterD2Ev: 348| 624|MD3Importer::~MD3Importer() = default; _ZNK6Assimp11MD3Importer7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 352| 474|bool MD3Importer::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 353| 474| static constexpr uint32_t tokens[] = { AI_MD3_MAGIC_NUMBER_LE }; ------------------ | | 66| 474|#define AI_MD3_MAGIC_NUMBER_LE AI_MAKE_MAGIC("3PDI") ------------------ 354| | return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); 355| 474|} _ZN6Assimp11MD3Importer21ValidateHeaderOffsetsEv: 358| 5|void MD3Importer::ValidateHeaderOffsets() { 359| | // Check magic number 360| 5| if (pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_BE && ------------------ | | 65| 5|#define AI_MD3_MAGIC_NUMBER_BE AI_MAKE_MAGIC("IDP3") ------------------ | Branch (360:9): [True: 0, False: 5] ------------------ 361| 0| pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_LE) ------------------ | | 66| 0|#define AI_MD3_MAGIC_NUMBER_LE AI_MAKE_MAGIC("3PDI") ------------------ | Branch (361:13): [True: 0, False: 0] ------------------ 362| 0| throw DeadlyImportError("Invalid MD3 file: Magic bytes not found"); 363| | 364| | // Check file format version 365| 5| if (pcHeader->VERSION > 15) ------------------ | Branch (365:9): [True: 5, False: 0] ------------------ 366| 5| ASSIMP_LOG_WARN("Unsupported MD3 file version. Continuing happily ..."); 367| | 368| | // Check some offset values whether they are valid 369| 5| if (!pcHeader->NUM_SURFACES) ------------------ | Branch (369:9): [True: 0, False: 5] ------------------ 370| 0| throw DeadlyImportError("Invalid md3 file: NUM_SURFACES is 0"); 371| | 372| 5| if (pcHeader->OFS_FRAMES >= fileSize || pcHeader->OFS_SURFACES >= fileSize || ------------------ | Branch (372:9): [True: 0, False: 5] | Branch (372:45): [True: 0, False: 5] ------------------ 373| 5| pcHeader->OFS_EOF > fileSize) { ------------------ | Branch (373:13): [True: 0, False: 5] ------------------ 374| 0| throw DeadlyImportError("Invalid MD3 header: some offsets are outside the file"); 375| 0| } 376| | 377| 5| if (pcHeader->NUM_SURFACES > AI_MAX_ALLOC(MD3::Surface)) { ------------------ | Branch (377:9): [True: 0, False: 5] ------------------ 378| 0| throw DeadlyImportError("Invalid MD3 header: too many surfaces, would overflow"); 379| 0| } 380| | 381| 5| if (pcHeader->OFS_SURFACES + pcHeader->NUM_SURFACES * sizeof(MD3::Surface) >= fileSize) { ------------------ | Branch (381:9): [True: 0, False: 5] ------------------ 382| 0| throw DeadlyImportError("Invalid MD3 header: some surfaces are outside the file"); 383| 0| } 384| | 385| 5| if (pcHeader->NUM_FRAMES <= configFrameID) ------------------ | Branch (385:9): [True: 0, False: 5] ------------------ 386| 0| throw DeadlyImportError("The requested frame is not existing the file"); 387| 5|} _ZNK6Assimp11MD3Importer7GetInfoEv: 431| 639|const aiImporterDesc *MD3Importer::GetInfo() const { 432| 639| return &desc; 433| 639|} _ZN6Assimp11MD3Importer15SetupPropertiesEPKNS_8ImporterE: 437| 5|void MD3Importer::SetupProperties(const Importer *pImp) { 438| | // The 439| | // AI_CONFIG_IMPORT_MD3_KEYFRAME option overrides the 440| | // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option. 441| 5| configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD3_KEYFRAME, -1); 442| 5| if (static_cast(-1) == configFrameID) { ------------------ | Branch (442:9): [True: 5, False: 0] ------------------ 443| 5| configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0); 444| 5| } 445| | 446| | // AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART 447| 5| configHandleMP = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 1)); 448| | 449| | // AI_CONFIG_IMPORT_MD3_SKIN_NAME 450| 5| configSkinFile = (pImp->GetPropertyString(AI_CONFIG_IMPORT_MD3_SKIN_NAME, "default")); 451| | 452| | // AI_CONFIG_IMPORT_MD3_LOAD_SHADERS 453| 5| configLoadShaders = (pImp->GetPropertyBool(AI_CONFIG_IMPORT_MD3_LOAD_SHADERS, true)); 454| | 455| | // AI_CONFIG_IMPORT_MD3_SHADER_SRC 456| 5| configShaderFile = (pImp->GetPropertyString(AI_CONFIG_IMPORT_MD3_SHADER_SRC, "")); 457| | 458| | // AI_CONFIG_FAVOUR_SPEED 459| | configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 0)); 460| 5|} _ZN6Assimp11MD3Importer17ReadMultipartFileEv: 526| 5|bool MD3Importer::ReadMultipartFile() { 527| | // check whether the file name contains a common postfix, e.g lower_2.md3 528| 5| std::string::size_type s = filename.find_last_of('_'), t = filename.find_last_of('.'); 529| | 530| 5| if (t == std::string::npos) ------------------ | Branch (530:9): [True: 0, False: 5] ------------------ 531| 0| t = filename.size(); 532| 5| if (s == std::string::npos) ------------------ | Branch (532:9): [True: 0, False: 5] ------------------ 533| 0| s = t; 534| | 535| 5| const std::string mod_filename = filename.substr(0, s); 536| 5| const std::string suffix = filename.substr(s, t - s); 537| | 538| 5| if (mod_filename == "lower" || mod_filename == "upper" || mod_filename == "head") { ------------------ | Branch (538:9): [True: 0, False: 5] | Branch (538:36): [True: 0, False: 5] | Branch (538:63): [True: 0, False: 5] ------------------ 539| 0| const std::string lower = path + "lower" + suffix + ".md3"; 540| 0| const std::string upper = path + "upper" + suffix + ".md3"; 541| 0| const std::string head = path + "head" + suffix + ".md3"; 542| | 543| 0| aiScene *scene_upper = nullptr; 544| 0| aiScene *scene_lower = nullptr; 545| 0| aiScene *scene_head = nullptr; 546| 0| std::string failure; 547| | 548| 0| aiNode *tag_torso, *tag_head; 549| 0| std::vector attach; 550| | 551| 0| ASSIMP_LOG_INFO("Multi part MD3 player model: lower, upper and head parts are joined"); 552| | 553| | // ensure we won't try to load ourselves recursively 554| 0| BatchLoader::PropertyMap props; 555| 0| SetGenericProperty(props.ints, AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 0); 556| | 557| | // now read these three files 558| 0| BatchLoader batch(mIOHandler); 559| 0| const unsigned int _lower = batch.AddLoadRequest(lower, 0, &props); 560| 0| const unsigned int _upper = batch.AddLoadRequest(upper, 0, &props); 561| 0| const unsigned int _head = batch.AddLoadRequest(head, 0, &props); 562| 0| batch.LoadAll(); 563| | 564| | // now construct a dummy scene to place these three parts in 565| 0| aiScene *master = new aiScene(); 566| 0| aiNode *nd = master->mRootNode = new aiNode(); 567| 0| nd->mName.Set(""); 568| | 569| | // ... and get them. We need all of them. 570| 0| scene_lower = batch.GetImport(_lower); 571| 0| if (!scene_lower) { ------------------ | Branch (571:13): [True: 0, False: 0] ------------------ 572| 0| ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, lower.md3 fails to load"); 573| 0| failure = "lower"; 574| 0| goto error_cleanup; 575| 0| } 576| | 577| 0| scene_upper = batch.GetImport(_upper); 578| 0| if (!scene_upper) { ------------------ | Branch (578:13): [True: 0, False: 0] ------------------ 579| 0| ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, upper.md3 fails to load"); 580| 0| failure = "upper"; 581| 0| goto error_cleanup; 582| 0| } 583| | 584| 0| scene_head = batch.GetImport(_head); 585| 0| if (!scene_head) { ------------------ | Branch (585:13): [True: 0, False: 0] ------------------ 586| 0| ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, head.md3 fails to load"); 587| 0| failure = "head"; 588| 0| goto error_cleanup; 589| 0| } 590| | 591| | // build attachment infos. search for typical Q3 tags 592| | 593| | // original root 594| 0| scene_lower->mRootNode->mName.Set("lower"); 595| 0| attach.emplace_back(scene_lower, nd); 596| | 597| | // tag_torso 598| 0| tag_torso = scene_lower->mRootNode->FindNode("tag_torso"); 599| 0| if (!tag_torso) { ------------------ | Branch (599:13): [True: 0, False: 0] ------------------ 600| 0| ASSIMP_LOG_ERROR("M3D: Failed to find attachment tag for multi part model: tag_torso expected"); 601| 0| goto error_cleanup; 602| 0| } 603| 0| scene_upper->mRootNode->mName.Set("upper"); 604| 0| attach.emplace_back(scene_upper, tag_torso); 605| | 606| | // tag_head 607| 0| tag_head = scene_upper->mRootNode->FindNode("tag_head"); 608| 0| if (!tag_head) { ------------------ | Branch (608:13): [True: 0, False: 0] ------------------ 609| 0| ASSIMP_LOG_ERROR("M3D: Failed to find attachment tag for multi part model: tag_head expected"); 610| 0| goto error_cleanup; 611| 0| } 612| 0| scene_head->mRootNode->mName.Set("head"); 613| 0| attach.emplace_back(scene_head, tag_head); 614| | 615| | // Remove tag_head and tag_torso from all other model parts ... 616| | // this ensures (together with AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) 617| | // that tag_torso/tag_head is also the name of the (unique) output node 618| 0| RemoveSingleNodeFromList(scene_upper->mRootNode->FindNode("tag_torso")); 619| 0| RemoveSingleNodeFromList(scene_head->mRootNode->FindNode("tag_head")); 620| | 621| | // Undo the rotations which we applied to the coordinate systems. We're 622| | // working in global Quake space here 623| 0| scene_head->mRootNode->mTransformation = aiMatrix4x4(); 624| 0| scene_lower->mRootNode->mTransformation = aiMatrix4x4(); 625| 0| scene_upper->mRootNode->mTransformation = aiMatrix4x4(); 626| | 627| | // and merge the scenes 628| 0| SceneCombiner::MergeScenes(&mScene, master, attach, 629| 0| AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES | 630| 0| AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES | 631| 0| AI_INT_MERGE_SCENE_RESOLVE_CROSS_ATTACHMENTS | 632| 0| (!configSpeedFlag ? AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY : 0)); ------------------ | Branch (632:26): [True: 0, False: 0] ------------------ 633| | 634| | // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system 635| 0| mScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f, 636| 0| 0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f); 637| | 638| 0| return true; 639| | 640| 0| error_cleanup: 641| 0| delete scene_upper; 642| 0| delete scene_lower; 643| 0| delete scene_head; 644| 0| delete master; 645| | 646| 0| if (failure == mod_filename) { ------------------ | Branch (646:13): [True: 0, False: 0] ------------------ 647| 0| throw DeadlyImportError("MD3: failure to read multipart host file"); 648| 0| } 649| 0| } 650| 5| return false; 651| 5|} _ZN6Assimp11MD3Importer14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 693| 5|void MD3Importer::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { 694| 5| mFile = pFile; 695| 5| mScene = pScene; 696| 5| mIOHandler = pIOHandler; 697| | 698| | // get base path and file name 699| | // todo ... move to PathConverter 700| 5| std::string::size_type s = mFile.find_last_of("/\\"); 701| 5| if (s == std::string::npos) { ------------------ | Branch (701:9): [True: 5, False: 0] ------------------ 702| 5| s = 0; 703| 5| } else { 704| 0| ++s; 705| 0| } 706| 5| filename = mFile.substr(s), path = mFile.substr(0, s); 707| 95| for (std::string::iterator it = filename.begin(); it != filename.end(); ++it) { ------------------ | Branch (707:55): [True: 90, False: 5] ------------------ 708| 90| *it = static_cast(tolower(static_cast(*it))); 709| 90| } 710| | 711| | // Load multi-part model file, if necessary 712| 5| if (configHandleMP) { ------------------ | Branch (712:9): [True: 5, False: 0] ------------------ 713| 5| if (ReadMultipartFile()) ------------------ | Branch (713:13): [True: 0, False: 5] ------------------ 714| 0| return; 715| 5| } 716| | 717| 5| std::unique_ptr file(pIOHandler->Open(pFile)); 718| | 719| | // Check whether we can read from the file 720| 5| if (file == nullptr) { ------------------ | Branch (720:9): [True: 0, False: 5] ------------------ 721| 0| throw DeadlyImportError("Failed to open MD3 file ", pFile, "."); 722| 0| } 723| | 724| | // Check whether the md3 file is large enough to contain the header 725| 5| fileSize = (unsigned int)file->FileSize(); 726| 5| if (fileSize < sizeof(MD3::Header)) ------------------ | Branch (726:9): [True: 0, False: 5] ------------------ 727| 0| throw DeadlyImportError("MD3 File is too small."); 728| | 729| | // Allocate storage and copy the contents of the file to a memory buffer 730| 5| std::vector mBuffer2(fileSize); 731| 5| file->Read(&mBuffer2[0], 1, fileSize); 732| 5| mBuffer = &mBuffer2[0]; 733| 5| const unsigned char* bufferEnd = mBuffer + fileSize; 734| | 735| 5| pcHeader = (BE_NCONST MD3::Header *)mBuffer; 736| | 737| | // Ensure correct endianness 738| |#ifdef AI_BUILD_BIG_ENDIAN 739| | 740| | AI_SWAP4(pcHeader->VERSION); 741| | AI_SWAP4(pcHeader->FLAGS); 742| | AI_SWAP4(pcHeader->IDENT); 743| | AI_SWAP4(pcHeader->NUM_FRAMES); 744| | AI_SWAP4(pcHeader->NUM_SKINS); 745| | AI_SWAP4(pcHeader->NUM_SURFACES); 746| | AI_SWAP4(pcHeader->NUM_TAGS); 747| | AI_SWAP4(pcHeader->OFS_EOF); 748| | AI_SWAP4(pcHeader->OFS_FRAMES); 749| | AI_SWAP4(pcHeader->OFS_SURFACES); 750| | AI_SWAP4(pcHeader->OFS_TAGS); 751| | 752| |#endif 753| | 754| | // Validate the file header 755| 5| ValidateHeaderOffsets(); 756| | 757| | // Navigate to the list of surfaces 758| 5| BE_NCONST MD3::Surface *pcSurfaces = (BE_NCONST MD3::Surface *)(mBuffer + pcHeader->OFS_SURFACES); 759| 5| if ((const unsigned char*)pcSurfaces + sizeof(MD3::Surface) * pcHeader->NUM_SURFACES > bufferEnd) { ------------------ | Branch (759:9): [True: 0, False: 5] ------------------ 760| 0| throw DeadlyImportError("MD3 surface headers are outside the file"); 761| 0| } 762| | 763| | // Navigate to the list of tags 764| 5| BE_NCONST MD3::Tag *pcTags = (BE_NCONST MD3::Tag *)(mBuffer + pcHeader->OFS_TAGS); 765| 5| if ((const unsigned char*)pcTags + sizeof(MD3::Tag) * pcHeader->NUM_TAGS > bufferEnd) { ------------------ | Branch (765:9): [True: 5, False: 0] ------------------ 766| 5| throw DeadlyImportError("MD3 tags are outside the file"); 767| 5| } 768| | 769| | // Allocate output storage 770| 0| pScene->mNumMeshes = pcHeader->NUM_SURFACES; 771| 0| if (pcHeader->NUM_SURFACES == 0) { ------------------ | Branch (771:9): [True: 0, False: 0] ------------------ 772| 0| throw DeadlyImportError("MD3: No surfaces"); 773| 0| } else if (pcHeader->NUM_SURFACES > AI_MAX_ALLOC(aiMesh)) { ------------------ | Branch (773:16): [True: 0, False: 0] ------------------ 774| | // We allocate pointers but check against the size of aiMesh 775| | // since those pointers will eventually have to point to real objects 776| 0| throw DeadlyImportError("MD3: Too many surfaces, would run out of memory"); 777| 0| } 778| 0| pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]; 779| | 780| 0| pScene->mNumMaterials = pcHeader->NUM_SURFACES; 781| 0| pScene->mMaterials = new aiMaterial *[pScene->mNumMeshes]; 782| | 783| | // Set arrays to zero to ensue proper destruction if an exception is raised 784| 0| ::memset(pScene->mMeshes, 0, pScene->mNumMeshes * sizeof(aiMesh *)); 785| 0| ::memset(pScene->mMaterials, 0, pScene->mNumMaterials * sizeof(aiMaterial *)); 786| | 787| | // Now read possible skins from .skin file 788| 0| Q3Shader::SkinData skins; 789| 0| ReadSkin(skins); 790| | 791| | // And check whether we can locate a shader file for this model 792| 0| Q3Shader::ShaderData shaders; 793| 0| if (configLoadShaders){ ------------------ | Branch (793:9): [True: 0, False: 0] ------------------ 794| 0| ReadShader(shaders); 795| 0| } 796| | 797| | // Adjust all texture paths in the shader 798| 0| const char *header_name = pcHeader->NAME; 799| 0| if (!shaders.blocks.empty()) { ------------------ | Branch (799:9): [True: 0, False: 0] ------------------ 800| 0| for (std::list::iterator dit = shaders.blocks.begin(); dit != shaders.blocks.end(); ++dit) { ------------------ | Branch (800:91): [True: 0, False: 0] ------------------ 801| 0| ConvertPath((*dit).name.c_str(), header_name, (*dit).name); 802| | 803| 0| for (std::list::iterator mit = (*dit).maps.begin(); mit != (*dit).maps.end(); ++mit) { ------------------ | Branch (803:91): [True: 0, False: 0] ------------------ 804| 0| ConvertPath((*mit).name.c_str(), header_name, (*mit).name); 805| 0| } 806| 0| } 807| 0| } 808| | 809| | // Read all surfaces from the file 810| 0| unsigned int iNum = pcHeader->NUM_SURFACES; 811| 0| unsigned int iNumMaterials = 0; 812| 0| while (iNum-- > 0) { ------------------ | Branch (812:12): [True: 0, False: 0] ------------------ 813| | 814| | // Ensure correct endianness 815| |#ifdef AI_BUILD_BIG_ENDIAN 816| | 817| | AI_SWAP4(pcSurfaces->FLAGS); 818| | AI_SWAP4(pcSurfaces->IDENT); 819| | AI_SWAP4(pcSurfaces->NUM_FRAMES); 820| | AI_SWAP4(pcSurfaces->NUM_SHADER); 821| | AI_SWAP4(pcSurfaces->NUM_TRIANGLES); 822| | AI_SWAP4(pcSurfaces->NUM_VERTICES); 823| | AI_SWAP4(pcSurfaces->OFS_END); 824| | AI_SWAP4(pcSurfaces->OFS_SHADERS); 825| | AI_SWAP4(pcSurfaces->OFS_ST); 826| | AI_SWAP4(pcSurfaces->OFS_TRIANGLES); 827| | AI_SWAP4(pcSurfaces->OFS_XYZNORMAL); 828| | 829| |#endif 830| | 831| | // Validate the surface header 832| 0| ValidateSurfaceHeaderOffsets(pcSurfaces); 833| | 834| | // Navigate to the vertex list of the surface 835| 0| BE_NCONST MD3::Vertex *pcVertices = (BE_NCONST MD3::Vertex *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_XYZNORMAL); 836| | 837| | // Navigate to the triangle list of the surface 838| 0| BE_NCONST MD3::Triangle *pcTriangles = (BE_NCONST MD3::Triangle *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_TRIANGLES); 839| | 840| | // Navigate to the texture coordinate list of the surface 841| 0| BE_NCONST MD3::TexCoord *pcUVs = (BE_NCONST MD3::TexCoord *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_ST); 842| | 843| | // Navigate to the shader list of the surface 844| 0| BE_NCONST MD3::Shader *pcShaders = (BE_NCONST MD3::Shader *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_SHADERS); 845| | 846| | // If the submesh is empty ignore it 847| 0| if (0 == pcSurfaces->NUM_VERTICES || 0 == pcSurfaces->NUM_TRIANGLES) { ------------------ | Branch (847:13): [True: 0, False: 0] | Branch (847:46): [True: 0, False: 0] ------------------ 848| 0| pcSurfaces = (BE_NCONST MD3::Surface *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_END); 849| 0| pScene->mNumMeshes--; 850| 0| continue; 851| 0| } 852| | 853| | // Allocate output mesh 854| 0| pScene->mMeshes[iNum] = new aiMesh(); 855| 0| aiMesh *pcMesh = pScene->mMeshes[iNum]; 856| | 857| 0| std::string _texture_name; 858| 0| const char *texture_name = nullptr; 859| | 860| | // Check whether we have a texture record for this surface in the .skin file 861| 0| std::list::iterator it = std::find( 862| 0| skins.textures.begin(), skins.textures.end(), pcSurfaces->NAME); 863| | 864| 0| if (it != skins.textures.end()) { ------------------ | Branch (864:13): [True: 0, False: 0] ------------------ 865| 0| texture_name = &*(_texture_name = (*it).second).begin(); 866| 0| ASSIMP_LOG_VERBOSE_DEBUG("MD3: Assigning skin texture ", (*it).second, " to surface ", pcSurfaces->NAME); 867| 0| (*it).resolved = true; // mark entry as resolved 868| 0| } 869| | 870| | // Get the first shader (= texture?) assigned to the surface 871| 0| if (!texture_name && pcSurfaces->NUM_SHADER) { ------------------ | Branch (871:13): [True: 0, False: 0] | Branch (871:30): [True: 0, False: 0] ------------------ 872| 0| texture_name = pcShaders->NAME; 873| 0| } 874| | 875| 0| std::string convertedPath; 876| 0| if (texture_name) { ------------------ | Branch (876:13): [True: 0, False: 0] ------------------ 877| 0| if (configLoadShaders){ ------------------ | Branch (877:17): [True: 0, False: 0] ------------------ 878| 0| ConvertPath(texture_name, header_name, convertedPath); 879| 0| } 880| 0| else{ 881| 0| convertedPath = texture_name; 882| 0| } 883| 0| } 884| | 885| 0| const Q3Shader::ShaderDataBlock *shader = nullptr; 886| | 887| | // Now search the current shader for a record with this name ( 888| | // excluding texture file extension) 889| 0| if (!shaders.blocks.empty()) { ------------------ | Branch (889:13): [True: 0, False: 0] ------------------ 890| 0| std::string::size_type sh = convertedPath.find_last_of('.'); 891| 0| if (sh == std::string::npos) { ------------------ | Branch (891:17): [True: 0, False: 0] ------------------ 892| 0| sh = convertedPath.length(); 893| 0| } 894| | 895| 0| const std::string without_ext = convertedPath.substr(0, sh); 896| 0| std::list::const_iterator dit = std::find(shaders.blocks.begin(), shaders.blocks.end(), without_ext); 897| 0| if (dit != shaders.blocks.end()) { ------------------ | Branch (897:17): [True: 0, False: 0] ------------------ 898| | // We made it! 899| 0| shader = &*dit; 900| 0| ASSIMP_LOG_INFO("Found shader record for ", without_ext); 901| 0| } else { 902| 0| ASSIMP_LOG_WARN("Unable to find shader record for ", without_ext); 903| 0| } 904| 0| } 905| | 906| 0| aiMaterial *pcHelper = new aiMaterial(); 907| | 908| 0| const int iMode = (int)aiShadingMode_Gouraud; 909| 0| pcHelper->AddProperty(&iMode, 1, AI_MATKEY_SHADING_MODEL); 910| | 911| | // Add a small ambient color value - Quake 3 seems to have one 912| 0| aiColor3D clr; 913| 0| clr.b = clr.g = clr.r = 0.05f; 914| 0| pcHelper->AddProperty(&clr, 1, AI_MATKEY_COLOR_AMBIENT); 915| | 916| 0| clr.b = clr.g = clr.r = 1.0f; 917| 0| pcHelper->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE); 918| 0| pcHelper->AddProperty(&clr, 1, AI_MATKEY_COLOR_SPECULAR); 919| | 920| | // use surface name + skin_name as material name 921| 0| aiString name; 922| 0| name.Set("MD3_[" + configSkinFile + "][" + pcSurfaces->NAME + "]"); 923| 0| pcHelper->AddProperty(&name, AI_MATKEY_NAME); 924| | 925| 0| if (!shader) { ------------------ | Branch (925:13): [True: 0, False: 0] ------------------ 926| | // Setup dummy texture file name to ensure UV coordinates are kept during postprocessing 927| 0| aiString szString; 928| 0| if (convertedPath.length()) { ------------------ | Branch (928:17): [True: 0, False: 0] ------------------ 929| 0| szString.Set(convertedPath); 930| 0| } else { 931| 0| ASSIMP_LOG_WARN("Texture file name has zero length. Using default name"); 932| 0| szString.Set("dummy_texture.bmp"); 933| 0| } 934| 0| pcHelper->AddProperty(&szString, AI_MATKEY_TEXTURE_DIFFUSE(0)); 935| | 936| | // prevent transparency by default 937| 0| int no_alpha = aiTextureFlags_IgnoreAlpha; 938| 0| pcHelper->AddProperty(&no_alpha, 1, AI_MATKEY_TEXFLAGS_DIFFUSE(0)); 939| 0| } else { 940| 0| Q3Shader::ConvertShaderToMaterial(pcHelper, *shader); 941| 0| } 942| | 943| 0| pScene->mMaterials[iNumMaterials] = (aiMaterial *)pcHelper; 944| 0| pcMesh->mMaterialIndex = iNumMaterials++; 945| | 946| | // Ensure correct endianness 947| |#ifdef AI_BUILD_BIG_ENDIAN 948| | 949| | for (uint32_t i = 0; i < pcSurfaces->NUM_VERTICES; ++i) { 950| | AI_SWAP2(pcVertices[i].NORMAL); 951| | AI_SWAP2(pcVertices[i].X); 952| | AI_SWAP2(pcVertices[i].Y); 953| | AI_SWAP2(pcVertices[i].Z); 954| | 955| | AI_SWAP4(pcUVs[i].U); 956| | AI_SWAP4(pcUVs[i].V); 957| | } 958| | for (uint32_t i = 0; i < pcSurfaces->NUM_TRIANGLES; ++i) { 959| | AI_SWAP4(pcTriangles[i].INDEXES[0]); 960| | AI_SWAP4(pcTriangles[i].INDEXES[1]); 961| | AI_SWAP4(pcTriangles[i].INDEXES[2]); 962| | } 963| | 964| |#endif 965| | 966| | // Fill mesh information 967| 0| pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; 968| | 969| 0| pcMesh->mNumVertices = pcSurfaces->NUM_TRIANGLES * 3; 970| 0| pcMesh->mNumFaces = pcSurfaces->NUM_TRIANGLES; 971| 0| pcMesh->mFaces = new aiFace[pcSurfaces->NUM_TRIANGLES]; 972| 0| pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices]; 973| 0| pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices]; 974| 0| pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices]; 975| 0| pcMesh->mNumUVComponents[0] = 2; 976| | 977| | // Fill in all triangles 978| 0| unsigned int iCurrent = 0; 979| 0| for (unsigned int i = 0; i < (unsigned int)pcSurfaces->NUM_TRIANGLES; ++i) { ------------------ | Branch (979:34): [True: 0, False: 0] ------------------ 980| 0| pcMesh->mFaces[i].mIndices = new unsigned int[3]; 981| 0| pcMesh->mFaces[i].mNumIndices = 3; 982| | 983| | //unsigned int iTemp = iCurrent; 984| 0| for (unsigned int c = 0; c < 3; ++c, ++iCurrent) { ------------------ | Branch (984:38): [True: 0, False: 0] ------------------ 985| 0| pcMesh->mFaces[i].mIndices[c] = iCurrent; 986| | 987| | // Read vertices 988| 0| aiVector3D &vec = pcMesh->mVertices[iCurrent]; 989| 0| uint32_t index = pcTriangles->INDEXES[c]; 990| 0| if (index >= pcSurfaces->NUM_VERTICES) { ------------------ | Branch (990:21): [True: 0, False: 0] ------------------ 991| 0| throw DeadlyImportError("MD3: Invalid vertex index"); 992| 0| } 993| 0| vec.x = pcVertices[index].X * AI_MD3_XYZ_SCALE; ------------------ | | 80| 0|#define AI_MD3_XYZ_SCALE (1.0f/64.0f) ------------------ 994| 0| vec.y = pcVertices[index].Y * AI_MD3_XYZ_SCALE; ------------------ | | 80| 0|#define AI_MD3_XYZ_SCALE (1.0f/64.0f) ------------------ 995| 0| vec.z = pcVertices[index].Z * AI_MD3_XYZ_SCALE; ------------------ | | 80| 0|#define AI_MD3_XYZ_SCALE (1.0f/64.0f) ------------------ 996| | 997| | // Convert the normal vector to uncompressed float3 format 998| 0| aiVector3D &nor = pcMesh->mNormals[iCurrent]; 999| 0| LatLngNormalToVec3(pcVertices[index].NORMAL, (ai_real *)&nor); 1000| | 1001| | // Read texture coordinates 1002| 0| pcMesh->mTextureCoords[0][iCurrent].x = pcUVs[index].U; 1003| 0| pcMesh->mTextureCoords[0][iCurrent].y = 1.0f - pcUVs[index].V; 1004| 0| } 1005| | // Flip face order normally, unless shader is backfacing 1006| 0| if (!(shader && shader->cull == Q3Shader::CULL_CCW)) { ------------------ | Branch (1006:19): [True: 0, False: 0] | Branch (1006:29): [True: 0, False: 0] ------------------ 1007| 0| std::swap(pcMesh->mFaces[i].mIndices[2], pcMesh->mFaces[i].mIndices[1]); 1008| 0| } 1009| 0| ++pcTriangles; 1010| 0| } 1011| | 1012| | // Go to the next surface 1013| 0| pcSurfaces = (BE_NCONST MD3::Surface *)(((unsigned char *)pcSurfaces) + pcSurfaces->OFS_END); 1014| 0| } 1015| | 1016| | // For debugging purposes: check whether we found matches for all entries in the skins file 1017| 0| if (!DefaultLogger::isNullLogger()) { ------------------ | Branch (1017:9): [True: 0, False: 0] ------------------ 1018| 0| for (std::list::const_iterator it = skins.textures.begin(); it != skins.textures.end(); ++it) { ------------------ | Branch (1018:103): [True: 0, False: 0] ------------------ 1019| 0| if (!(*it).resolved) { ------------------ | Branch (1019:17): [True: 0, False: 0] ------------------ 1020| 0| ASSIMP_LOG_ERROR("MD3: Failed to match skin ", (*it).first, " to surface ", (*it).second); 1021| 0| } 1022| 0| } 1023| 0| } 1024| | 1025| 0| if (!pScene->mNumMeshes) { ------------------ | Branch (1025:9): [True: 0, False: 0] ------------------ 1026| 0| throw DeadlyImportError("MD3: File contains no valid mesh"); 1027| 0| } 1028| 0| pScene->mNumMaterials = iNumMaterials; 1029| | 1030| | // Now we need to generate an empty node graph 1031| 0| pScene->mRootNode = new aiNode(""); 1032| 0| pScene->mRootNode->mNumMeshes = pScene->mNumMeshes; 1033| 0| pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes]; 1034| | 1035| | // Attach tiny children for all tags 1036| 0| if (pcHeader->NUM_TAGS) { ------------------ | Branch (1036:9): [True: 0, False: 0] ------------------ 1037| 0| pScene->mRootNode->mNumChildren = pcHeader->NUM_TAGS; 1038| 0| pScene->mRootNode->mChildren = new aiNode *[pcHeader->NUM_TAGS]; 1039| | 1040| 0| for (unsigned int i = 0; i < pcHeader->NUM_TAGS; ++i, ++pcTags) { ------------------ | Branch (1040:34): [True: 0, False: 0] ------------------ 1041| 0| aiNode *nd = pScene->mRootNode->mChildren[i] = new aiNode(); 1042| 0| if ((const unsigned char*)pcTags + sizeof(MD3::Tag) > bufferEnd) { ------------------ | Branch (1042:17): [True: 0, False: 0] ------------------ 1043| 0| throw DeadlyImportError("MD3 tag is outside the file"); 1044| 0| } 1045| | 1046| 0| nd->mName.Set((const char *)pcTags->NAME); 1047| 0| nd->mParent = pScene->mRootNode; 1048| | 1049| 0| AI_SWAP4(pcTags->origin.x); 1050| 0| AI_SWAP4(pcTags->origin.y); 1051| 0| AI_SWAP4(pcTags->origin.z); 1052| | 1053| | // Copy local origin, again flip z,y 1054| 0| nd->mTransformation.a4 = pcTags->origin.x; 1055| 0| nd->mTransformation.b4 = pcTags->origin.y; 1056| 0| nd->mTransformation.c4 = pcTags->origin.z; 1057| | 1058| | // Copy rest of transformation (need to transpose to match row-order matrix) 1059| 0| for (unsigned int a = 0; a < 3; ++a) { ------------------ | Branch (1059:38): [True: 0, False: 0] ------------------ 1060| 0| for (unsigned int m = 0; m < 3; ++m) { ------------------ | Branch (1060:42): [True: 0, False: 0] ------------------ 1061| 0| nd->mTransformation[m][a] = pcTags->orientation[a][m]; 1062| 0| AI_SWAP4(nd->mTransformation[m][a]); 1063| 0| } 1064| 0| } 1065| 0| } 1066| 0| } 1067| | 1068| 0| for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) ------------------ | Branch (1068:30): [True: 0, False: 0] ------------------ 1069| 0| pScene->mRootNode->mMeshes[i] = i; 1070| | 1071| | // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system 1072| 0| pScene->mRootNode->mTransformation = aiMatrix4x4( 1073| 0| 1.f, 0.f, 0.f, 0.f, 1074| 0| 0.f, 0.f, 1.f, 0.f, 1075| 0| 0.f, -1.f, 0.f, 0.f, 1076| 0| 0.f, 0.f, 0.f, 1.f); 1077| 0|} _ZN6Assimp11MD5ImporterC2Ev: 83| 624| mIOHandler(nullptr), 84| | mBuffer(), 85| | mFileSize(), 86| | mLineNumber(), 87| | mScene(), 88| | mHadMD5Mesh(), 89| | mHadMD5Anim(), 90| | mHadMD5Camera(), 91| 624| mCconfigNoAutoLoad(false) { 92| | // empty 93| 624|} _ZNK6Assimp11MD5Importer7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 97| 409|bool MD5Importer::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 98| 409| static const char *tokens[] = { "MD5Version" }; 99| | return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); 100| 409|} _ZNK6Assimp11MD5Importer7GetInfoEv: 104| 641|const aiImporterDesc *MD5Importer::GetInfo() const { 105| 641| return &desc; 106| 641|} _ZN6Assimp11MD5Importer15SetupPropertiesEPKNS_8ImporterE: 110| 7|void MD5Importer::SetupProperties(const Importer *pImp) { 111| | // AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD 112| | mCconfigNoAutoLoad = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD5_NO_ANIM_AUTOLOAD, 0)); 113| 7|} _ZN6Assimp11MD5Importer14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 117| 7|void MD5Importer::InternReadFile(const std::string &pFile, aiScene *_pScene, IOSystem *pIOHandler) { 118| 7| mIOHandler = pIOHandler; 119| 7| mScene = _pScene; 120| 7| mHadMD5Mesh = mHadMD5Anim = mHadMD5Camera = false; 121| | 122| | // remove the file extension 123| 7| const std::string::size_type pos = pFile.find_last_of('.'); 124| 7| mFile = (std::string::npos == pos ? pFile : pFile.substr(0, pos + 1)); ------------------ | Branch (124:14): [True: 0, False: 7] ------------------ 125| | 126| 7| const std::string extension = GetExtension(pFile); 127| 7| try { 128| 7| if (extension == "md5camera") { ------------------ | Branch (128:13): [True: 0, False: 7] ------------------ 129| 0| LoadMD5CameraFile(); 130| 7| } else if (mCconfigNoAutoLoad || extension == "md5anim") { ------------------ | Branch (130:20): [True: 0, False: 7] | Branch (130:42): [True: 0, False: 7] ------------------ 131| | // determine file extension and process just *one* file 132| 0| if (extension.length() == 0) { ------------------ | Branch (132:17): [True: 0, False: 0] ------------------ 133| 0| throw DeadlyImportError("Failure, need file extension to determine MD5 part type"); 134| 0| } 135| 0| if (extension == "md5anim") { ------------------ | Branch (135:17): [True: 0, False: 0] ------------------ 136| 0| LoadMD5AnimFile(); 137| 0| } else if (extension == "md5mesh") { ------------------ | Branch (137:24): [True: 0, False: 0] ------------------ 138| 0| LoadMD5MeshFile(); 139| 0| } 140| 7| } else { 141| 7| LoadMD5MeshFile(); 142| 7| LoadMD5AnimFile(); 143| 7| } 144| 7| } catch (...) { // std::exception, Assimp::DeadlyImportError 145| 2| UnloadFileFromMemory(); 146| 2| throw; 147| 2| } 148| | 149| | // make sure we have at least one file 150| 5| if (!mHadMD5Mesh && !mHadMD5Anim && !mHadMD5Camera) { ------------------ | Branch (150:9): [True: 0, False: 5] | Branch (150:25): [True: 0, False: 0] | Branch (150:41): [True: 0, False: 0] ------------------ 151| 0| throw DeadlyImportError("Failed to read valid contents out of this MD5* file"); 152| 0| } 153| | 154| | // Now rotate the whole scene 90 degrees around the x axis to match our internal coordinate system 155| 5| mScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f, 156| 5| 0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f); 157| | 158| | // the output scene wouldn't pass the validation without this flag 159| 5| if (!mHadMD5Mesh) { ------------------ | Branch (159:9): [True: 0, False: 5] ------------------ 160| 0| mScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; 161| 0| } 162| | 163| | // clean the instance -- the BaseImporter instance may be reused later. 164| 5| UnloadFileFromMemory(); 165| 5|} _ZN6Assimp11MD5Importer18LoadFileIntoMemoryEPNS_8IOStreamE: 169| 12|void MD5Importer::LoadFileIntoMemory(IOStream *file) { 170| | // unload the previous buffer, if any 171| 12| UnloadFileFromMemory(); 172| | 173| 12| ai_assert(nullptr != file); 174| 12| mFileSize = (unsigned int)file->FileSize(); 175| 12| ai_assert(mFileSize); 176| | 177| | // allocate storage and copy the contents of the file to a memory buffer 178| 12| mBuffer = new char[mFileSize + 1]; 179| 12| file->Read((void *)mBuffer, 1, mFileSize); 180| 12| mLineNumber = 1; 181| | 182| | // append a terminal 0 183| 12| mBuffer[mFileSize] = '\0'; 184| | 185| | // now remove all line comments from the file 186| 12| CommentRemover::RemoveLineComments("//", mBuffer, ' '); 187| 12|} _ZN6Assimp11MD5Importer20UnloadFileFromMemoryEv: 191| 19|void MD5Importer::UnloadFileFromMemory() { 192| | // delete the file buffer 193| 19| delete[] mBuffer; 194| 19| mBuffer = nullptr; 195| 19| mFileSize = 0; 196| 19|} _ZN6Assimp11MD5Importer17AttachChilds_MeshEiP6aiNodeRNSt3__16vectorINS_3MD58BoneDescENS3_9allocatorIS6_EEEE: 234| 5|void MD5Importer::AttachChilds_Mesh(int iParentID, aiNode *piParent, BoneArray &bones) { 235| 5| ai_assert(nullptr != piParent); 236| 5| ai_assert(!piParent->mNumChildren); 237| | 238| | // First find out how many children we'll have 239| 5| for (int i = 0; i < (int)bones.size(); ++i) { ------------------ | Branch (239:21): [True: 0, False: 5] ------------------ 240| 0| if (iParentID != i && bones[i].mParentIndex == iParentID) { ------------------ | Branch (240:13): [True: 0, False: 0] | Branch (240:31): [True: 0, False: 0] ------------------ 241| 0| ++piParent->mNumChildren; 242| 0| } 243| 0| } 244| 5| if (piParent->mNumChildren) { ------------------ | Branch (244:9): [True: 0, False: 5] ------------------ 245| 0| piParent->mChildren = new aiNode *[piParent->mNumChildren]; 246| 0| for (int i = 0; i < (int)bones.size(); ++i) { ------------------ | Branch (246:25): [True: 0, False: 0] ------------------ 247| | // (avoid infinite recursion) 248| 0| if (iParentID != i && bones[i].mParentIndex == iParentID) { ------------------ | Branch (248:17): [True: 0, False: 0] | Branch (248:35): [True: 0, False: 0] ------------------ 249| 0| aiNode *pc; 250| | // setup a new node 251| 0| *piParent->mChildren++ = pc = new aiNode(); 252| 0| pc->mName = aiString(bones[i].mName); 253| 0| pc->mParent = piParent; 254| | 255| | // get the transformation matrix from rotation and translational components 256| 0| aiQuaternion quat; 257| 0| MD5::ConvertQuaternion(bones[i].mRotationQuat, quat); 258| | 259| 0| bones[i].mTransform = aiMatrix4x4(quat.GetMatrix()); 260| 0| bones[i].mTransform.a4 = bones[i].mPositionXYZ.x; 261| 0| bones[i].mTransform.b4 = bones[i].mPositionXYZ.y; 262| 0| bones[i].mTransform.c4 = bones[i].mPositionXYZ.z; 263| | 264| | // store it for later use 265| 0| pc->mTransformation = bones[i].mInvTransform = bones[i].mTransform; 266| 0| bones[i].mInvTransform.Inverse(); 267| | 268| | // the transformations for each bone are absolute, so we need to multiply them 269| | // with the inverse of the absolute matrix of the parent joint 270| 0| if (-1 != iParentID) { ------------------ | Branch (270:21): [True: 0, False: 0] ------------------ 271| 0| pc->mTransformation = bones[iParentID].mInvTransform * pc->mTransformation; 272| 0| } 273| | 274| | // add children to this node, too 275| 0| AttachChilds_Mesh(i, pc, bones); 276| 0| } 277| 0| } 278| | // undo offset computations 279| 0| piParent->mChildren -= piParent->mNumChildren; 280| 0| } 281| 5|} _ZN6Assimp11MD5Importer15LoadMD5MeshFileEv: 325| 7|void MD5Importer::LoadMD5MeshFile() { 326| 7| std::string filename = mFile + "md5mesh"; 327| 7| std::unique_ptr file(mIOHandler->Open(filename, "rb")); 328| | 329| | // Check whether we can read from the file 330| 7| if (file == nullptr || !file->FileSize()) { ------------------ | Branch (330:9): [True: 0, False: 7] | Branch (330:28): [True: 0, False: 7] ------------------ 331| 0| ASSIMP_LOG_WARN("Failed to access MD5MESH file: ", filename); 332| 0| return; 333| 0| } 334| 7| mHadMD5Mesh = true; 335| 7| LoadFileIntoMemory(file.get()); 336| | 337| | // now construct a parser and parse the file 338| 7| MD5::MD5Parser parser(mBuffer, mFileSize); 339| | 340| | // load the mesh information from it 341| 7| MD5::MD5MeshParser meshParser(parser.mSections); 342| | 343| | // create the bone hierarchy - first the root node and dummy nodes for all meshes 344| 7| mScene->mRootNode = new aiNode(""); 345| 7| mScene->mRootNode->mNumChildren = 2; 346| 7| mScene->mRootNode->mChildren = new aiNode *[2]; 347| | 348| | // build the hierarchy from the MD5MESH file 349| 7| aiNode *pcNode = mScene->mRootNode->mChildren[1] = new aiNode(); 350| 7| pcNode->mName.Set(""); 351| 7| pcNode->mParent = mScene->mRootNode; 352| 7| AttachChilds_Mesh(-1, pcNode, meshParser.mJoints); 353| | 354| 7| pcNode = mScene->mRootNode->mChildren[0] = new aiNode(); 355| 7| pcNode->mName.Set(""); 356| 7| pcNode->mParent = mScene->mRootNode; 357| | 358| |#if 0 359| | if (pScene->mRootNode->mChildren[1]->mNumChildren) /* start at the right hierarchy level */ 360| | SkeletonMeshBuilder skeleton_maker(pScene,pScene->mRootNode->mChildren[1]->mChildren[0]); 361| |#else 362| | 363| | // FIX: MD5 files exported from Blender can have empty meshes 364| 7| unsigned int numMaterials = 0; 365| 68| for (std::vector::const_iterator it = meshParser.mMeshes.begin(), end = meshParser.mMeshes.end(); it != end; ++it) { ------------------ | Branch (365:118): [True: 61, False: 7] ------------------ 366| 61| if (!(*it).mFaces.empty() && !(*it).mVertices.empty()) { ------------------ | Branch (366:13): [True: 2, False: 59] | Branch (366:38): [True: 0, False: 2] ------------------ 367| 0| ++numMaterials; 368| 0| } 369| 61| } 370| | 371| | // generate all meshes 372| 7| mScene->mMeshes = new aiMesh *[numMaterials]; 373| 7| mScene->mMaterials = new aiMaterial *[numMaterials]; 374| | 375| | // storage for node mesh indices 376| 7| pcNode->mNumMeshes = numMaterials; 377| 7| pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes]; 378| 7| for (unsigned int m = 0; m < pcNode->mNumMeshes; ++m) { ------------------ | Branch (378:30): [True: 0, False: 7] ------------------ 379| 0| pcNode->mMeshes[m] = m; 380| 0| } 381| | 382| 7| unsigned int n = 0; 383| 68| for (std::vector::iterator it = meshParser.mMeshes.begin(), end = meshParser.mMeshes.end(); it != end; ++it) { ------------------ | Branch (383:112): [True: 61, False: 7] ------------------ 384| 61| MD5::MeshDesc &meshSrc = *it; 385| 61| if (meshSrc.mFaces.empty() || meshSrc.mVertices.empty()) { ------------------ | Branch (385:13): [True: 59, False: 2] | Branch (385:39): [True: 2, False: 0] ------------------ 386| 61| continue; 387| 61| } 388| | 389| 0| aiMesh* mesh = new aiMesh(); 390| 0| mScene->mMeshes[n] = mesh; 391| 0| ++mScene->mNumMeshes; 392| | 393| 0| mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; 394| | 395| | // generate unique vertices in our internal verbose format 396| 0| MakeDataUnique(meshSrc); 397| | 398| 0| std::string name(meshSrc.mShader.C_Str()); 399| 0| name += ".msh"; 400| 0| mesh->mName = name; 401| 0| mesh->mNumVertices = (unsigned int)meshSrc.mVertices.size(); 402| 0| mesh->mVertices = new aiVector3D[mesh->mNumVertices]; 403| 0| mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices]; 404| 0| mesh->mNumUVComponents[0] = 2; 405| | 406| | // copy texture coordinates 407| 0| aiVector3D *pv = mesh->mTextureCoords[0]; 408| 0| for (MD5::VertexArray::const_iterator iter = meshSrc.mVertices.begin(); iter != meshSrc.mVertices.end(); ++iter, ++pv) { ------------------ | Branch (408:81): [True: 0, False: 0] ------------------ 409| 0| pv->x = (*iter).mUV.x; 410| 0| pv->y = 1.0f - (*iter).mUV.y; // D3D to OpenGL 411| 0| pv->z = 0.0f; 412| 0| } 413| | 414| | // sort all bone weights - per bone 415| 0| unsigned int *piCount = new unsigned int[meshParser.mJoints.size()]; 416| 0| ::memset(piCount, 0, sizeof(unsigned int) * meshParser.mJoints.size()); 417| | 418| 0| for (MD5::VertexArray::const_iterator iter = meshSrc.mVertices.begin(); iter != meshSrc.mVertices.end(); ++iter, ++pv) { ------------------ | Branch (418:81): [True: 0, False: 0] ------------------ 419| 0| for (unsigned int jub = (*iter).mFirstWeight, w = jub; w < jub + (*iter).mNumWeights; ++w) { ------------------ | Branch (419:68): [True: 0, False: 0] ------------------ 420| 0| MD5::WeightDesc &weightDesc = meshSrc.mWeights[w]; 421| | /* FIX for some invalid exporters */ 422| 0| if (!(weightDesc.mWeight < AI_MD5_WEIGHT_EPSILON && weightDesc.mWeight >= -AI_MD5_WEIGHT_EPSILON)) { ------------------ | | 65| 0|#define AI_MD5_WEIGHT_EPSILON Math::getEpsilon() ------------------ if (!(weightDesc.mWeight < AI_MD5_WEIGHT_EPSILON && weightDesc.mWeight >= -AI_MD5_WEIGHT_EPSILON)) { ------------------ | | 65| 0|#define AI_MD5_WEIGHT_EPSILON Math::getEpsilon() ------------------ | Branch (422:23): [True: 0, False: 0] | Branch (422:69): [True: 0, False: 0] ------------------ 423| 0| ++piCount[weightDesc.mBone]; 424| 0| } 425| 0| } 426| 0| } 427| | 428| | // check how many we will need 429| 0| for (unsigned int p = 0; p < meshParser.mJoints.size(); ++p) { ------------------ | Branch (429:34): [True: 0, False: 0] ------------------ 430| 0| if (piCount[p]) mesh->mNumBones++; ------------------ | Branch (430:17): [True: 0, False: 0] ------------------ 431| 0| } 432| | 433| | // just for safety 434| 0| if (mesh->mNumBones) { ------------------ | Branch (434:13): [True: 0, False: 0] ------------------ 435| 0| mesh->mBones = new aiBone *[mesh->mNumBones]; 436| 0| for (unsigned int q = 0, h = 0; q < meshParser.mJoints.size(); ++q) { ------------------ | Branch (436:45): [True: 0, False: 0] ------------------ 437| 0| if (!piCount[q]) continue; ------------------ | Branch (437:21): [True: 0, False: 0] ------------------ 438| 0| aiBone *p = mesh->mBones[h] = new aiBone(); 439| 0| p->mNumWeights = piCount[q]; 440| 0| p->mWeights = new aiVertexWeight[p->mNumWeights]; 441| 0| p->mName = aiString(meshParser.mJoints[q].mName); 442| 0| p->mOffsetMatrix = meshParser.mJoints[q].mInvTransform; 443| | 444| | // store the index for later use 445| 0| MD5::BoneDesc &boneSrc = meshParser.mJoints[q]; 446| 0| boneSrc.mMap = h++; 447| | 448| | // compute w-component of quaternion 449| 0| MD5::ConvertQuaternion(boneSrc.mRotationQuat, boneSrc.mRotationQuatConverted); 450| 0| } 451| | 452| 0| pv = mesh->mVertices; 453| 0| for (MD5::VertexArray::const_iterator iter = meshSrc.mVertices.begin(); iter != meshSrc.mVertices.end(); ++iter, ++pv) { ------------------ | Branch (453:85): [True: 0, False: 0] ------------------ 454| | // compute the final vertex position from all single weights 455| 0| *pv = aiVector3D(); 456| | 457| | // there are models which have weights which don't sum to 1 ... 458| 0| ai_real fSum = 0.0; 459| 0| for (unsigned int jub = (*iter).mFirstWeight, w = jub; w < jub + (*iter).mNumWeights; ++w) { ------------------ | Branch (459:72): [True: 0, False: 0] ------------------ 460| 0| fSum += meshSrc.mWeights[w].mWeight; 461| 0| } 462| 0| if (!fSum) { ------------------ | Branch (462:21): [True: 0, False: 0] ------------------ 463| 0| ASSIMP_LOG_ERROR("MD5MESH: The sum of all vertex bone weights is 0"); 464| 0| continue; 465| 0| } 466| | 467| | // process bone weights 468| 0| for (unsigned int jub = (*iter).mFirstWeight, w = jub; w < jub + (*iter).mNumWeights; ++w) { ------------------ | Branch (468:72): [True: 0, False: 0] ------------------ 469| 0| if (w >= meshSrc.mWeights.size()) { ------------------ | Branch (469:25): [True: 0, False: 0] ------------------ 470| 0| throw DeadlyImportError("MD5MESH: Invalid weight index"); 471| 0| } 472| | 473| 0| MD5::WeightDesc &weightDesc = meshSrc.mWeights[w]; 474| 0| if (weightDesc.mWeight < AI_MD5_WEIGHT_EPSILON && weightDesc.mWeight >= -AI_MD5_WEIGHT_EPSILON) { ------------------ | | 65| 0|#define AI_MD5_WEIGHT_EPSILON Math::getEpsilon() ------------------ if (weightDesc.mWeight < AI_MD5_WEIGHT_EPSILON && weightDesc.mWeight >= -AI_MD5_WEIGHT_EPSILON) { ------------------ | | 65| 0|#define AI_MD5_WEIGHT_EPSILON Math::getEpsilon() ------------------ | Branch (474:25): [True: 0, False: 0] | Branch (474:71): [True: 0, False: 0] ------------------ 475| 0| continue; 476| 0| } 477| | 478| 0| const ai_real fNewWeight = weightDesc.mWeight / fSum; 479| | 480| | // transform the local position into worldspace 481| 0| MD5::BoneDesc &boneSrc = meshParser.mJoints[weightDesc.mBone]; 482| 0| const aiVector3D v = boneSrc.mRotationQuatConverted.Rotate(weightDesc.vOffsetPosition); 483| | 484| | // use the original weight to compute the vertex position 485| | // (some MD5s seem to depend on the invalid weight values ...) 486| 0| *pv += ((boneSrc.mPositionXYZ + v) * (ai_real)weightDesc.mWeight); 487| | 488| 0| aiBone *bone = mesh->mBones[boneSrc.mMap]; 489| 0| *bone->mWeights++ = aiVertexWeight((unsigned int)(pv - mesh->mVertices), fNewWeight); 490| 0| } 491| 0| } 492| | 493| | // undo our nice offset tricks ... 494| 0| for (unsigned int p = 0; p < mesh->mNumBones; ++p) { ------------------ | Branch (494:38): [True: 0, False: 0] ------------------ 495| 0| mesh->mBones[p]->mWeights -= mesh->mBones[p]->mNumWeights; 496| 0| } 497| 0| } 498| | 499| 0| delete[] piCount; 500| | 501| | // now setup all faces - we can directly copy the list 502| | // (however, take care that the aiFace destructor doesn't delete the mIndices array) 503| 0| mesh->mNumFaces = (unsigned int)meshSrc.mFaces.size(); 504| 0| mesh->mFaces = new aiFace[mesh->mNumFaces]; 505| 0| for (unsigned int c = 0; c < mesh->mNumFaces; ++c) { ------------------ | Branch (505:34): [True: 0, False: 0] ------------------ 506| 0| mesh->mFaces[c].mNumIndices = 3; 507| 0| mesh->mFaces[c].mIndices = meshSrc.mFaces[c].mIndices; 508| 0| meshSrc.mFaces[c].mIndices = nullptr; 509| 0| } 510| | 511| | // generate a material for the mesh 512| 0| aiMaterial *mat = new aiMaterial(); 513| 0| mScene->mMaterials[n] = mat; 514| 0| ++mScene->mNumMaterials; 515| | 516| | // insert the typical doom3 textures: 517| | // nnn_local.tga - normal map 518| | // nnn_h.tga - height map 519| | // nnn_s.tga - specular map 520| | // nnn_d.tga - diffuse map 521| 0| if (meshSrc.mShader.length && !strchr(meshSrc.mShader.data, '.')) { ------------------ | Branch (521:13): [True: 0, False: 0] | Branch (521:39): [True: 0, False: 0] ------------------ 522| | 523| 0| aiString temp(meshSrc.mShader); 524| 0| temp.Append("_local.tga"); 525| 0| mat->AddProperty(&temp, AI_MATKEY_TEXTURE_NORMALS(0)); 526| | 527| 0| temp = aiString(meshSrc.mShader); 528| 0| temp.Append("_s.tga"); 529| 0| mat->AddProperty(&temp, AI_MATKEY_TEXTURE_SPECULAR(0)); 530| | 531| 0| temp = aiString(meshSrc.mShader); 532| 0| temp.Append("_d.tga"); 533| 0| mat->AddProperty(&temp, AI_MATKEY_TEXTURE_DIFFUSE(0)); 534| | 535| 0| temp = aiString(meshSrc.mShader); 536| 0| temp.Append("_h.tga"); 537| 0| mat->AddProperty(&temp, AI_MATKEY_TEXTURE_HEIGHT(0)); 538| | 539| | // set this also as material name 540| 0| mat->AddProperty(&meshSrc.mShader, AI_MATKEY_NAME); 541| 0| } else { 542| | mat->AddProperty(&meshSrc.mShader, AI_MATKEY_TEXTURE_DIFFUSE(0)); 543| 0| } 544| 0| mesh->mMaterialIndex = n++; 545| 0| } 546| 7|#endif 547| 7|} _ZN6Assimp11MD5Importer15LoadMD5AnimFileEv: 551| 5|void MD5Importer::LoadMD5AnimFile() { 552| 5| std::string pFile = mFile + "md5anim"; 553| 5| std::unique_ptr file(mIOHandler->Open(pFile, "rb")); 554| | 555| | // Check whether we can read from the file 556| 5| if (!file || !file->FileSize()) { ------------------ | Branch (556:9): [True: 0, False: 5] | Branch (556:18): [True: 0, False: 5] ------------------ 557| 0| ASSIMP_LOG_WARN("Failed to read MD5ANIM file: ", pFile); 558| 0| return; 559| 0| } 560| | 561| 5| LoadFileIntoMemory(file.get()); 562| | 563| | // parse the basic file structure 564| 5| MD5::MD5Parser parser(mBuffer, mFileSize); 565| | 566| | // load the animation information from the parse tree 567| 5| MD5::MD5AnimParser animParser(parser.mSections); 568| | 569| | // generate and fill the output animation 570| 5| if (animParser.mAnimatedBones.empty() || animParser.mFrames.empty() || ------------------ | Branch (570:9): [True: 3, False: 2] | Branch (570:46): [True: 2, False: 0] ------------------ 571| 5| animParser.mBaseFrames.size() != animParser.mAnimatedBones.size()) { ------------------ | Branch (571:13): [True: 0, False: 0] ------------------ 572| 5| ASSIMP_LOG_ERROR("MD5ANIM: No frames or animated bones loaded"); 573| 5| } else { 574| 0| mHadMD5Anim = true; 575| | 576| 0| mScene->mAnimations = new aiAnimation *[mScene->mNumAnimations = 1]; 577| 0| aiAnimation *anim = mScene->mAnimations[0] = new aiAnimation(); 578| 0| anim->mNumChannels = (unsigned int)animParser.mAnimatedBones.size(); 579| 0| anim->mChannels = new aiNodeAnim *[anim->mNumChannels]; 580| 0| for (unsigned int i = 0; i < anim->mNumChannels; ++i) { ------------------ | Branch (580:34): [True: 0, False: 0] ------------------ 581| 0| aiNodeAnim *node = anim->mChannels[i] = new aiNodeAnim(); 582| 0| node->mNodeName = aiString(animParser.mAnimatedBones[i].mName); 583| | 584| | // allocate storage for the keyframes 585| 0| node->mPositionKeys = new aiVectorKey[animParser.mFrames.size()]; 586| 0| node->mRotationKeys = new aiQuatKey[animParser.mFrames.size()]; 587| 0| } 588| | 589| | // 1 tick == 1 frame 590| 0| anim->mTicksPerSecond = animParser.fFrameRate; 591| | 592| 0| for (FrameArray::const_iterator iter = animParser.mFrames.begin(), iterEnd = animParser.mFrames.end(); iter != iterEnd; ++iter) { ------------------ | Branch (592:112): [True: 0, False: 0] ------------------ 593| 0| double dTime = (double)(*iter).iIndex; 594| 0| aiNodeAnim **pcAnimNode = anim->mChannels; 595| 0| if (!(*iter).mValues.empty() || iter == animParser.mFrames.begin()) /* be sure we have at least one frame */ ------------------ | Branch (595:17): [True: 0, False: 0] | Branch (595:17): [True: 0, False: 0] | Branch (595:45): [True: 0, False: 0] ------------------ 596| 0| { 597| | // now process all values in there ... read all joints 598| 0| MD5::BaseFrameDesc *pcBaseFrame = &animParser.mBaseFrames[0]; 599| 0| for (AnimBoneArray::const_iterator iter2 = animParser.mAnimatedBones.begin(); iter2 != animParser.mAnimatedBones.end(); ++iter2, ------------------ | Branch (599:95): [True: 0, False: 0] ------------------ 600| 0| ++pcAnimNode, ++pcBaseFrame) { 601| 0| if ((*iter2).iFirstKeyIndex >= (*iter).mValues.size()) { ------------------ | Branch (601:25): [True: 0, False: 0] ------------------ 602| | 603| | // Allow for empty frames 604| 0| if ((*iter2).iFlags != 0) { ------------------ | Branch (604:29): [True: 0, False: 0] ------------------ 605| 0| throw DeadlyImportError("MD5: Keyframe index is out of range"); 606| 0| } 607| 0| continue; 608| 0| } 609| 0| const float *fpCur = &(*iter).mValues[(*iter2).iFirstKeyIndex]; 610| 0| aiNodeAnim *pcCurAnimBone = *pcAnimNode; 611| | 612| 0| aiVectorKey *vKey = &pcCurAnimBone->mPositionKeys[pcCurAnimBone->mNumPositionKeys++]; 613| 0| aiQuatKey *qKey = &pcCurAnimBone->mRotationKeys[pcCurAnimBone->mNumRotationKeys++]; 614| 0| aiVector3D vTemp; 615| | 616| | // translational component 617| 0| for (unsigned int i = 0; i < 3; ++i) { ------------------ | Branch (617:46): [True: 0, False: 0] ------------------ 618| 0| if ((*iter2).iFlags & (1u << i)) { ------------------ | Branch (618:29): [True: 0, False: 0] ------------------ 619| 0| vKey->mValue[i] = *fpCur++; 620| 0| } else 621| 0| vKey->mValue[i] = pcBaseFrame->vPositionXYZ[i]; 622| 0| } 623| | 624| | // orientation component 625| 0| for (unsigned int i = 0; i < 3; ++i) { ------------------ | Branch (625:46): [True: 0, False: 0] ------------------ 626| 0| if ((*iter2).iFlags & (8u << i)) { ------------------ | Branch (626:29): [True: 0, False: 0] ------------------ 627| 0| vTemp[i] = *fpCur++; 628| 0| } else 629| 0| vTemp[i] = pcBaseFrame->vRotationQuat[i]; 630| 0| } 631| | 632| 0| MD5::ConvertQuaternion(vTemp, qKey->mValue); 633| 0| qKey->mTime = vKey->mTime = dTime; 634| 0| } 635| 0| } 636| | 637| | // compute the duration of the animation 638| 0| anim->mDuration = std::max(dTime, anim->mDuration); 639| 0| } 640| | 641| | // If we didn't build the hierarchy yet (== we didn't load a MD5MESH), 642| | // construct it now from the data given in the MD5ANIM. 643| 0| if (!mScene->mRootNode) { ------------------ | Branch (643:13): [True: 0, False: 0] ------------------ 644| 0| mScene->mRootNode = new aiNode(); 645| 0| mScene->mRootNode->mName.Set(""); 646| | 647| 0| AttachChilds_Anim(-1, mScene->mRootNode, animParser.mAnimatedBones, (const aiNodeAnim **)anim->mChannels); 648| | 649| | // Call SkeletonMeshBuilder to construct a mesh to represent the shape 650| 0| if (mScene->mRootNode->mNumChildren) { ------------------ | Branch (650:17): [True: 0, False: 0] ------------------ 651| 0| SkeletonMeshBuilder skeleton_maker(mScene, mScene->mRootNode->mChildren[0]); 652| 0| } 653| 0| } 654| 0| } 655| 5|} _ZN6Assimp11MD5ImporterD2Ev: 68| 624| ~MD5Importer() override = default; _ZN6Assimp3MD59MD5ParserC2EPcj: 61| 12|MD5Parser::MD5Parser(char *_buffer, unsigned int _fileSize) : buffer(_buffer), bufferEnd(nullptr), fileSize(_fileSize), lineNumber(0) { 62| 12| ai_assert(nullptr != _buffer); 63| 12| ai_assert(0 != _fileSize); 64| | 65| 12| bufferEnd = buffer + fileSize; 66| 12| ASSIMP_LOG_DEBUG("MD5Parser begin"); 67| | 68| | // parse the file header 69| 12| ParseHeader(); 70| | 71| | // and read all sections until we're finished 72| 12| bool running = true; 73| 2.06k| while (running) { ------------------ | Branch (73:12): [True: 2.06k, False: 0] ------------------ 74| 2.06k| mSections.emplace_back(); 75| 2.06k| Section &sec = mSections.back(); 76| 2.06k| if (!ParseSection(sec)) { ------------------ | Branch (76:13): [True: 12, False: 2.04k] ------------------ 77| 12| break; 78| 12| } 79| 2.06k| } 80| | 81| 12| if (!DefaultLogger::isNullLogger()) { ------------------ | Branch (81:9): [True: 0, False: 12] ------------------ 82| 0| char szBuffer[128]; // should be sufficiently large 83| 0| ::ai_snprintf(szBuffer, 128, "MD5Parser end. Parsed %i sections", (int)mSections.size()); 84| | ASSIMP_LOG_DEBUG(szBuffer); 85| 0| } 86| 12|} _ZN6Assimp3MD59MD5Parser13ReportWarningEPKcj: 98| 15.7k|void MD5Parser::ReportWarning(const char *warn, unsigned int line) { 99| 15.7k| char szBuffer[1024]; 100| 15.7k| ::snprintf(szBuffer, sizeof(szBuffer), "[MD5] Line %u: %s", line, warn); 101| | ASSIMP_LOG_WARN(szBuffer); 102| 15.7k|} _ZN6Assimp3MD59MD5Parser11ParseHeaderEv: 106| 12|void MD5Parser::ParseHeader() { 107| | // parse and validate the file version 108| 12| SkipSpaces(); 109| 12| if (!TokenMatch(buffer, "MD5Version", 10)) { ------------------ | Branch (109:9): [True: 0, False: 12] ------------------ 110| 0| ReportError("Invalid MD5 file: MD5Version tag has not been found"); 111| 0| } 112| 12| SkipSpaces(); 113| 12| unsigned int iVer = ::strtoul10(buffer, (const char **)&buffer); 114| 12| if (10 != iVer) { ------------------ | Branch (114:9): [True: 0, False: 12] ------------------ 115| 0| ReportError("MD5 version tag is unknown (10 is expected)"); 116| 0| } 117| 12| SkipLine(); 118| | 119| | // print the command line options to the console 120| 12| char *sz = buffer; 121| 392| while (buffer < bufferEnd) { ------------------ | Branch (121:12): [True: 392, False: 0] ------------------ 122| 392| if (IsLineEnd(*buffer++)) { ------------------ | Branch (122:13): [True: 12, False: 380] ------------------ 123| 12| break; 124| 12| } 125| 392| } 126| | 127| 12| if (buffer == bufferEnd) { ------------------ | Branch (127:9): [True: 0, False: 12] ------------------ 128| 0| return; 129| 0| } 130| | 131| 12| ASSIMP_LOG_INFO(std::string(sz, std::min((uintptr_t)MAX_LOG_MESSAGE_LENGTH, (uintptr_t)(buffer - sz)))); 132| 12| SkipSpacesAndLineEnd(); 133| 12|} _ZN6Assimp3MD59MD5Parser12ParseSectionERNS0_7SectionE: 137| 2.06k|bool MD5Parser::ParseSection(Section &out) { 138| | // store the current line number for use in error messages 139| 2.06k| out.iLineNumber = lineNumber; 140| | 141| | // first parse the name of the section 142| 2.06k| char *sz = buffer; 143| 15.7k| while (!IsSpaceOrNewLine(*buffer)) { ------------------ | Branch (143:12): [True: 13.7k, False: 2.06k] ------------------ 144| 13.7k| ++buffer; 145| 13.7k| if (buffer == bufferEnd) { ------------------ | Branch (145:13): [True: 0, False: 13.7k] ------------------ 146| 0| return false; 147| 0| } 148| 13.7k| } 149| 2.06k| out.mName = std::string(sz, (uintptr_t)(buffer - sz)); 150| 3.35k| while (IsSpace(*buffer)) { ------------------ | Branch (150:12): [True: 1.29k, False: 2.06k] ------------------ 151| 1.29k| ++buffer; 152| 1.29k| if (buffer == bufferEnd) { ------------------ | Branch (152:13): [True: 0, False: 1.29k] ------------------ 153| 0| return false; 154| 0| } 155| 1.29k| } 156| | 157| 2.06k| bool running = true; 158| 5.19k| while (running) { ------------------ | Branch (158:12): [True: 5.19k, False: 0] ------------------ 159| 5.19k| if ('{' == *buffer) { ------------------ | Branch (159:13): [True: 100, False: 5.09k] ------------------ 160| | // it is a normal section so read all lines 161| 100| ++buffer; 162| 100| if (buffer == bufferEnd) { ------------------ | Branch (162:17): [True: 0, False: 100] ------------------ 163| 0| return false; 164| 0| } 165| 100| bool run = true; 166| 27.0k| while (run) { ------------------ | Branch (166:20): [True: 27.0k, False: 0] ------------------ 167| 57.9k| while (IsSpaceOrNewLine(*buffer)) { ------------------ | Branch (167:24): [True: 30.9k, False: 27.0k] ------------------ 168| 30.9k| ++buffer; 169| 30.9k| if (buffer == bufferEnd) { ------------------ | Branch (169:25): [True: 0, False: 30.9k] ------------------ 170| 0| return false; 171| 0| } 172| 30.9k| } 173| 27.0k| if ('\0' == *buffer) { ------------------ | Branch (173:21): [True: 0, False: 27.0k] ------------------ 174| 0| return false; // seems this was the last section 175| 0| } 176| 27.0k| if ('}' == *buffer) { ------------------ | Branch (176:21): [True: 90, False: 26.9k] ------------------ 177| 90| ++buffer; 178| 90| break; 179| 90| } 180| | 181| 26.9k| out.mElements.emplace_back(); 182| 26.9k| Element &elem = out.mElements.back(); 183| | 184| 26.9k| elem.iLineNumber = lineNumber; 185| 26.9k| elem.szStart = buffer; 186| 26.9k| elem.end = bufferEnd; 187| | 188| | // terminate the line with zero 189| 305k| while (!IsLineEnd(*buffer)) { ------------------ | Branch (189:24): [True: 278k, False: 26.9k] ------------------ 190| 278k| ++buffer; 191| 278k| if (buffer == bufferEnd) { ------------------ | Branch (191:25): [True: 10, False: 278k] ------------------ 192| 10| return false; 193| 10| } 194| 278k| } 195| 26.9k| if (*buffer) { ------------------ | Branch (195:21): [True: 19.0k, False: 7.94k] ------------------ 196| 19.0k| ++lineNumber; 197| 19.0k| *buffer++ = '\0'; 198| 19.0k| if (buffer == bufferEnd) { ------------------ | Branch (198:25): [True: 0, False: 19.0k] ------------------ 199| 0| return false; 200| 0| } 201| 19.0k| } 202| 26.9k| } 203| 90| break; 204| 5.09k| } else if (!IsSpaceOrNewLine(*buffer)) { ------------------ | Branch (204:20): [True: 3.13k, False: 1.95k] ------------------ 205| | // it is an element at global scope. Parse its value and go on 206| 3.13k| sz = buffer; 207| 46.8k| while (!IsSpaceOrNewLine(*buffer++)) { ------------------ | Branch (207:20): [True: 43.6k, False: 3.13k] ------------------ 208| 43.6k| if (buffer == bufferEnd) { ------------------ | Branch (208:21): [True: 2, False: 43.6k] ------------------ 209| 2| return false; 210| 2| } 211| 43.6k| } 212| 3.13k| out.mGlobalValue = std::string(sz, (uintptr_t)(buffer - sz)); 213| 3.13k| continue; 214| 3.13k| } 215| 1.95k| break; 216| 5.19k| } 217| 2.04k| if (buffer == bufferEnd) { ------------------ | Branch (217:9): [True: 0, False: 2.04k] ------------------ 218| 0| return false; 219| 0| } 220| 5.48k| while (IsSpaceOrNewLine(*buffer)) { ------------------ | Branch (220:12): [True: 3.44k, False: 2.04k] ------------------ 221| 3.44k| if (buffer == bufferEnd) { ------------------ | Branch (221:13): [True: 0, False: 3.44k] ------------------ 222| 0| break; 223| 0| } 224| 3.44k| ++buffer; 225| 3.44k| } 226| 2.04k| return '\0' != *buffer; 227| 2.04k|} _ZN6Assimp3MD513MD5MeshParserC2ERNSt3__16vectorINS0_7SectionENS2_9allocatorIS4_EEEE: 314| 7|MD5MeshParser::MD5MeshParser(SectionArray &mSections) { 315| 7| ASSIMP_LOG_DEBUG("MD5MeshParser begin"); 316| | 317| | // now parse all sections 318| 1.33k| for (SectionArray::const_iterator iter = mSections.begin(), iterEnd = mSections.end(); iter != iterEnd; ++iter) { ------------------ | Branch (318:92): [True: 1.33k, False: 7] ------------------ 319| 1.33k| if ((*iter).mName == "numMeshes") { ------------------ | Branch (319:13): [True: 0, False: 1.33k] ------------------ 320| 0| mMeshes.reserve(::strtoul10((*iter).mGlobalValue.c_str())); 321| 1.33k| } else if ((*iter).mName == "numJoints") { ------------------ | Branch (321:20): [True: 52, False: 1.27k] ------------------ 322| 52| mJoints.reserve(::strtoul10((*iter).mGlobalValue.c_str())); 323| 1.27k| } else if ((*iter).mName == "joints") { ------------------ | Branch (323:20): [True: 30, False: 1.24k] ------------------ 324| | // "origin" -1 ( -0.000000 0.016430 -0.006044 ) ( 0.707107 0.000000 0.707107 ) 325| 30| for (const auto &elem : (*iter).mElements) { ------------------ | Branch (325:35): [True: 2, False: 30] ------------------ 326| 2| mJoints.emplace_back(); 327| 2| BoneDesc &desc = mJoints.back(); 328| | 329| 2| const char *sz = elem.szStart; 330| 2| AI_MD5_PARSE_STRING_IN_QUOTATION(&sz, elem.end, desc.mName); 331| | 332| 2| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 333| | 334| | // negative values, at least -1, is allowed here 335| 2| desc.mParentIndex = (int)strtol10(sz, &sz); 336| | 337| 2| AI_MD5_READ_TRIPLE(desc.mPositionXYZ, &sz, elem.end, elem.iLineNumber); 338| 2| AI_MD5_READ_TRIPLE(desc.mRotationQuat, &sz, elem.end, elem.iLineNumber); // normalized quaternion, so w is not there 339| 2| } 340| 1.24k| } else if ((*iter).mName == "mesh") { ------------------ | Branch (340:20): [True: 61, False: 1.18k] ------------------ 341| 61| mMeshes.emplace_back(); 342| 61| MeshDesc &desc = mMeshes.back(); 343| | 344| 7.99k| for (const auto &elem : (*iter).mElements) { ------------------ | Branch (344:35): [True: 7.99k, False: 61] ------------------ 345| 7.99k| const char *sz = elem.szStart; 346| | 347| | // shader attribute 348| 7.99k| if (TokenMatch(sz, "shader", 6)) { ------------------ | Branch (348:21): [True: 52, False: 7.94k] ------------------ 349| 52| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 350| 52| AI_MD5_PARSE_STRING_IN_QUOTATION(&sz, elem.end, desc.mShader); 351| 52| } 352| | // numverts attribute 353| 7.94k| else if (TokenMatch(sz, "numverts", 8)) { ------------------ | Branch (353:26): [True: 0, False: 7.94k] ------------------ 354| 0| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 355| 0| desc.mVertices.resize(strtoul10(sz)); 356| 0| } 357| | // numtris attribute 358| 7.94k| else if (TokenMatch(sz, "numtris", 7)) { ------------------ | Branch (358:26): [True: 33, False: 7.91k] ------------------ 359| 33| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 360| 33| desc.mFaces.resize(strtoul10(sz)); 361| 33| } 362| | // numweights attribute 363| 7.91k| else if (TokenMatch(sz, "numweights", 10)) { ------------------ | Branch (363:26): [True: 2, False: 7.91k] ------------------ 364| 2| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 365| 2| desc.mWeights.resize(strtoul10(sz)); 366| 2| } 367| | // vert attribute 368| | // "vert 0 ( 0.394531 0.513672 ) 0 1" 369| 7.91k| else if (TokenMatch(sz, "vert", 4)) { ------------------ | Branch (369:26): [True: 44, False: 7.86k] ------------------ 370| 44| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 371| 44| const unsigned int idx = ::strtoul10(sz, &sz); 372| 44| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 373| 44| if (idx >= desc.mVertices.size()) ------------------ | Branch (373:25): [True: 32, False: 12] ------------------ 374| 32| desc.mVertices.resize(idx + 1); 375| | 376| 44| VertexDesc &vert = desc.mVertices[idx]; 377| 44| if ('(' != *sz++) ------------------ | Branch (377:25): [True: 44, False: 0] ------------------ 378| 44| MD5Parser::ReportWarning("Unexpected token: ( was expected", elem.iLineNumber); 379| 44| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 380| 44| sz = fast_atoreal_move(sz, vert.mUV.x); 381| 44| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 382| 44| sz = fast_atoreal_move(sz, vert.mUV.y); 383| 44| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 384| 44| if (')' != *sz++) ------------------ | Branch (384:25): [True: 44, False: 0] ------------------ 385| 44| MD5Parser::ReportWarning("Unexpected token: ) was expected", elem.iLineNumber); 386| 44| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 387| 44| vert.mFirstWeight = ::strtoul10(sz, &sz); 388| 44| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 389| 44| vert.mNumWeights = ::strtoul10(sz, &sz); 390| 44| } 391| | // tri attribute 392| | // "tri 0 15 13 12" 393| 7.86k| else if (TokenMatch(sz, "tri", 3)) { ------------------ | Branch (393:26): [True: 171, False: 7.69k] ------------------ 394| 171| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 395| 171| const unsigned int idx = strtoul10(sz, &sz); 396| 171| if (idx >= desc.mFaces.size()) { ------------------ | Branch (396:25): [True: 50, False: 121] ------------------ 397| 50| desc.mFaces.resize(idx + 1); 398| 50| } 399| | 400| 171| aiFace &face = desc.mFaces[idx]; 401| 171| if (face.mNumIndices != 3) { ------------------ | Branch (401:25): [True: 65, False: 106] ------------------ 402| 65| delete [] face.mIndices; 403| 65| face.mIndices = new unsigned int[face.mNumIndices = 3]; 404| 65| } 405| 684| for (unsigned int i = 0; i < 3; ++i) { ------------------ | Branch (405:46): [True: 513, False: 171] ------------------ 406| 513| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 407| 513| face.mIndices[i] = strtoul10(sz, &sz); 408| 513| } 409| 171| } 410| | // weight attribute 411| | // "weight 362 5 0.500000 ( -3.553583 11.893474 9.719339 )" 412| 7.69k| else if (TokenMatch(sz, "weight", 6)) { ------------------ | Branch (412:26): [True: 0, False: 7.69k] ------------------ 413| 0| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 414| 0| const unsigned int idx = strtoul10(sz, &sz); 415| 0| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 416| 0| if (idx >= desc.mWeights.size()) ------------------ | Branch (416:25): [True: 0, False: 0] ------------------ 417| 0| desc.mWeights.resize(idx + 1); 418| | 419| 0| WeightDesc &weight = desc.mWeights[idx]; 420| 0| weight.mBone = strtoul10(sz, &sz); 421| 0| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 422| 0| sz = fast_atoreal_move(sz, weight.mWeight); 423| 0| AI_MD5_READ_TRIPLE(weight.vOffsetPosition, &sz, elem.end, elem.iLineNumber); 424| 0| } 425| 7.99k| } 426| 61| } 427| 1.33k| } 428| | ASSIMP_LOG_DEBUG("MD5MeshParser end"); 429| 7|} _ZN6Assimp3MD513MD5AnimParserC2ERNSt3__16vectorINS0_7SectionENS2_9allocatorIS4_EEEE: 433| 5|MD5AnimParser::MD5AnimParser(SectionArray &mSections) { 434| 5| ASSIMP_LOG_DEBUG("MD5AnimParser begin"); 435| | 436| 5| fFrameRate = 24.0f; 437| 5| mNumAnimatedComponents = UINT_MAX; 438| 735| for (SectionArray::const_iterator iter = mSections.begin(), iterEnd = mSections.end(); iter != iterEnd; ++iter) { ------------------ | Branch (438:92): [True: 730, False: 5] ------------------ 439| 730| if ((*iter).mName == "hierarchy") { ------------------ | Branch (439:13): [True: 2, False: 728] ------------------ 440| | // "sheath" 0 63 6 441| 5.20k| for (const auto &elem : (*iter).mElements) { ------------------ | Branch (441:35): [True: 5.20k, False: 2] ------------------ 442| 5.20k| mAnimatedBones.emplace_back(); 443| 5.20k| AnimBoneDesc &desc = mAnimatedBones.back(); 444| | 445| 5.20k| const char *sz = elem.szStart; 446| 5.20k| AI_MD5_PARSE_STRING_IN_QUOTATION(&sz, elem.end, desc.mName); 447| 5.20k| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 448| | 449| | // parent index - negative values are allowed (at least -1) 450| 5.20k| desc.mParentIndex = ::strtol10(sz, &sz); 451| | 452| | // flags (highest is 2^6-1) 453| 5.20k| AI_MD5_SKIP_SPACES(&sz, elem.end, elem.iLineNumber); 454| 5.20k| if (63 < (desc.iFlags = ::strtoul10(sz, &sz))) { ------------------ | Branch (454:21): [True: 13, False: 5.18k] ------------------ 455| 13| MD5Parser::ReportWarning("Invalid flag combination in hierarchy section", elem.iLineNumber); 456| 13| } 457| 5.20k| AI_MD5_SKIP_SPACES(& sz, elem.end, elem.iLineNumber); 458| | 459| | // index of the first animation keyframe component for this joint 460| 5.20k| desc.iFirstKeyIndex = ::strtoul10(sz, &sz); 461| 5.20k| } 462| 728| } else if ((*iter).mName == "baseframe") { ------------------ | Branch (462:20): [True: 0, False: 728] ------------------ 463| | // ( -0.000000 0.016430 -0.006044 ) ( 0.707107 0.000242 0.707107 ) 464| 0| for (const auto &elem : (*iter).mElements) { ------------------ | Branch (464:35): [True: 0, False: 0] ------------------ 465| 0| const char *sz = elem.szStart; 466| | 467| 0| mBaseFrames.emplace_back(); 468| 0| BaseFrameDesc &desc = mBaseFrames.back(); 469| | 470| 0| AI_MD5_READ_TRIPLE(desc.vPositionXYZ, &sz, elem.end, elem.iLineNumber); 471| 0| AI_MD5_READ_TRIPLE(desc.vRotationQuat, &sz, elem.end, elem.iLineNumber); 472| 0| } 473| 728| } else if ((*iter).mName == "frame") { ------------------ | Branch (473:20): [True: 0, False: 728] ------------------ 474| 0| if (!(*iter).mGlobalValue.length()) { ------------------ | Branch (474:17): [True: 0, False: 0] ------------------ 475| 0| MD5Parser::ReportWarning("A frame section must have a frame index", (*iter).iLineNumber); 476| 0| continue; 477| 0| } 478| | 479| 0| mFrames.emplace_back(); 480| 0| FrameDesc &desc = mFrames.back(); 481| 0| desc.iIndex = strtoul10((*iter).mGlobalValue.c_str()); 482| | 483| | // we do already know how much storage we will presumably need 484| 0| if (UINT_MAX != mNumAnimatedComponents) { ------------------ | Branch (484:17): [True: 0, False: 0] ------------------ 485| 0| desc.mValues.reserve(mNumAnimatedComponents); 486| 0| } 487| | 488| | // now read all elements (continuous list of floats) 489| 0| for (const auto &elem : (*iter).mElements) { ------------------ | Branch (489:35): [True: 0, False: 0] ------------------ 490| 0| const char *sz = elem.szStart; 491| 0| while (SkipSpacesAndLineEnd(&sz, elem.end)) { ------------------ | Branch (491:24): [True: 0, False: 0] ------------------ 492| 0| float f; 493| 0| sz = fast_atoreal_move(sz, f); 494| 0| desc.mValues.push_back(f); 495| 0| } 496| 0| } 497| 728| } else if ((*iter).mName == "numFrames") { ------------------ | Branch (497:20): [True: 0, False: 728] ------------------ 498| 0| mFrames.reserve(strtoul10((*iter).mGlobalValue.c_str())); 499| 728| } else if ((*iter).mName == "numJoints") { ------------------ | Branch (499:20): [True: 0, False: 728] ------------------ 500| 0| const unsigned int num = strtoul10((*iter).mGlobalValue.c_str()); 501| 0| mAnimatedBones.reserve(num); 502| | 503| | // try to guess the number of animated components if that element is not given 504| 0| if (UINT_MAX == mNumAnimatedComponents) { ------------------ | Branch (504:17): [True: 0, False: 0] ------------------ 505| 0| mNumAnimatedComponents = num * 6; 506| 0| } 507| 728| } else if ((*iter).mName == "numAnimatedComponents") { ------------------ | Branch (507:20): [True: 0, False: 728] ------------------ 508| 0| mAnimatedBones.reserve(strtoul10((*iter).mGlobalValue.c_str())); 509| 728| } else if ((*iter).mName == "frameRate") { ------------------ | Branch (509:20): [True: 0, False: 728] ------------------ 510| 0| fast_atoreal_move((*iter).mGlobalValue.c_str(), fFrameRate); 511| 0| } 512| 730| } 513| | ASSIMP_LOG_DEBUG("MD5AnimParser end"); 514| 5|} _Z32AI_MD5_PARSE_STRING_IN_QUOTATIONPPKcS0_R8aiString: 289| 5.25k|inline void AI_MD5_PARSE_STRING_IN_QUOTATION(const char **sz, const char *bufferEnd, aiString &out) { 290| 5.25k| out.length = 0u; 291| 40.7k| while (('\"' != **sz && '\0' != **sz) && *sz != bufferEnd) { ------------------ | Branch (291:13): [True: 40.6k, False: 99] | Branch (291:29): [True: 35.5k, False: 5.15k] | Branch (291:46): [True: 35.5k, False: 0] ------------------ 292| 35.5k| ++*sz; 293| 35.5k| } 294| 5.25k| if ('\0' != **sz) { ------------------ | Branch (294:9): [True: 99, False: 5.15k] ------------------ 295| 99| const char *szStart = ++(*sz); 296| | 297| 1.00k| while (('\"' != **sz && '\0' != **sz) && *sz != bufferEnd) { ------------------ | Branch (297:17): [True: 933, False: 74] | Branch (297:33): [True: 908, False: 25] | Branch (297:50): [True: 908, False: 0] ------------------ 298| 908| ++*sz; 299| 908| } 300| 99| if ('\0' != **sz) { ------------------ | Branch (300:13): [True: 74, False: 25] ------------------ 301| 74| const char *szEnd = *sz; 302| 74| ++*sz; 303| 74| out.length = (ai_uint32)(szEnd - szStart); 304| 74| if (out.length >= AI_MAXLEN) ------------------ | Branch (304:17): [True: 0, False: 74] ------------------ 305| 0| out.length = AI_MAXLEN - 1; 306| 74| ::memcpy(out.data, szStart, out.length); 307| 74| } 308| 99| } 309| 5.25k| out.data[out.length] = '\0'; 310| 5.25k|} _Z18AI_MD5_SKIP_SPACESPPKcS0_i: 230| 16.6k|inline void AI_MD5_SKIP_SPACES(const char **sz, const char *bufferEnd, int linenumber) { 231| 16.6k| if (!SkipSpaces(sz, bufferEnd)) { ------------------ | Branch (231:9): [True: 15.5k, False: 1.08k] ------------------ 232| 15.5k| MD5Parser::ReportWarning("Unexpected end of line", linenumber); 233| 15.5k| } 234| 16.6k|} _Z18AI_MD5_READ_TRIPLER10aiVector3tIfEPPKcS3_i: 237| 2|inline void AI_MD5_READ_TRIPLE(aiVector3D &vec, const char **sz, const char *bufferEnd, int linenumber) { 238| 2| AI_MD5_SKIP_SPACES(sz, bufferEnd, linenumber); 239| 2| if ('(' != **sz) { ------------------ | Branch (239:9): [True: 2, False: 0] ------------------ 240| 2| MD5Parser::ReportWarning("Unexpected token: ( was expected", linenumber); 241| 2| if (*sz == bufferEnd) ------------------ | Branch (241:13): [True: 0, False: 2] ------------------ 242| 0| return; 243| 2| ++*sz; 244| 2| } 245| 2| if (*sz == bufferEnd) ------------------ | Branch (245:9): [True: 0, False: 2] ------------------ 246| 0| return; 247| 2| ++*sz; 248| 2| AI_MD5_SKIP_SPACES(sz, bufferEnd, linenumber); 249| 2| *sz = fast_atoreal_move(*sz, vec.x); 250| 2| AI_MD5_SKIP_SPACES(sz, bufferEnd, linenumber); 251| 2| *sz = fast_atoreal_move(*sz, vec.y); 252| 2| AI_MD5_SKIP_SPACES(sz, bufferEnd, linenumber); 253| 2| *sz = fast_atoreal_move(*sz, vec.z); 254| 2| AI_MD5_SKIP_SPACES(sz, bufferEnd, linenumber); 255| 2| if (')' != **sz) { ------------------ | Branch (255:9): [True: 0, False: 2] ------------------ 256| 0| MD5Parser::ReportWarning("Unexpected token: ) was expected", linenumber); 257| 0| } 258| 2| if (*sz == bufferEnd) ------------------ | Branch (258:9): [True: 0, False: 2] ------------------ 259| 0| return; 260| 2| ++*sz; 261| 2|} _ZN6Assimp3MD510VertexDescC2Ev: 189| 160| : mFirstWeight(0), mNumWeights(0) { 190| | // empty 191| 160| } _ZN6Assimp3MD59MD5Parser8SkipLineEPKcPS3_: 409| 12|inline bool MD5Parser::SkipLine(const char* in, const char** out) { 410| 12| ++lineNumber; 411| 12| return Assimp::SkipLine(in, out, bufferEnd); 412| 12|} _ZN6Assimp3MD59MD5Parser8SkipLineEv: 415| 12|inline bool MD5Parser::SkipLine( ) { 416| 12| return SkipLine(buffer,(const char**)&buffer); 417| 12|} _ZN6Assimp3MD59MD5Parser20SkipSpacesAndLineEndEPKcPS3_: 420| 12|inline bool MD5Parser::SkipSpacesAndLineEnd( const char* in, const char** out) { 421| 12| if (in == bufferEnd) { ------------------ | Branch (421:9): [True: 0, False: 12] ------------------ 422| 0| *out = in; 423| 0| return false; 424| 0| } 425| | 426| 12| bool bHad = false, running = true; 427| 12| while (running) { ------------------ | Branch (427:12): [True: 12, False: 0] ------------------ 428| 12| if( *in == '\r' || *in == '\n') { ------------------ | Branch (428:13): [True: 0, False: 12] | Branch (428:28): [True: 0, False: 12] ------------------ 429| | // we open files in binary mode, so there could be \r\n sequences ... 430| 0| if (!bHad) { ------------------ | Branch (430:17): [True: 0, False: 0] ------------------ 431| 0| bHad = true; 432| 0| ++lineNumber; 433| 0| } 434| 12| } else if (*in == '\t' || *in == ' ') { ------------------ | Branch (434:20): [True: 0, False: 12] | Branch (434:35): [True: 0, False: 12] ------------------ 435| 0| bHad = false; 436| 12| } else { 437| 12| break; 438| 12| } 439| 0| ++in; 440| 0| if (in == bufferEnd) { ------------------ | Branch (440:13): [True: 0, False: 0] ------------------ 441| 0| break; 442| 0| } 443| 0| } 444| 12| *out = in; 445| 12| return *in != '\0'; 446| 12|} _ZN6Assimp3MD59MD5Parser20SkipSpacesAndLineEndEv: 449| 12|inline bool MD5Parser::SkipSpacesAndLineEnd() { 450| 12| return SkipSpacesAndLineEnd(buffer,(const char**)&buffer); 451| 12|} _ZN6Assimp3MD59MD5Parser10SkipSpacesEv: 454| 24|inline bool MD5Parser::SkipSpaces() { 455| 24| return Assimp::SkipSpaces((const char**)&buffer, bufferEnd); 456| 24|} _ZN6Assimp11MDCImporterC2Ev: 102| 624| fileSize() { 103| | // empty 104| 624|} _ZNK6Assimp11MDCImporter7CanReadERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPNS_8IOSystemEb: 108| 410|bool MDCImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { 109| 410| static constexpr uint32_t tokens[] = { AI_MDC_MAGIC_NUMBER_LE }; ------------------ | | 65| 410|#define AI_MDC_MAGIC_NUMBER_LE AI_MAKE_MAGIC("IDPC") ------------------ 110| | return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); 111| 410|} _ZNK6Assimp11MDCImporter7GetInfoEv: 114| 635|const aiImporterDesc *MDCImporter::GetInfo() const { 115| 635| return &desc; 116| 635|} _ZN6Assimp11MDCImporter14ValidateHeaderEv: 120| 1|void MDCImporter::ValidateHeader() { 121| 1| AI_SWAP4(this->pcHeader->ulVersion); 122| 1| AI_SWAP4(this->pcHeader->ulFlags); 123| 1| AI_SWAP4(this->pcHeader->ulNumFrames); 124| 1| AI_SWAP4(this->pcHeader->ulNumTags); 125| 1| AI_SWAP4(this->pcHeader->ulNumSurfaces); 126| 1| AI_SWAP4(this->pcHeader->ulNumSkins); 127| 1| AI_SWAP4(this->pcHeader->ulOffsetBorderFrames); 128| | 129| 1| if (pcHeader->ulIdent != AI_MDC_MAGIC_NUMBER_BE && ------------------ | | 64| 1|#define AI_MDC_MAGIC_NUMBER_BE AI_MAKE_MAGIC("CPDI") ------------------ | Branch (129:9): [True: 0, False: 1] ------------------ 130| 0| pcHeader->ulIdent != AI_MDC_MAGIC_NUMBER_LE) { ------------------ | | 65| 0|#define AI_MDC_MAGIC_NUMBER_LE AI_MAKE_MAGIC("IDPC") ------------------ | Branch (130:13): [True: 0, False: 0] ------------------ 131| 0| throw DeadlyImportError("Invalid MDC magic word: expected IDPC, found ", 132| 0| ai_str_toprintable((char *)&pcHeader->ulIdent, 4)); 133| 0| } 134| | 135| 1| if (pcHeader->ulVersion != AI_MDC_VERSION) { ------------------ | | 68| 1|#define AI_MDC_VERSION 2 ------------------ | Branch (135:9): [True: 0, False: 1] ------------------ 136| 0| ASSIMP_LOG_WARN("Unsupported MDC file version (2 (AI_MDC_VERSION) was expected)"); 137| 0| } 138| | 139| 1| if (pcHeader->ulOffsetBorderFrames + pcHeader->ulNumFrames * sizeof(MDC::Frame) > this->fileSize || ------------------ | Branch (139:9): [True: 0, False: 1] ------------------ 140| 1| pcHeader->ulOffsetSurfaces + pcHeader->ulNumSurfaces * sizeof(MDC::Surface) > this->fileSize) { ------------------ | Branch (140:13): [True: 0, False: 1] ------------------ 141| 0| throw DeadlyImportError("Some of the offset values in the MDC header are invalid " 142| 0| "and point to something behind the file."); 143| 0| } 144| | 145| 1| if (this->configFrameID >= this->pcHeader->ulNumFrames) { ------------------ | Branch (145:9): [True: 0, False: 1] ------------------ 146| 0| throw DeadlyImportError("The requested frame is not available"); 147| 0| } 148| 1|} _ZN6Assimp11MDCImporter21ValidateSurfaceHeaderEPKNS_3MDC7SurfaceE: 152| 19|void MDCImporter::ValidateSurfaceHeader(BE_NCONST MDC::Surface *pcSurf) { 153| 19| AI_SWAP4(pcSurf->ulFlags); 154| 19| AI_SWAP4(pcSurf->ulNumCompFrames); 155| 19| AI_SWAP4(pcSurf->ulNumBaseFrames); 156| 19| AI_SWAP4(pcSurf->ulNumShaders); 157| 19| AI_SWAP4(pcSurf->ulNumVertices); 158| 19| AI_SWAP4(pcSurf->ulNumTriangles); 159| 19| AI_SWAP4(pcSurf->ulOffsetTriangles); 160| 19| AI_SWAP4(pcSurf->ulOffsetTexCoords); 161| 19| AI_SWAP4(pcSurf->ulOffsetBaseVerts); 162| 19| AI_SWAP4(pcSurf->ulOffsetCompVerts); 163| 19| AI_SWAP4(pcSurf->ulOffsetShaders); 164| 19| AI_SWAP4(pcSurf->ulOffsetFrameBaseFrames); 165| 19| AI_SWAP4(pcSurf->ulOffsetFrameCompFrames); 166| 19| AI_SWAP4(pcSurf->ulOffsetEnd); 167| | 168| 19| const unsigned int iMax = this->fileSize - (unsigned int)((int8_t *)pcSurf - (int8_t *)pcHeader); 169| | 170| 19| if (pcSurf->ulOffsetBaseVerts + pcSurf->ulNumVertices * sizeof(MDC::BaseVertex) > iMax || ------------------ | Branch (170:9): [True: 0, False: 19] ------------------ 171| 19| (pcSurf->ulNumCompFrames && pcSurf->ulOffsetCompVerts + pcSurf->ulNumVertices * sizeof(MDC::CompressedVertex) > iMax) || ------------------ | Branch (171:14): [True: 19, False: 0] | Branch (171:41): [True: 0, False: 19] ------------------ 172| 19| pcSurf->ulOffsetTriangles + pcSurf->ulNumTriangles * sizeof(MDC::Triangle) > iMax || ------------------ | Branch (172:13): [True: 0, False: 19] ------------------ 173| 19| pcSurf->ulOffsetTexCoords + pcSurf->ulNumVertices * sizeof(MDC::TexturCoord) > iMax || ------------------ | Branch (173:13): [True: 0, False: 19] ------------------ 174| 19| pcSurf->ulOffsetShaders + pcSurf->ulNumShaders * sizeof(MDC::Shader) > iMax || ------------------ | Branch (174:13): [True: 0, False: 19] ------------------ 175| 19| pcSurf->ulOffsetFrameBaseFrames + pcSurf->ulNumBaseFrames * 2 > iMax || ------------------ | Branch (175:13): [True: 0, False: 19] ------------------ 176| 19| (pcSurf->ulNumCompFrames && pcSurf->ulOffsetFrameCompFrames + pcSurf->ulNumCompFrames * 2 > iMax) || ------------------ | Branch (176:14): [True: 19, False: 0] | Branch (176:41): [True: 0, False: 19] ------------------ 177| 19| pcSurf->ulOffsetEnd > iMax) { ------------------ | Branch (177:13): [True: 0, False: 19] ------------------ 178| 0| throw DeadlyImportError("Some of the offset values in the MDC surface header " 179| 0| "are invalid and point somewhere behind the file."); 180| 0| } 181| 19|} _ZN6Assimp11MDCImporter15SetupPropertiesEPKNS_8ImporterE: 185| 1|void MDCImporter::SetupProperties(const Importer *pImp) { 186| | // The AI_CONFIG_IMPORT_MDC_KEYFRAME option overrides the 187| | // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option. 188| 1| if (static_cast(-1) == (configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MDC_KEYFRAME, -1))) { ------------------ | Branch (188:9): [True: 1, False: 0] ------------------ 189| | configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0); 190| 1| } 191| 1|} _ZN6Assimp11MDCImporter14InternReadFileERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEP7aiScenePNS_8IOSystemE: 196| 1| const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { 197| 1| std::unique_ptr file(pIOHandler->Open(pFile)); 198| | 199| | // Check whether we can read from the file 200| 1| if (file == nullptr) { ------------------ | Branch (200:9): [True: 0, False: 1] ------------------ 201| 0| throw DeadlyImportError("Failed to open MDC file ", pFile, "."); 202| 0| } 203| | 204| | // check whether the mdc file is large enough to contain the file header 205| 1| fileSize = static_cast(file->FileSize()); 206| 1| if (fileSize < sizeof(MDC::Header)) { ------------------ | Branch (206:9): [True: 0, False: 1] ------------------ 207| 0| throw DeadlyImportError("MDC File is too small."); 208| 0| } 209| | 210| 1| std::vector mBuffer2(fileSize); 211| 1| file->Read(&mBuffer2[0], 1, fileSize); 212| 1| mBuffer = &mBuffer2[0]; 213| | 214| | // validate the file header 215| 1| this->pcHeader = (BE_NCONST MDC::Header *)this->mBuffer; 216| 1| this->ValidateHeader(); 217| | 218| 1| std::vector aszShaders; 219| | 220| | // get a pointer to the frame we want to read 221| 1| BE_NCONST MDC::Frame *pcFrame = (BE_NCONST MDC::Frame *)(this->mBuffer + 222| 1| this->pcHeader->ulOffsetBorderFrames); 223| | 224| | // no need to swap the other members, we won't need them 225| 1| pcFrame += configFrameID; 226| 1| AI_SWAP4(pcFrame->localOrigin[0]); 227| 1| AI_SWAP4(pcFrame->localOrigin[1]); 228| 1| AI_SWAP4(pcFrame->localOrigin[2]); 229| | 230| | // get the number of valid surfaces 231| 1| BE_NCONST MDC::Surface *pcSurface, *pcSurface2; 232| 1| pcSurface = pcSurface2 = reinterpret_cast(mBuffer + pcHeader->ulOffsetSurfaces); 233| 1| unsigned int iNumShaders = 0; 234| 20| for (unsigned int i = 0; i < pcHeader->ulNumSurfaces; ++i) { ------------------ | Branch (234:30): [True: 19, False: 1] ------------------ 235| | // validate the surface header 236| 19| this->ValidateSurfaceHeader(pcSurface2); 237| | 238| 19| if (pcSurface2->ulNumVertices && pcSurface2->ulNumTriangles) { ------------------ | Branch (238:13): [True: 19, False: 0] | Branch (238:42): [True: 19, False: 0] ------------------ 239| 19| ++pScene->mNumMeshes; 240| 19| } 241| 19| iNumShaders += pcSurface2->ulNumShaders; 242| 19| pcSurface2 = reinterpret_cast((BE_NCONST int8_t *)pcSurface2 + pcSurface2->ulOffsetEnd); 243| 19| } 244| 1| aszShaders.reserve(iNumShaders); 245| 1| pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]; 246| | 247| | // necessary that we don't crash if an exception occurs 248| 20| for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) { ------------------ | Branch (248:30): [True: 19, False: 1] ------------------ 249| 19| pScene->mMeshes[i] = nullptr; 250| 19| } 251| | 252| | // now read all surfaces 253| 1| unsigned int iDefaultMatIndex = UINT_MAX; 254| 20| for (unsigned int i = 0, iNum = 0; i < pcHeader->ulNumSurfaces; ++i) { ------------------ | Branch (254:40): [True: 19, False: 1] ------------------ 255| 19| if (!pcSurface->ulNumVertices || !pcSurface->ulNumTriangles) continue; ------------------ | Branch (255:13): [True: 0, False: 19] | Branch (255:42): [True: 0, False: 19] ------------------ 256| 19| aiMesh *pcMesh = pScene->mMeshes[iNum++] = new aiMesh(); 257| | 258| 19| pcMesh->mNumFaces = pcSurface->ulNumTriangles; 259| 19| pcMesh->mNumVertices = pcMesh->mNumFaces * 3; 260| | 261| | // store the name of the surface for use as node name. 262| 19| pcMesh->mName.Set(std::string(pcSurface->ucName, strnlen(pcSurface->ucName, AI_MDC_MAXQPATH - 1))); ------------------ | | 69| 19|#define AI_MDC_MAXQPATH 64 ------------------ 263| | 264| | // go to the first shader in the file. ignore the others. 265| 19| if (pcSurface->ulNumShaders) { ------------------ | Branch (265:13): [True: 19, False: 0] ------------------ 266| 19| const MDC::Shader *pcShader = (const MDC::Shader *)((int8_t *)pcSurface + pcSurface->ulOffsetShaders); 267| 19| pcMesh->mMaterialIndex = (unsigned int)aszShaders.size(); 268| | 269| | // create a new shader 270| 19| aszShaders.emplace_back(pcShader->ucName, 271| 19| ::strnlen(pcShader->ucName, sizeof(pcShader->ucName))); 272| 19| } 273| | // need to create a default material 274| 0| else if (UINT_MAX == iDefaultMatIndex) { ------------------ | Branch (274:18): [True: 0, False: 0] ------------------ 275| 0| pcMesh->mMaterialIndex = iDefaultMatIndex = (unsigned int)aszShaders.size(); 276| 0| aszShaders.emplace_back(); 277| 0| } 278| | // otherwise assign a reference to the default material 279| 0| else 280| 0| pcMesh->mMaterialIndex = iDefaultMatIndex; 281| | 282| | // allocate output storage for the mesh 283| 19| aiVector3D *pcVertCur = pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices]; 284| 19| aiVector3D *pcNorCur = pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices]; 285| 19| aiVector3D *pcUVCur = pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices]; 286| 19| aiFace *pcFaceCur = pcMesh->mFaces = new aiFace[pcMesh->mNumFaces]; 287| | 288| | // create all vertices/faces 289| 19| BE_NCONST MDC::Triangle *pcTriangle = (BE_NCONST MDC::Triangle *)((int8_t *)pcSurface + pcSurface->ulOffsetTriangles); 290| | 291| 19| BE_NCONST MDC::TexturCoord *const pcUVs = (BE_NCONST MDC::TexturCoord *)((int8_t *)pcSurface + pcSurface->ulOffsetTexCoords); 292| | 293| | // get a pointer to the uncompressed vertices 294| 19| int16_t iOfs = *((int16_t *)((int8_t *)pcSurface + 295| 19| pcSurface->ulOffsetFrameBaseFrames) + 296| 19| this->configFrameID); 297| | 298| 19| AI_SWAP2(iOfs); 299| | 300| 19| BE_NCONST MDC::BaseVertex *const pcVerts = (BE_NCONST MDC::BaseVertex *)((int8_t *)pcSurface + pcSurface->ulOffsetBaseVerts) + 301| 19| ((int)iOfs * pcSurface->ulNumVertices * 4); 302| | 303| | // do the main swapping stuff ... 304| |#if (defined AI_BUILD_BIG_ENDIAN) 305| | 306| | // swap all triangles 307| | for (unsigned int i = 0; i < pcSurface->ulNumTriangles; ++i) { 308| | AI_SWAP4(pcTriangle[i].aiIndices[0]); 309| | AI_SWAP4(pcTriangle[i].aiIndices[1]); 310| | AI_SWAP4(pcTriangle[i].aiIndices[2]); 311| | } 312| | 313| | // swap all vertices 314| | for (unsigned int i = 0; i < pcSurface->ulNumVertices * pcSurface->ulNumBaseFrames; ++i) { 315| | AI_SWAP2(pcVerts->normal); 316| | AI_SWAP2(pcVerts->x); 317| | AI_SWAP2(pcVerts->y); 318| | AI_SWAP2(pcVerts->z); 319| | } 320| | 321| | // swap all texture coordinates 322| | for (unsigned int i = 0; i < pcSurface->ulNumVertices; ++i) { 323| | AI_SWAP4(pcUVs->u); 324| | AI_SWAP4(pcUVs->v); 325| | } 326| | 327| |#endif 328| | 329| | // boundary check for pcVerts 330| 19| auto surfStart = reinterpret_cast(pcSurface); 331| 19| const uint8_t* surfEnd = surfStart + pcSurface->ulOffsetEnd; 332| 19| auto vertBufStart = reinterpret_cast(pcVerts); 333| 19| const size_t needVertBytes = sizeof(MDC::BaseVertex) * pcSurface->ulNumVertices; 334| 19| if (vertBufStart < surfStart || vertBufStart + needVertBytes > surfEnd) { ------------------ | Branch (334:13): [True: 0, False: 19] | Branch (334:41): [True: 0, False: 19] ------------------ 335| 0| throw DeadlyImportError("MDCImporter: pcVerts points outside of surface block."); 336| 0| } 337| | 338| 19| const MDC::CompressedVertex *pcCVerts = nullptr; 339| 19| int16_t *mdcCompVert = nullptr; 340| | 341| | // access compressed frames for large frame numbers, but never for the first 342| 19| if (this->configFrameID && pcSurface->ulNumCompFrames > 0) { ------------------ | Branch (342:13): [True: 0, False: 19] | Branch (342:36): [True: 0, False: 0] ------------------ 343| 0| mdcCompVert = (int16_t *)((int8_t *)pcSurface + pcSurface->ulOffsetFrameCompFrames) + this->configFrameID; 344| 0| AI_SWAP2P(mdcCompVert); 345| 0| if (*mdcCompVert >= 0) { ------------------ | Branch (345:17): [True: 0, False: 0] ------------------ 346| 0| pcCVerts = (const MDC::CompressedVertex *)((int8_t *)pcSurface + 347| 0| pcSurface->ulOffsetCompVerts) + 348| 0| *mdcCompVert * pcSurface->ulNumVertices; 349| 0| auto cvertBufStart = reinterpret_cast(pcCVerts); 350| 0| const size_t needCompVertBytes = sizeof(MDC::CompressedVertex) * pcSurface->ulNumVertices; 351| 0| if (cvertBufStart < surfStart || cvertBufStart > surfEnd || ------------------ | Branch (351:21): [True: 0, False: 0] | Branch (351:50): [True: 0, False: 0] ------------------ 352| 0| needCompVertBytes > static_cast(surfEnd - cvertBufStart)) { ------------------ | Branch (352:21): [True: 0, False: 0] ------------------ 353| 0| throw DeadlyImportError("MDCImporter: pcCVerts points outside of surface block."); 354| 0| } 355| 0| } else 356| 0| mdcCompVert = nullptr; 357| 0| } 358| | 359| | // copy all faces 360| 1.38k| for (unsigned int iFace = 0; iFace < pcSurface->ulNumTriangles; ++iFace, ------------------ | Branch (360:38): [True: 1.36k, False: 19] ------------------ 361| 1.36k| ++pcTriangle, ++pcFaceCur) { 362| 1.36k| const unsigned int iOutIndex = iFace * 3; 363| 1.36k| pcFaceCur->mNumIndices = 3; 364| 1.36k| pcFaceCur->mIndices = new unsigned int[3]; 365| | 366| 5.47k| for (unsigned int iIndex = 0; iIndex < 3; ++iIndex, ------------------ | Branch (366:43): [True: 4.10k, False: 1.36k] ------------------ 367| 4.10k| ++pcVertCur, ++pcUVCur, ++pcNorCur) { 368| 4.10k| uint32_t quak = pcTriangle->aiIndices[iIndex]; 369| 4.10k| if (quak >= pcSurface->ulNumVertices) { ------------------ | Branch (369:21): [True: 0, False: 4.10k] ------------------ 370| 0| ASSIMP_LOG_ERROR("MDC vertex index is out of range"); 371| 0| quak = pcSurface->ulNumVertices - 1; 372| 0| } 373| | 374| | // compressed vertices? 375| 4.10k| if (mdcCompVert) { ------------------ | Branch (375:21): [True: 0, False: 4.10k] ------------------ 376| 0| MDC::BuildVertex(*pcFrame, pcVerts[quak], pcCVerts[quak], 377| 0| *pcVertCur, *pcNorCur); 378| 4.10k| } else { 379| | // copy position 380| 4.10k| pcVertCur->x = pcVerts[quak].x * AI_MDC_BASE_SCALING; ------------------ | | 74| 4.10k|#define AI_MDC_BASE_SCALING (1.0f / 64.0f) ------------------ 381| 4.10k| pcVertCur->y = pcVerts[quak].y * AI_MDC_BASE_SCALING; ------------------ | | 74| 4.10k|#define AI_MDC_BASE_SCALING (1.0f / 64.0f) ------------------ 382| 4.10k| pcVertCur->z = pcVerts[quak].z * AI_MDC_BASE_SCALING; ------------------ | | 74| 4.10k|#define AI_MDC_BASE_SCALING (1.0f / 64.0f) ------------------ 383| | 384| | // copy normals 385| 4.10k| MD3::LatLngNormalToVec3(pcVerts[quak].normal, &pcNorCur->x); 386| | 387| | // copy texture coordinates 388| 4.10k| pcUVCur->x = pcUVs[quak].u; 389| 4.10k| pcUVCur->y = ai_real(1.0) - pcUVs[quak].v; // DX to OGL 390| 4.10k| } 391| 4.10k| pcVertCur->x += pcFrame->localOrigin[0]; 392| 4.10k| pcVertCur->y += pcFrame->localOrigin[1]; 393| 4.10k| pcVertCur->z += pcFrame->localOrigin[2]; 394| 4.10k| } 395| | 396| | // swap the face order - DX to OGL 397| 1.36k| pcFaceCur->mIndices[0] = iOutIndex + 2; 398| 1.36k| pcFaceCur->mIndices[1] = iOutIndex + 1; 399| 1.36k| pcFaceCur->mIndices[2] = iOutIndex + 0; 400| 1.36k| } 401| | 402| 19| pcSurface = reinterpret_cast((BE_NCONST int8_t *)pcSurface + pcSurface->ulOffsetEnd); 403| 19| } 404| | 405| | // create a flat node graph with a root node and one child for each surface 406| 1| if (!pScene->mNumMeshes) ------------------ | Branch (406:9): [True: 0, False: 1] ------------------ 407| 0| throw DeadlyImportError("Invalid MDC file: File contains no valid mesh"); 408| 1| else if (1 == pScene->mNumMeshes) { ------------------ | Branch (408:14): [True: 0, False: 1] ------------------ 409| 0| pScene->mRootNode = new aiNode(); 410| 0| if (nullptr != pScene->mMeshes[0]) { ------------------ | Branch (410:13): [True: 0, False: 0] ------------------ 411| 0| pScene->mRootNode->mName = pScene->mMeshes[0]->mName; 412| 0| pScene->mRootNode->mNumMeshes = 1; 413| 0| pScene->mRootNode->mMeshes = new unsigned int[1]; 414| 0| pScene->mRootNode->mMeshes[0] = 0; 415| 0| } 416| 1| } else { 417| 1| pScene->mRootNode = new aiNode(); 418| 1| pScene->mRootNode->mNumChildren = pScene->mNumMeshes; 419| 1| pScene->mRootNode->mChildren = new aiNode *[pScene->mNumMeshes]; 420| 1| pScene->mRootNode->mName.Set(""); 421| 20| for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) { ------------------ | Branch (421:34): [True: 19, False: 1] ------------------ 422| 19| aiNode *pcNode = pScene->mRootNode->mChildren[i] = new aiNode(); 423| 19| pcNode->mParent = pScene->mRootNode; 424| 19| pcNode->mName = pScene->mMeshes[i]->mName; 425| 19| pcNode->mNumMeshes = 1; 426| 19| pcNode->mMeshes = new unsigned int[1]; 427| 19| pcNode->mMeshes[0] = i; 428| 19| } 429| 1| } 430| | 431| | // create materials 432| 1| pScene->mNumMaterials = (unsigned int)aszShaders.size(); 433| 1| pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials]; 434| 20| for (unsigned int i = 0; i < pScene->mNumMaterials; ++i) { ------------------ | Branch (434:30): [True: 19, False: 1] ------------------ 435| 19| aiMaterial *pcMat = new aiMaterial(); 436| 19| pScene->mMaterials[i] = pcMat; 437| | 438| 19| const std::string &name = aszShaders[i]; 439| | 440| 19| int iMode = (int)aiShadingMode_Gouraud; 441| 19| pcMat->AddProperty(&iMode, 1, AI_MATKEY_SHADING_MODEL); 442| | 443| | // add a small ambient color value - RtCW seems to have one 444| 19| aiColor3D clr; 445| 19| clr.b = clr.g = clr.r = 0.05f; 446| 19| pcMat->AddProperty(&clr, 1, AI_MATKEY_COLOR_AMBIENT); 447| | 448| 19| if (name.length()) ------------------ | Branch (448:13): [True: 19, False: 0] ------------------ 449| 19| clr.b = clr.g = clr.r = 1.0f; 450| 0| else 451| 0| clr.b = clr.g = clr.r = 0.6f; 452| | 453| 19| pcMat->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE); 454| 19| pcMat->AddProperty(&clr, 1, AI_MATKEY_COLOR_SPECULAR); 455| | 456| 19| if (name.length()) { ------------------ | Branch (456:13): [True: 19, False: 0] ------------------ 457| 19| aiString path; 458| 19| path.Set(name); 459| 19| pcMat->AddProperty(&path, AI_MATKEY_TEXTURE_DIFFUSE(0)); 460| 19| } 461| 19| } 462| | 463| | // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system 464| 1| pScene->mRootNode->mTransformation = aiMatrix4x4( 465| 1| 1.f, 0.f, 0.f, 0.f, 466| 1| 0.f, 0.f, 1.f, 0.f, 467| 1| 0.f, -1.f, 0.f, 0.f, 468| 1| 0.f, 0.f, 0.f, 1.f); 469| 1|} _ZN6Assimp3MDL8HalfLife13HL1DataBufferC2Ev: 70| 31| HL1DataBuffer() AI_NO_EXCEPT : data_(nullptr), 71| 31| length_(0), 72| 31| owner_(nullptr) {} _ZN6Assimp3MDL8HalfLife13HL1DataBufferaSEOS2_: 90| 13| HL1DataBuffer &operator=(HL1DataBuffer &&other) AI_NO_EXCEPT { 91| 13| if (this != &other) { ------------------ | Branch (91:13): [True: 13, False: 0] ------------------ 92| 13| data_ = other.data_; 93| 13| length_ = other.length_; 94| 13| owner_ = std::move(other.owner_); 95| | 96| 13| other.data_ = nullptr; 97| 13| other.length_ = 0; 98| 13| other.owner_ = nullptr; 99| 13| } 100| | 101| 13| return *this; 102| 13| } _ZN6Assimp3MDL8HalfLife13HL1DataBuffer4viewEPKhm: 110| 4| static HL1DataBuffer view(const unsigned char *data, size_t length) { 111| 4| HL1DataBuffer b; 112| 4| b.data_ = data; 113| 4| b.length_ = length; 114| 4| b.owner_ = nullptr; 115| 4| return b; 116| 4| } _ZN6Assimp3MDL8HalfLife13HL1DataBuffer4viewERKS2_: 123| 4| static HL1DataBuffer view(const HL1DataBuffer &other) { 124| 4| HL1DataBuffer b; 125| 4| b.data_ = other.data_; 126| 4| b.length_ = other.length_; 127| 4| b.owner_ = nullptr; 128| 4| return b; 129| 4| } _ZN6Assimp3MDL8HalfLife13HL1DataBuffer6owningENSt3__110unique_ptrIA_hNS3_14default_deleteIS5_EEEEm: 137| 9| static HL1DataBuffer owning(std::unique_ptr buffer, size_t length) { 138| 9| HL1DataBuffer b; 139| 9| b.data_ = buffer.get(); 140| 9| b.length_ = length; 141| 9| b.owner_ = std::move(buffer); 142| 9| return b; 143| 9| } _ZNK6Assimp3MDL8HalfLife13HL1DataBuffer8get_dataINS1_10Header_HL1EEEPKT_ii: 154| 8| const DataType *get_data(int offset, int elements) const { 155| 8| if (offset < 0 || elements < 0) { ------------------ | Branch (155:13): [True: 0, False: 8] | Branch (155:27): [True: 0, False: 8] ------------------ 156| 0| throw DeadlyImportError("MDL file contains invalid data"); 157| 0| } 158| | 159| 8| const size_t uoffset = static_cast(offset); 160| 8| const size_t uelements = static_cast(elements); 161| | 162| 8| if (uoffset > length_ || uelements > (length_ - uoffset) / sizeof(DataType)) { ------------------ | Branch (162:13): [True: 0, False: 8] | Branch (162:34): [True: 0, False: 8] ------------------ 163| 0| throw DeadlyImportError("MDL file contains invalid data"); 164| 0| } 165| | 166| 8| return reinterpret_cast(data_ + uoffset); 167| 8| } _ZNK6Assimp3MDL8HalfLife13HL1DataBuffer8get_dataINS1_18SequenceHeader_HL1EEEPKT_ii: 154| 9| const DataType *get_data(int offset, int elements) const { 155| 9| if (offset < 0 || elements < 0) { ------------------ | Branch (155:13): [True: 0, False: 9] | Branch (155:27): [True: 0, False: 9] ------------------ 156| 0| throw DeadlyImportError("MDL file contains invalid data"); 157| 0| } 158| | 159| 9| const size_t uoffset = static_cast(offset); 160| 9| const size_t uelements = static_cast(elements); 161| | 162| 9| if (uoffset > length_ || uelements > (length_ - uoffset) / sizeof(DataType)) { ------------------ | Branch (162:13): [True: 0, False: 9] | Branch (162:34): [True: 0, False: 9] ------------------ 163| 0| throw DeadlyImportError("MDL file contains invalid data"); 164| 0| } 165| | 166| 9| return reinterpret_cast(data_ + uoffset); 167| 9| } _ZNK6Assimp3MDL8HalfLife13HL1DataBuffer8get_dataINS1_11Texture_HL1EEEPKT_ii: 154| 8| const DataType *get_data(int offset, int elements) const { 155| 8| if (offset < 0 || elements < 0) { ------------------ | Branch (155:13): [True: 0, False: 8] | Branch (155:27): [True: 0, False: 8] ------------------ 156| 0| throw DeadlyImportError("MDL file contains invalid data"); 157| 0| } 158| | 159| 8| const size_t uoffset = static_cast(offset); 160| 8| const size_t uelements = static_cast(elements); 161| | 162| 8| if (uoffset > length_ || uelements > (length_ - uoffset) / sizeof(DataType)) { ------------------ | Branch (162:13): [True: 0, False: 8] | Branch (162:34): [True: 0, False: 8] ------------------ 163| 0| throw DeadlyImportError("MDL file contains invalid data"); 164| 0| } 165| | 166| 8| return reinterpret_cast(data_ + uoffset); 167| 8| } _ZNK6Assimp3MDL8HalfLife13HL1DataBuffer8get_dataIhEEPKT_ii: 154| 14| const DataType *get_data(int offset, int elements) const { 155| 14| if (offset < 0 || elements < 0) { ------------------ | Branch (155:13): [True: 0, False: 14] | Branch (155:27): [True: 0, False: 14] ------------------ 156| 0| throw DeadlyImportError("MDL file contains invalid data"); 157| 0| } 158| | 159| 14| const size_t uoffset = static_cast(offset); 160| 14| const size_t uelements = static_cast(elements); 161| | 162| 14| if (uoffset > length_ || uelements > (length_ - uoffset) / sizeof(DataType)) { ------------------ | Branch (162:13): [True: 0, False: 14] | Branch (162:34): [True: 0, False: 14] ------------------ 163| 0| throw DeadlyImportError("MDL file contains invalid data"); 164| 0| } 165| | 166| 14| return reinterpret_cast(data_ + uoffset); 167| 14| } _ZNK6Assimp3MDL8HalfLife13HL1DataBuffer8get_dataIsEEPKT_ii: 154| 4| const DataType *get_data(int offset, int elements) const { 155| 4| if (offset < 0 || elements < 0) { ------------------ | Branch (155:13): [True: 0, False: 4] | Branch (155:27): [True: 0, False: 4] ------------------ 156| 0| throw DeadlyImportError("MDL file contains invalid data"); 157| 0| } 158| | 159| 4| const size_t uoffset = static_cast(offset); 160| 4| const size_t uelements = static_cast(elements); 161| | 162| 4| if (uoffset > length_ || uelements > (length_ - uoffset) / sizeof(DataType)) { ------------------ | Branch (162:13): [True: 0, False: 4] | Branch (162:34): [True: 0, False: 4] ------------------ 163| 0| throw DeadlyImportError("MDL file contains invalid data"); 164| 0| } 165| | 166| 4| return reinterpret_cast(data_ + uoffset); 167| 4| } _ZNK6Assimp3MDL8HalfLife13HL1DataBuffer8get_dataINS1_8Bone_HL1EEEPKT_ii: 154| 9| const DataType *get_data(int offset, int elements) const { 155| 9| if (offset < 0 || elements < 0) { ------------------ | Branch (155:13): [True: 0, False: 9] | Branch (155:27): [True: 0, False: 9] ------------------ 156| 0| throw DeadlyImportError("MDL file contains invalid data"); 157| 0| } 158| | 159| 9| const size_t uoffset = static_cast(offset); 160| 9| const size_t uelements = static_cast(elements); 161| | 162| 9| if (uoffset > length_ || uelements > (length_ - uoffset) / sizeof(DataType)) { ------------------ | Branch (162:13): [True: 0, False: 9] | Branch (162:34): [True: 0, False: 9] ------------------ 163| 0| throw DeadlyImportError("MDL file contains invalid data"); 164| 0| } 165| | 166| 9| return reinterpret_cast(data_ + uoffset); 167| 9| } _ZNK6Assimp3MDL8HalfLife13HL1DataBuffer8get_dataINS1_12Bodypart_HL1EEEPKT_ii: 154| 12| const DataType *get_data(int offset, int elements) const { 155| 12| if (offset < 0 || elements < 0) { ------------------ | Branch (155:13): [True: 0, False: 12] | Branch (155:27): [True: 0, False: 12] ------------------ 156| 0| throw DeadlyImportError("MDL file contains invalid data"); 157| 0| } 158| | 159| 12| const size_t uoffset = static_cast(offset); 160| 12| const size_t uelements = static_cast(elements); 161| | 162| 12| if (uoffset > length_ || uelements > (length_ - uoffset) / sizeof(DataType)) { ------------------ | Branch (162:13): [True: 0, False: 12] | Branch (162:34): [True: 0, False: 12] ------------------ 163| 0| throw DeadlyImportError("MDL file contains invalid data"); 164| 0| } 165| | 166| 12| return reinterpret_cast(data_ + uoffset); 167| 12| } _ZNK6Assimp3MDL8HalfLife13HL1DataBuffer8get_dataINS1_9Model_HL1EEEPKT_ii: 154| 12| const DataType *get_data(int offset, int elements) const { 155| 12| if (offset < 0 || elements < 0) { ------------------ | Branch (155:13): [True: 0, False: 12] | Branch (155:27): [True: 0, False: 12] ------------------ 156| 0| throw DeadlyImportError("MDL file contains invalid data"); 157| 0| } 158| | 159| 12| const size_t uoffset = static_cast(offset); 160| 12| const size_t uelements = static_cast(elements); 161| | 162| 12| if (uoffset > length_ || uelements > (length_ - uoffset) / sizeof(DataType)) { ------------------ | Branch (162:13): [True: 0, False: 12] | Branch (162:34): [True: 0, False: 12] ------------------ 163| 0| throw DeadlyImportError("MDL file contains invalid data"); 164| 0| } 165| | 166| 12| return reinterpret_cast(data_ + uoffset); 167| 12| } _ZNK6Assimp3MDL8HalfLife13HL1DataBuffer8get_dataINS1_8Mesh_HL1EEEPKT_ii: 154| 3| const DataType *get_data(int offset, int elements) const { 155| 3| if (offset < 0 || elements < 0) { ------------------ | Branch (155:13): [True: 0, False: 3] | Branch (155:27): [True: 0, False: 3] ------------------ 156| 0| throw DeadlyImportError("MDL file contains invalid data"); 157| 0| } 158| | 159| 3| const size_t uoffset = static_cast(offset); 160| 3| const size_t uelements = static_cast(elements); 161| | 162| 3| if (uoffset > length_ || uelements > (length_ - uoffset) / sizeof(DataType)) { ------------------ | Branch (162:13): [True: 0, False: 3] | Branch (162:34): [True: 0, False: 3] ------------------ 163| 0| throw DeadlyImportError("MDL file contains invalid data"); 164| 0| } 165| | 166| 3| return reinterpret_cast(data_ + uoffset); 167| 3| } _ZNK6Assimp3MDL8HalfLife13HL1DataBuffer8get_dataIA3_fEEPKT_ii: 154| 6| const DataType *get_data(int offset, int elements) const { 155| 6| if (offset < 0 || elements < 0) { ------------------ | Branch (155:13): [True: 0, False: 6] | Branch (155:27): [True: 0, False: 6] ------------------ 156| 0| throw DeadlyImportError("MDL file contains invalid data"); 157| 0| } 158| | 159| 6| const size_t uoffset = static_cast(offset); 160| 6| const size_t uelements = static_cast(elements); 161| | 162| 6| if (uoffset > length_ || uelements > (length_ - uoffset) / sizeof(DataType)) { ------------------ | Branch (162:13): [True: 0, False: 6] | Branch (162:34): [True: 0, False: 6] ------------------ 163| 0| throw DeadlyImportError("MDL file contains invalid data"); 164| 0| } 165| | 166| 6| return reinterpret_cast(data_ + uoffset); 167| 6| } _ZNK6Assimp3MDL8HalfLife13HL1DataBuffer8get_dataINS1_16SequenceDesc_HL1EEEPKT_ii: 154| 11| const DataType *get_data(int offset, int elements) const { 155| 11| if (offset < 0 || elements < 0) { ------------------ | Branch (155:13): [True: 0, False: 11] | Branch (155:27): [True: 0, False: 11] ------------------ 156| 0| throw DeadlyImportError("MDL file contains invalid data"); 157| 0| } 158| | 159| 11| const size_t uoffset = static_cast(offset); 160| 11| const size_t uelements = static_cast(elements); 161| | 162| 11| if (uoffset > length_ || uelements > (length_ - uoffset) / sizeof(DataType)) { ------------------ | Branch (162:13): [True: 0, False: 11] | Branch (162:34): [True: 0, False: 11] ------------------ 163| 0| throw DeadlyImportError("MDL file contains invalid data"); 164| 0| } 165| | 166| 11| return reinterpret_cast(data_ + uoffset); 167| 11| } _ZNK6Assimp3MDL8HalfLife13HL1DataBuffer8get_dataINS1_17SequenceGroup_HL1EEEPKT_ii: 154| 10| const DataType *get_data(int offset, int elements) const { 155| 10| if (offset < 0 || elements < 0) { ------------------ | Branch (155:13): [True: 1, False: 9] | Branch (155:27): [True: 0, False: 9] ------------------ 156| 1| throw DeadlyImportError("MDL file contains invalid data"); 157| 1| } 158| | 159| 9| const size_t uoffset = static_cast(offset); 160| 9| const size_t uelements = static_cast(elements); 161| | 162| 9| if (uoffset > length_ || uelements > (length_ - uoffset) / sizeof(DataType)) { ------------------ | Branch (162:13): [True: 0, False: 9] | Branch (162:34): [True: 0, False: 9] ------------------ 163| 0| throw DeadlyImportError("MDL file contains invalid data"); 164| 0| } 165| | 166| 9| return reinterpret_cast(data_ + uoffset); 167| 9| } _ZNK6Assimp3MDL8HalfLife13HL1DataBuffer8get_dataINS1_19AnimValueOffset_HL1EEEPKT_ii: 154| 5| const DataType *get_data(int offset, int elements) const { 155| 5| if (offset < 0 || elements < 0) { ------------------ | Branch (155:13): [True: 0, False: 5] | Branch (155:27): [True: 0, False: 5] ------------------ 156| 0| throw DeadlyImportError("MDL file contains invalid data"); 157| 0| } 158| | 159| 5| const size_t uoffset = static_cast(offset); 160| 5| const size_t uelements = static_cast(elements); 161| | 162| 5| if (uoffset > length_ || uelements > (length_ - uoffset) / sizeof(DataType)) { ------------------ | Branch (162:13): [True: 0, False: 5] | Branch (162:34): [True: 0, False: 5] ------------------ 163| 0| throw DeadlyImportError("MDL file contains invalid data"); 164| 0| } 165| | 166| 5| return reinterpret_cast(data_ + uoffset); 167| 5| } _ZNK6Assimp3MDL8HalfLife13HL1DataBuffer8get_dataINS1_10Hitbox_HL1EEEPKT_ii: 154| 2| const DataType *get_data(int offset, int elements) const { 155| 2| if (offset < 0 || elements < 0) { ------------------ | Branch (155:13): [True: 0, False: 2] | Branch (155:27): [True: 0, False: 2] ------------------ 156| 0| throw DeadlyImportError("MDL file contains invalid data"); 157| 0| } 158| | 159| 2| const size_t uoffset = static_cast(offset); 160| 2| const size_t uelements = static_cast(elements); 161| | 162| 2| if (uoffset > length_ || uelements > (length_ - uoffset) / sizeof(DataType)) { ------------------ | Branch (162:13): [True: 0, False: 2] | Branch (162:34): [True: 0, False: 2] ------------------ 163| 0| throw DeadlyImportError("MDL file contains invalid data"); 164| 0| } 165| | 166| 2| return reinterpret_cast(data_ + uoffset); 167| 2| } _ZN6Assimp3MDL8HalfLife17HL1ImportSettingsC2Ev: 57| 1.24k| read_animations(false), 58| 1.24k| read_animation_events(false), 59| 1.24k| read_blend_controllers(false), 60| 1.24k| read_sequence_groups_info(false), 61| 1.24k| read_sequence_transitions(false), 62| 1.24k| read_attachments(false), 63| 1.24k| read_bone_controllers(false), 64| 1.24k| read_hitboxes(false), 65| 1.24k| read_textures(false), 66| 1.24k| read_misc_global_info(false), 67| 1.24k| transform_coord_system(true) { 68| 1.24k| } _ZN6Assimp3MDL8HalfLife12HL1MDLLoaderC2EP7aiScenePNS_8IOSystemEPKhmRKNSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEERKNS1_17HL1ImportSettingsE: 84| 4| scene_(scene), 85| 4| io_(io), 86| 4| buffer_(HL1DataBuffer::view(buffer, buffer_length)), 87| 4| file_path_(file_path), 88| 4| import_settings_(import_settings), 89| 4| header_(nullptr), 90| 4| texture_header_(nullptr), 91| 4| anim_headers_(), 92| 4| texture_buffer_(), 93| 4| anim_buffers_(), 94| 4| num_sequence_groups_(0), 95| 4| rootnode_children_(), 96| 4| unique_name_generator_(), 97| 4| unique_sequence_names_(), 98| 4| unique_sequence_groups_names_(), 99| 4| temp_bones_(), 100| 4| num_blend_controllers_(0), 101| 4| total_models_(0) { 102| 4| load_file(); 103| 4|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoaderD2Ev: 106| 3|HL1MDLLoader::~HL1MDLLoader() { 107| 3| release_resources(); 108| 3|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader17release_resourcesEv: 111| 7|void HL1MDLLoader::release_resources() { 112| | // Root has some children nodes. so let's proceed them 113| 7| if (!rootnode_children_.empty()) { ------------------ | Branch (113:9): [True: 1, False: 6] ------------------ 114| | // Here, it means that the nodes were not added to the 115| | // scene root node. We still have to delete them. 116| 4| for (auto it = rootnode_children_.begin(); it != rootnode_children_.end(); ++it) { ------------------ | Branch (116:52): [True: 3, False: 1] ------------------ 117| 3| if (*it) { ------------------ | Branch (117:17): [True: 3, False: 0] ------------------ 118| 3| delete *it; 119| 3| } 120| 3| } 121| | // Ensure this happens only once. 122| 1| rootnode_children_.clear(); 123| 1| } 124| 7|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader9load_fileEv: 127| 4|void HL1MDLLoader::load_file() { 128| 4| try { 129| 4| header_ = get_buffer_data(0, 1); 130| 4| validate_header(header_, false); 131| | 132| | // Create the root scene node. 133| 4| scene_->mRootNode = new aiNode(AI_MDL_HL1_NODE_ROOT); ------------------ | | 49| 4|#define AI_MDL_HL1_NODE_ROOT "" ------------------ 134| | 135| 4| load_texture_file(); 136| | 137| 4| if (import_settings_.read_animations) { ------------------ | Branch (137:13): [True: 4, False: 0] ------------------ 138| 4| load_sequence_groups_files(); 139| 4| } 140| | 141| 4| read_textures(); 142| 4| read_skins(); 143| | 144| 4| read_bones(); 145| 4| read_meshes(); 146| | 147| 4| if (import_settings_.read_animations) { ------------------ | Branch (147:13): [True: 4, False: 0] ------------------ 148| 4| read_sequence_groups_info(); 149| 4| read_animations(); 150| 4| read_sequence_infos(); 151| 4| if (import_settings_.read_sequence_transitions) ------------------ | Branch (151:17): [True: 3, False: 1] ------------------ 152| 3| read_sequence_transitions(); 153| 4| } 154| | 155| 4| if (import_settings_.read_attachments) { ------------------ | Branch (155:13): [True: 3, False: 1] ------------------ 156| 3| read_attachments(); 157| 3| } 158| | 159| 4| if (import_settings_.read_hitboxes) { ------------------ | Branch (159:13): [True: 3, False: 1] ------------------ 160| 3| read_hitboxes(); 161| 3| } 162| | 163| 4| if (import_settings_.read_bone_controllers) { ------------------ | Branch (163:13): [True: 3, False: 1] ------------------ 164| 3| read_bone_controllers(); 165| 3| } 166| | 167| 4| read_global_info(); 168| | 169| 4| if (!header_->numbodyparts) { ------------------ | Branch (169:13): [True: 0, False: 4] ------------------ 170| | // This could be an MDL external texture file. In this case, 171| | // add this flag to allow the scene to be loaded even if it 172| | // has no meshes. 173| 0| scene_->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; 174| 0| } 175| | 176| | // Append children to root node. 177| 4| if (rootnode_children_.size()) { ------------------ | Branch (177:13): [True: 3, False: 1] ------------------ 178| 3| scene_->mRootNode->addChildren( 179| 3| static_cast(rootnode_children_.size()), 180| 3| rootnode_children_.data()); 181| | 182| | // Clear the list of nodes so they will not be destroyed 183| | // when resources are released. 184| 3| rootnode_children_.clear(); 185| 3| } 186| | 187| 4| release_resources(); 188| | 189| 4| } catch (...) { 190| 1| release_resources(); 191| 1| throw; 192| 1| } 193| 4|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader15validate_headerEPKNS1_10Header_HL1Eb: 196| 8|void HL1MDLLoader::validate_header(const Header_HL1 *header, bool is_texture_header) { 197| 8| if (is_texture_header) { ------------------ | Branch (197:9): [True: 4, False: 4] ------------------ 198| | // Every single Half-Life model is assumed to have at least one texture. 199| 4| if (!header->numtextures) { ------------------ | Branch (199:13): [True: 0, False: 4] ------------------ 200| 0| throw DeadlyImportError(MDL_HALFLIFE_LOG_HEADER "There are no textures in the file"); ------------------ | | 65| 0|#define MDL_HALFLIFE_LOG_HEADER "[Half-Life 1 MDL] " ------------------ 201| 0| } 202| | 203| 4| if (header->numtextures > AI_MDL_HL1_MAX_TEXTURES) { ------------------ | | 555| 4|#define AI_MDL_HL1_MAX_TEXTURES 100 ------------------ | Branch (203:13): [True: 0, False: 4] ------------------ 204| 0| log_warning_limit_exceeded(header->numtextures, "textures"); 205| 0| } 206| | 207| 4| if (header->numskinfamilies > AI_MDL_HL1_MAX_SKIN_FAMILIES) { ------------------ | | 558| 4|#define AI_MDL_HL1_MAX_SKIN_FAMILIES 100 ------------------ | Branch (207:13): [True: 0, False: 4] ------------------ 208| 0| log_warning_limit_exceeded(header->numskinfamilies, "skin families"); 209| 0| } 210| | 211| 4| } else { 212| | 213| 4| if (header->numbodyparts > AI_MDL_HL1_MAX_BODYPARTS) { ------------------ | | 564| 4|#define AI_MDL_HL1_MAX_BODYPARTS 32 ------------------ | Branch (213:13): [True: 0, False: 4] ------------------ 214| 0| log_warning_limit_exceeded(header->numbodyparts, "bodyparts"); 215| 0| } 216| | 217| 4| if (header->numbones > AI_MDL_HL1_MAX_BONES) { ------------------ | | 561| 4|#define AI_MDL_HL1_MAX_BONES 128 ------------------ | Branch (217:13): [True: 0, False: 4] ------------------ 218| 0| log_warning_limit_exceeded(header->numbones, "bones"); 219| 0| } 220| | 221| 4| if (header->numbonecontrollers > AI_MDL_HL1_MAX_BONE_CONTROLLERS) { ------------------ | | 576| 4|#define AI_MDL_HL1_MAX_BONE_CONTROLLERS 8 ------------------ | Branch (221:13): [True: 0, False: 4] ------------------ 222| 0| log_warning_limit_exceeded(header->numbonecontrollers, "bone controllers"); 223| 0| } 224| | 225| 4| if (header->numseq > AI_MDL_HL1_MAX_SEQUENCES) { ------------------ | | 549| 4|#define AI_MDL_HL1_MAX_SEQUENCES 2048 ------------------ | Branch (225:13): [True: 0, False: 4] ------------------ 226| 0| log_warning_limit_exceeded(header->numseq, "sequences"); 227| 0| } 228| | 229| 4| if (header->numseqgroups > AI_MDL_HL1_MAX_SEQUENCE_GROUPS) { ------------------ | | 552| 4|#define AI_MDL_HL1_MAX_SEQUENCE_GROUPS 32 ------------------ | Branch (229:13): [True: 0, False: 4] ------------------ 230| 0| log_warning_limit_exceeded(header->numseqgroups, "sequence groups"); 231| 0| } 232| | 233| 4| if (header->numattachments > AI_MDL_HL1_MAX_ATTACHMENTS) { ------------------ | | 579| 4|#define AI_MDL_HL1_MAX_ATTACHMENTS 512 ------------------ | Branch (233:13): [True: 0, False: 4] ------------------ 234| 0| log_warning_limit_exceeded(header->numattachments, "attachments"); 235| 0| } 236| 4| } 237| 8|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader17load_texture_fileEv: 257| 4|void HL1MDLLoader::load_texture_file() { 258| 4| if (header_->numtextures == 0) { ------------------ | Branch (258:9): [True: 0, False: 4] ------------------ 259| | // Load an external MDL texture file. 260| 0| std::string texture_file_path = 261| 0| DefaultIOSystem::absolutePath(file_path_) + io_->getOsSeparator() + 262| 0| DefaultIOSystem::completeBaseName(file_path_) + "T." + 263| 0| BaseImporter::GetExtension(file_path_); 264| | 265| 0| load_file_into_buffer(texture_file_path, texture_buffer_); 266| 4| } else { 267| | // Model has no external texture file. This means the texture is stored inside the main MDL file. 268| 4| texture_buffer_ = HL1DataBuffer::view(buffer_); 269| 4| } 270| | 271| 4| texture_header_ = get_texture_buffer_data(0, 1); 272| | 273| | // Validate texture header. 274| 4| validate_header(texture_header_, true); 275| 4|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader26load_sequence_groups_filesEv: 293| 4|void HL1MDLLoader::load_sequence_groups_files() { 294| 4| if (header_->numseqgroups <= 1) { ------------------ | Branch (294:9): [True: 3, False: 1] ------------------ 295| 3| return; 296| 3| } 297| | 298| 1| num_sequence_groups_ = header_->numseqgroups; 299| | 300| 1| anim_buffers_.resize(num_sequence_groups_); 301| 1| anim_headers_.resize(num_sequence_groups_, nullptr); 302| | 303| 1| std::string file_path_without_extension = 304| 1| DefaultIOSystem::absolutePath(file_path_) + 305| 1| io_->getOsSeparator() + 306| 1| DefaultIOSystem::completeBaseName(file_path_); 307| | 308| 10| for (int i = 1; i < num_sequence_groups_; ++i) { ------------------ | Branch (308:21): [True: 9, False: 1] ------------------ 309| 9| std::stringstream ss; 310| 9| ss << file_path_without_extension; 311| 9| ss << std::setw(2) << std::setfill('0') << i; 312| 9| ss << '.' << BaseImporter::GetExtension(file_path_); 313| | 314| 9| std::string sequence_file_path = ss.str(); 315| | 316| 9| load_file_into_buffer(sequence_file_path, anim_buffers_[i]); 317| | 318| 9| anim_headers_[i] = get_anim_buffer_data(i, 0, 1); 319| 9| } 320| 1|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader12read_textureEPKNS1_11Texture_HL1EPKhS7_P9aiTextureR9aiColor3D: 326| 4| aiColor3D &last_palette_color) { 327| 4| pResult->mFilename = ptexture->name; 328| 4| pResult->mWidth = static_cast(ptexture->width); 329| 4| pResult->mHeight = static_cast(ptexture->height); 330| 4| pResult->achFormatHint[0] = 'r'; 331| 4| pResult->achFormatHint[1] = 'g'; 332| 4| pResult->achFormatHint[2] = 'b'; 333| 4| pResult->achFormatHint[3] = 'a'; 334| 4| pResult->achFormatHint[4] = '8'; 335| 4| pResult->achFormatHint[5] = '8'; 336| 4| pResult->achFormatHint[6] = '8'; 337| 4| pResult->achFormatHint[7] = '8'; 338| 4| pResult->achFormatHint[8] = '\0'; 339| | 340| 4| const size_t num_pixels = pResult->mWidth * pResult->mHeight; 341| 4| aiTexel *out = pResult->pcData = new aiTexel[num_pixels]; 342| | 343| | // Convert indexed 8 bit to 32 bit RGBA. 344| 270k| for (size_t i = 0; i < num_pixels; ++i, ++out) { ------------------ | Branch (344:24): [True: 270k, False: 4] ------------------ 345| 270k| out->r = pal[data[i] * 3]; 346| 270k| out->g = pal[data[i] * 3 + 1]; 347| 270k| out->b = pal[data[i] * 3 + 2]; 348| 270k| out->a = 255; 349| 270k| } 350| | 351| | // Get the last palette color. 352| 4| last_palette_color.r = pal[255 * 3]; 353| 4| last_palette_color.g = pal[255 * 3 + 1]; 354| 4| last_palette_color.b = pal[255 * 3 + 2]; 355| 4|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader13read_texturesEv: 358| 4|void HL1MDLLoader::read_textures() { 359| 4| scene_->mTextures = new aiTexture *[texture_header_->numtextures]; 360| 4| scene_->mMaterials = new aiMaterial *[texture_header_->numtextures]; 361| | 362| 4| const Texture_HL1 *ptexture = get_texture_buffer_data(texture_header_->textureindex, texture_header_->numtextures); 363| | 364| 8| for (int i = 0; i < texture_header_->numtextures; ++i) { ------------------ | Branch (364:21): [True: 4, False: 4] ------------------ 365| 4| scene_->mTextures[i] = new aiTexture(); 366| 4| ++scene_->mNumTextures; 367| | 368| 4| const uint8_t *data = get_texture_buffer_data(ptexture[i].index, ptexture[i].width * ptexture[i].height); 369| 4| const uint8_t *pal = get_texture_buffer_data(ptexture[i].index + ptexture[i].width * ptexture[i].height, 256 * 3); 370| | 371| 4| aiColor3D last_palette_color; 372| 4| read_texture(&ptexture[i], data, pal, scene_->mTextures[i], last_palette_color); 373| | 374| 4| aiMaterial *scene_material = new aiMaterial(); 375| 4| scene_->mMaterials[i] = scene_material; 376| 4| ++scene_->mNumMaterials; 377| | 378| 4| const aiTextureType texture_type = aiTextureType_DIFFUSE; 379| 4| aiString texture_name(ptexture[i].name); 380| 4| scene_material->AddProperty(&texture_name, AI_MATKEY_TEXTURE(texture_type, 0)); 381| | 382| | // Is this a chrome texture? 383| 4| int chrome = ptexture[i].flags & AI_MDL_HL1_STUDIO_NF_CHROME ? 1 : 0; ------------------ | | 587| 4|#define AI_MDL_HL1_STUDIO_NF_CHROME 0x0002 ------------------ | Branch (383:22): [True: 2, False: 2] ------------------ 384| 4| scene_material->AddProperty(&chrome, 1, AI_MDL_HL1_MATKEY_CHROME(texture_type, 0)); ------------------ | | 62| 4|#define AI_MDL_HL1_MATKEY_CHROME(type, N) "$mat.HL1.chrome", type, N ------------------ 385| | 386| 4| if (ptexture[i].flags & AI_MDL_HL1_STUDIO_NF_FLATSHADE) { ------------------ | | 584| 4|#define AI_MDL_HL1_STUDIO_NF_FLATSHADE 0x0001 ------------------ | Branch (386:13): [True: 2, False: 2] ------------------ 387| | // Flat shading. 388| 2| const aiShadingMode shading_mode = aiShadingMode_Flat; 389| 2| scene_material->AddProperty(&shading_mode, 1, AI_MATKEY_SHADING_MODEL); 390| 2| } 391| | 392| 4| if (ptexture[i].flags & AI_MDL_HL1_STUDIO_NF_ADDITIVE) { ------------------ | | 590| 4|#define AI_MDL_HL1_STUDIO_NF_ADDITIVE 0x0020 ------------------ | Branch (392:13): [True: 1, False: 3] ------------------ 393| | // Additive texture. 394| 1| const aiBlendMode blend_mode = aiBlendMode_Additive; 395| 1| scene_material->AddProperty(&blend_mode, 1, AI_MATKEY_BLEND_FUNC); 396| 3| } else if (ptexture[i].flags & AI_MDL_HL1_STUDIO_NF_MASKED) { ------------------ | | 593| 3|#define AI_MDL_HL1_STUDIO_NF_MASKED 0x0040 ------------------ | Branch (396:20): [True: 1, False: 2] ------------------ 397| | // Texture with 1 bit alpha test. 398| 1| const aiTextureFlags use_alpha = aiTextureFlags_UseAlpha; 399| 1| scene_material->AddProperty(&use_alpha, 1, AI_MATKEY_TEXFLAGS(texture_type, 0)); 400| | scene_material->AddProperty(&last_palette_color, 1, AI_MATKEY_COLOR_TRANSPARENT); 401| 1| } 402| 4| } 403| 4|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader10read_skinsEv: 406| 4|void HL1MDLLoader::read_skins() { 407| | // Read skins, if any. 408| 4| if (texture_header_->numskinfamilies <= 1) { ------------------ | Branch (408:9): [True: 4, False: 0] ------------------ 409| 4| return; 410| 4| } 411| | 412| | // Pointer to base texture index. 413| 0| const short *default_skin_ptr = get_texture_buffer_data( 414| 0| texture_header_->skinindex, 415| 0| texture_header_->numskinref); 416| | 417| | // Start at first replacement skin. 418| 0| const short *replacement_skin_ptr = get_texture_buffer_data( 419| 0| texture_header_->skinindex + texture_header_->numskinref * sizeof(short), 420| 0| (texture_header_->numskinfamilies - 1) * texture_header_->numskinref); 421| | 422| 0| for (int i = 1; i < texture_header_->numskinfamilies; ++i, replacement_skin_ptr += texture_header_->numskinref) { ------------------ | Branch (422:21): [True: 0, False: 0] ------------------ 423| 0| for (int j = 0; j < texture_header_->numskinref; ++j) { ------------------ | Branch (423:25): [True: 0, False: 0] ------------------ 424| 0| if (default_skin_ptr[j] != replacement_skin_ptr[j]) { ------------------ | Branch (424:17): [True: 0, False: 0] ------------------ 425| | // Save replacement textures. 426| 0| aiString skinMaterialId(scene_->mTextures[replacement_skin_ptr[j]]->mFilename); 427| | scene_->mMaterials[default_skin_ptr[j]]->AddProperty(&skinMaterialId, AI_MATKEY_TEXTURE_DIFFUSE(i)); 428| 0| } 429| 0| } 430| 0| } 431| 0|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader10read_bonesEv: 434| 4|void HL1MDLLoader::read_bones() { 435| 4| if (!header_->numbones) { ------------------ | Branch (435:9): [True: 0, False: 4] ------------------ 436| 0| return; 437| 0| } 438| | 439| 4| const Bone_HL1 *pbone = get_buffer_data(header_->boneindex, header_->numbones); 440| | 441| 4| std::vector unique_bones_names(header_->numbones); 442| 26| for (int i = 0; i < header_->numbones; ++i) { ------------------ | Branch (442:21): [True: 22, False: 4] ------------------ 443| 22| unique_bones_names[i] = pbone[i].name; 444| 22| } 445| | 446| | // Ensure bones have unique names. 447| 4| unique_name_generator_.set_template_name("Bone"); 448| 4| unique_name_generator_.make_unique(unique_bones_names); 449| | 450| 4| temp_bones_.resize(header_->numbones); 451| | 452| | // Create the main 'bones' node that will contain all MDL root bones. 453| 4| aiNode *bones_node = new aiNode(AI_MDL_HL1_NODE_BONES); ------------------ | | 51| 4|#define AI_MDL_HL1_NODE_BONES "" ------------------ 454| 4| rootnode_children_.push_back(bones_node); 455| | 456| | // Store roots bones IDs temporarily. 457| 4| std::vector roots; 458| | 459| | // Create bone matrices in local space. 460| 26| for (int i = 0; i < header_->numbones; ++i) { ------------------ | Branch (460:21): [True: 22, False: 4] ------------------ 461| 22| aiNode *bone_node = temp_bones_[i].node = new aiNode(unique_bones_names[i]); 462| | 463| 22| aiVector3D angles(pbone[i].value[3], pbone[i].value[4], pbone[i].value[5]); 464| 22| temp_bones_[i].absolute_transform = bone_node->mTransformation = 465| 22| aiMatrix4x4(aiVector3D(1), aiQuaternion(angles.y, angles.z, angles.x), 466| 22| aiVector3D(pbone[i].value[0], pbone[i].value[1], pbone[i].value[2])); 467| | 468| 22| if (pbone[i].parent == -1) { ------------------ | Branch (468:13): [True: 6, False: 16] ------------------ 469| 6| bone_node->mParent = bones_node; 470| 6| roots.push_back(i); // This bone has no parent. Add it to the roots list. 471| 16| } else { 472| 16| bone_node->mParent = temp_bones_[pbone[i].parent].node; 473| 16| temp_bones_[pbone[i].parent].children.push_back(i); // Add this bone to the parent bone's children list. 474| | 475| 16| temp_bones_[i].absolute_transform = 476| 16| temp_bones_[pbone[i].parent].absolute_transform * bone_node->mTransformation; 477| 16| } 478| | 479| 22| temp_bones_[i].offset_matrix = temp_bones_[i].absolute_transform; 480| 22| temp_bones_[i].offset_matrix.Inverse(); 481| 22| } 482| | 483| | // Allocate memory for each MDL root bone. 484| 4| bones_node->mNumChildren = static_cast(roots.size()); 485| 4| bones_node->mChildren = new aiNode *[bones_node->mNumChildren]; 486| | 487| | // Build all bones children hierarchy starting from each MDL root bone. 488| 10| for (size_t i = 0; i < roots.size(); ++i) ------------------ | Branch (488:24): [True: 6, False: 4] ------------------ 489| 6| { 490| 6| const TempBone &root_bone = temp_bones_[roots[i]]; 491| 6| bones_node->mChildren[i] = root_bone.node; 492| 6| build_bone_children_hierarchy(root_bone); 493| 6| } 494| 4|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader29build_bone_children_hierarchyERKNS2_8TempBoneE: 497| 22|{ 498| 22| if (bone.children.empty()) ------------------ | Branch (498:9): [True: 13, False: 9] ------------------ 499| 13| return; 500| | 501| 9| aiNode* bone_node = bone.node; 502| 9| bone_node->mNumChildren = static_cast(bone.children.size()); 503| 9| bone_node->mChildren = new aiNode *[bone_node->mNumChildren]; 504| | 505| | // Build each child bone's hierarchy recursively. 506| 25| for (size_t i = 0; i < bone.children.size(); ++i) ------------------ | Branch (506:24): [True: 16, False: 9] ------------------ 507| 16| { 508| 16| const TempBone &child_bone = temp_bones_[bone.children[i]]; 509| 16| bone_node->mChildren[i] = child_bone.node; 510| 16| build_bone_children_hierarchy(child_bone); 511| 16| } 512| 9|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader11read_meshesEv: 562| 4|void HL1MDLLoader::read_meshes() { 563| 4| if (!header_->numbodyparts) { ------------------ | Branch (563:9): [True: 0, False: 4] ------------------ 564| 0| return; 565| 0| } 566| | 567| 4| int total_verts = 0; 568| 4| int total_triangles = 0; 569| 4| total_models_ = 0; 570| | 571| 4| const Bodypart_HL1 *pbodypart = get_buffer_data(header_->bodypartindex, header_->numbodyparts); 572| 4| const Model_HL1 *pmodel = nullptr; 573| 4| const Mesh_HL1 *pmesh = nullptr; 574| | 575| 4| const Texture_HL1 *ptexture = get_texture_buffer_data(texture_header_->textureindex, texture_header_->numtextures); 576| 4| const short *pskinref = get_texture_buffer_data(texture_header_->skinindex, texture_header_->numskinref); 577| | 578| 4| scene_->mNumMeshes = 0; 579| | 580| 4| std::vector unique_bodyparts_names; 581| 4| unique_bodyparts_names.resize(header_->numbodyparts); 582| | 583| | // Count the number of meshes. 584| | 585| 8| for (int i = 0; i < header_->numbodyparts; ++i, ++pbodypart) { ------------------ | Branch (585:21): [True: 4, False: 4] ------------------ 586| 4| unique_bodyparts_names[i] = pbodypart->name; 587| | 588| 4| pmodel = get_buffer_data(pbodypart->modelindex, pbodypart->nummodels); 589| 7| for (int j = 0; j < pbodypart->nummodels; ++j, ++pmodel) { ------------------ | Branch (589:25): [True: 3, False: 4] ------------------ 590| 3| scene_->mNumMeshes += pmodel->nummesh; 591| 3| total_verts += pmodel->numverts; 592| 3| } 593| | 594| 4| total_models_ += pbodypart->nummodels; 595| 4| } 596| | 597| | // Display limit infos. 598| 4| if (total_verts > AI_MDL_HL1_MAX_VERTICES) { ------------------ | | 546| 4|#define AI_MDL_HL1_MAX_VERTICES 2048 ------------------ | Branch (598:9): [True: 0, False: 4] ------------------ 599| 0| log_warning_limit_exceeded(total_verts, "vertices"); 600| 0| } 601| | 602| 4| if (scene_->mNumMeshes > AI_MDL_HL1_MAX_MESHES) { ------------------ | | 570| 4|#define AI_MDL_HL1_MAX_MESHES 256 ------------------ | Branch (602:9): [True: 0, False: 4] ------------------ 603| 0| log_warning_limit_exceeded(scene_->mNumMeshes, "meshes"); 604| 0| } 605| | 606| 4| if (total_models_ > AI_MDL_HL1_MAX_MODELS) { ------------------ | | 567| 4|#define AI_MDL_HL1_MAX_MODELS 32 ------------------ | Branch (606:9): [True: 0, False: 4] ------------------ 607| 0| log_warning_limit_exceeded(total_models_, "models"); 608| 0| } 609| | 610| | // Ensure bodyparts have unique names. 611| 4| unique_name_generator_.set_template_name("Bodypart"); 612| 4| unique_name_generator_.make_unique(unique_bodyparts_names); 613| | 614| | // Now do the same for each model. 615| 4| pbodypart = get_buffer_data(header_->bodypartindex, header_->numbodyparts); 616| | 617| | // Prepare template name for bodypart models. 618| 4| std::vector unique_models_names; 619| 4| unique_models_names.resize(total_models_); 620| | 621| 4| unsigned int model_index = 0; 622| | 623| 8| for (int i = 0; i < header_->numbodyparts; ++i, ++pbodypart) { ------------------ | Branch (623:21): [True: 4, False: 4] ------------------ 624| 4| pmodel = get_buffer_data(pbodypart->modelindex, pbodypart->nummodels); 625| 7| for (int j = 0; j < pbodypart->nummodels; ++j, ++pmodel, ++model_index) ------------------ | Branch (625:25): [True: 3, False: 4] ------------------ 626| 3| unique_models_names[model_index] = pmodel->name; 627| 4| } 628| | 629| 4| unique_name_generator_.set_template_name("Model"); 630| 4| unique_name_generator_.make_unique(unique_models_names); 631| | 632| 4| unsigned int mesh_index = 0; 633| | 634| 4| scene_->mMeshes = new aiMesh *[scene_->mNumMeshes]; 635| | 636| 4| pbodypart = get_buffer_data(header_->bodypartindex, header_->numbodyparts); 637| | 638| | /* Create a node that will represent the mesh hierarchy. 639| | 640| | 641| | | 642| | +-- bodypart --+-- model -- [mesh index, mesh index, ...] 643| | | | 644| | | +-- model -- [mesh index, mesh index, ...] 645| | | | 646| | | ... 647| | | 648| | |-- bodypart -- ... 649| | | 650| | ... 651| | */ 652| 4| aiNode *bodyparts_node = new aiNode(AI_MDL_HL1_NODE_BODYPARTS); ------------------ | | 50| 4|#define AI_MDL_HL1_NODE_BODYPARTS "" ------------------ 653| 4| rootnode_children_.push_back(bodyparts_node); 654| 4| bodyparts_node->mNumChildren = static_cast(header_->numbodyparts); 655| 4| bodyparts_node->mChildren = new aiNode *[bodyparts_node->mNumChildren]; 656| 4| aiNode **bodyparts_node_ptr = bodyparts_node->mChildren; 657| | 658| | // The following variables are defined here so they don't have 659| | // to be recreated every iteration. 660| | 661| | // Model_HL1 vertices, in bind pose space. 662| 4| std::vector bind_pose_vertices; 663| | 664| | // Model_HL1 normals, in bind pose space. 665| 4| std::vector bind_pose_normals; 666| | 667| | // Used to contain temporary information for building a mesh. 668| 4| std::vector triverts; 669| | 670| 4| std::vector tricmds; 671| | 672| | // Which triverts to use for the mesh. 673| 4| std::vector mesh_triverts_indices; 674| | 675| 4| std::vector mesh_faces; 676| | 677| | /* triverts that have the same vertindex, but have different normindex,s,t values. 678| | Similar triverts are mapped from vertindex to a list of similar triverts. */ 679| 4| std::map> triverts_similars; 680| | 681| | // triverts per bone. 682| 4| std::map> bone_triverts; 683| | 684| | /** This function adds a trivert index to the list of triverts per bone. 685| | * \param[in] bone The bone that affects the trivert at index \p trivert_index. 686| | * \param[in] trivert_index The trivert index. 687| | */ 688| 4| auto AddTrivertToBone = [&](int bone, short trivert_index) { 689| 4| if (bone_triverts.count(bone) == 0) 690| 4| bone_triverts.insert({ bone, std::set{ trivert_index }}); 691| 4| else 692| 4| bone_triverts[bone].insert(trivert_index); 693| 4| }; 694| | 695| | /** This function creates and appends a new trivert to the list of triverts. 696| | * \param[in] trivert The trivert to use as a prototype. 697| | * \param[in] bone The bone that affects \p trivert. 698| | */ 699| 4| auto AddSimilarTrivert = [&](const Trivert &trivert, const int bone) { 700| 4| HL1MeshTrivert new_trivert(trivert); 701| 4| new_trivert.localindex = static_cast(mesh_triverts_indices.size()); 702| | 703| 4| short new_trivert_index = static_cast(triverts.size()); 704| | 705| 4| if (triverts_similars.count(trivert.vertindex) == 0) 706| 4| triverts_similars.insert({ trivert.vertindex, std::set{ new_trivert_index }}); 707| 4| else 708| 4| triverts_similars[trivert.vertindex].insert(new_trivert_index); 709| | 710| 4| triverts.push_back(new_trivert); 711| | 712| 4| mesh_triverts_indices.push_back(new_trivert_index); 713| 4| tricmds.push_back(new_trivert.localindex); 714| 4| AddTrivertToBone(bone, new_trivert.localindex); 715| 4| }; 716| | 717| 4| model_index = 0; 718| | 719| 8| for (int i = 0; i < header_->numbodyparts; ++i, ++pbodypart, ++bodyparts_node_ptr) { ------------------ | Branch (719:21): [True: 4, False: 4] ------------------ 720| 4| pmodel = get_buffer_data(pbodypart->modelindex, pbodypart->nummodels); 721| | 722| | // Create bodypart node for the mesh tree hierarchy. 723| 4| aiNode *bodypart_node = (*bodyparts_node_ptr) = new aiNode(unique_bodyparts_names[i]); 724| 4| bodypart_node->mParent = bodyparts_node; 725| 4| bodypart_node->mMetaData = aiMetadata::Alloc(1); 726| 4| bodypart_node->mMetaData->Set(0, "Base", pbodypart->base); 727| | 728| 4| bodypart_node->mNumChildren = static_cast(pbodypart->nummodels); 729| 4| bodypart_node->mChildren = new aiNode *[bodypart_node->mNumChildren]; 730| 4| aiNode **bodypart_models_ptr = bodypart_node->mChildren; 731| | 732| 7| for (int j = 0; j < pbodypart->nummodels; ------------------ | Branch (732:25): [True: 3, False: 4] ------------------ 733| 4| ++j, ++pmodel, ++bodypart_models_ptr, ++model_index) { 734| | 735| 3| pmesh = get_buffer_data(pmodel->meshindex, pmodel->nummesh); 736| | 737| 3| const uint8_t *pvertbone = get_buffer_data(pmodel->vertinfoindex, pmodel->numverts); 738| 3| const uint8_t *pnormbone = get_buffer_data(pmodel->norminfoindex, pmodel->numnorms); 739| 3| const vec3_t *pstudioverts = get_buffer_data(pmodel->vertindex, pmodel->numverts); 740| 3| const vec3_t *pstudionorms = get_buffer_data(pmodel->normindex, pmodel->numnorms); 741| | 742| | // Each vertex and normal is in local space, so transform 743| | // each of them to bring them in bind pose. 744| 3| bind_pose_vertices.resize(pmodel->numverts); 745| 3| bind_pose_normals.resize(pmodel->numnorms); 746| 405| for (size_t k = 0; k < bind_pose_vertices.size(); ++k) { ------------------ | Branch (746:32): [True: 402, False: 3] ------------------ 747| 402| const vec3_t &vert = pstudioverts[k]; 748| 402| bind_pose_vertices[k] = temp_bones_[pvertbone[k]].absolute_transform * aiVector3D(vert[0], vert[1], vert[2]); 749| 402| } 750| 421| for (size_t k = 0; k < bind_pose_normals.size(); ++k) { ------------------ | Branch (750:32): [True: 418, False: 3] ------------------ 751| 418| const vec3_t &norm = pstudionorms[k]; 752| | // Compute the normal matrix to transform the normal into bind pose, 753| | // without affecting its length. 754| 418| const aiMatrix4x4 normal_matrix = aiMatrix4x4(temp_bones_[pnormbone[k]].absolute_transform).Inverse().Transpose(); 755| 418| bind_pose_normals[k] = normal_matrix * aiVector3D(norm[0], norm[1], norm[2]); 756| 418| } 757| | 758| | // Create model node for the mesh tree hierarchy. 759| 3| aiNode *model_node = (*bodypart_models_ptr) = new aiNode(unique_models_names[model_index]); 760| 3| model_node->mParent = bodypart_node; 761| 3| model_node->mNumMeshes = static_cast(pmodel->nummesh); 762| 3| model_node->mMeshes = new unsigned int[model_node->mNumMeshes]; 763| 3| unsigned int *model_meshes_ptr = model_node->mMeshes; 764| | 765| 6| for (int k = 0; k < pmodel->nummesh; ++k, ++pmesh, ++mesh_index, ++model_meshes_ptr) { ------------------ | Branch (765:29): [True: 3, False: 3] ------------------ 766| 3| *model_meshes_ptr = mesh_index; 767| | 768| | // Read triverts. 769| 3| short *ptricmds = (short *)((uint8_t *)header_ + pmesh->triindex); 770| 3| float texcoords_s_scale = 1.0f / (float)ptexture[pskinref[pmesh->skinref]].width; 771| 3| float texcoords_t_scale = 1.0f / (float)ptexture[pskinref[pmesh->skinref]].height; 772| | 773| | // Reset the data for the upcoming mesh. 774| 3| triverts.clear(); 775| 3| triverts.resize(pmodel->numverts); 776| 3| mesh_triverts_indices.clear(); 777| 3| mesh_faces.clear(); 778| 3| triverts_similars.clear(); 779| 3| bone_triverts.clear(); 780| | 781| 3| int l; 782| 157| while ((l = *(ptricmds++))) { ------------------ | Branch (782:24): [True: 154, False: 3] ------------------ 783| 154| bool is_triangle_fan = false; 784| | 785| 154| if (l < 0) { ------------------ | Branch (785:25): [True: 12, False: 142] ------------------ 786| 12| l = -l; 787| 12| is_triangle_fan = true; 788| 12| } 789| | 790| | // Clear the list of tris for the upcoming tris. 791| 154| tricmds.clear(); 792| | 793| 1.18k| for (; l > 0; l--, ptricmds += 4) { ------------------ | Branch (793:28): [True: 1.02k, False: 154] ------------------ 794| 1.02k| const Trivert *input_trivert = reinterpret_cast(ptricmds); 795| 1.02k| const int bone = pvertbone[input_trivert->vertindex]; 796| | 797| 1.02k| HL1MeshTrivert *private_trivert = &triverts[input_trivert->vertindex]; 798| 1.02k| if (private_trivert->localindex == -1) { ------------------ | Branch (798:29): [True: 402, False: 626] ------------------ 799| | // First time referenced. 800| 402| *private_trivert = *input_trivert; 801| 402| private_trivert->localindex = static_cast(mesh_triverts_indices.size()); 802| 402| mesh_triverts_indices.push_back(input_trivert->vertindex); 803| 402| tricmds.push_back(private_trivert->localindex); 804| 402| AddTrivertToBone(bone, private_trivert->localindex); 805| 626| } else if (*private_trivert == *input_trivert) { ------------------ | Branch (805:36): [True: 420, False: 206] ------------------ 806| | // Exists and is the same. 807| 420| tricmds.push_back(private_trivert->localindex); 808| 420| } else { 809| | // No similar trivert associated to the trivert currently processed. 810| 206| if (triverts_similars.count(input_trivert->vertindex) == 0) ------------------ | Branch (810:33): [True: 160, False: 46] ------------------ 811| 160| AddSimilarTrivert(*input_trivert, bone); 812| 46| else { 813| | // Search in the list of similar triverts to see if the 814| | // trivert in process is already registered. 815| 46| short similar_index = -1; 816| 46| for (auto it = triverts_similars[input_trivert->vertindex].cbegin(); 817| 92| similar_index == -1 && it != triverts_similars[input_trivert->vertindex].cend(); ------------------ | Branch (817:41): [True: 92, False: 0] | Branch (817:41): [True: 46, False: 46] | Branch (817:64): [True: 46, False: 46] ------------------ 818| 46| ++it) { 819| 46| if (triverts[*it] == *input_trivert) ------------------ | Branch (819:41): [True: 0, False: 46] ------------------ 820| 0| similar_index = *it; 821| 46| } 822| | 823| | // If a similar trivert has been found, reuse it. 824| | // Otherwise, add it. 825| 46| if (similar_index == -1) ------------------ | Branch (825:37): [True: 46, False: 0] ------------------ 826| 46| AddSimilarTrivert(*input_trivert, bone); 827| 0| else 828| 0| tricmds.push_back(triverts[similar_index].localindex); 829| 46| } 830| 206| } 831| 1.02k| } 832| | 833| | // Build mesh faces. 834| 154| const int num_faces = static_cast(tricmds.size() - 2); 835| 154| mesh_faces.reserve(num_faces); 836| | 837| 154| if (is_triangle_fan) { ------------------ | Branch (837:25): [True: 12, False: 142] ------------------ 838| 79| for (int faceIdx = 0; faceIdx < num_faces; ++faceIdx) { ------------------ | Branch (838:47): [True: 67, False: 12] ------------------ 839| 67| mesh_faces.push_back(HL1MeshFace{ 840| 67| tricmds[0], 841| 67| tricmds[faceIdx + 1], 842| 67| tricmds[faceIdx + 2] }); 843| 67| } 844| 142| } else { 845| 795| for (int faceIdx = 0; faceIdx < num_faces; ++faceIdx) { ------------------ | Branch (845:47): [True: 653, False: 142] ------------------ 846| 653| if (faceIdx & 1) { ------------------ | Branch (846:33): [True: 297, False: 356] ------------------ 847| | // Preserve winding order. 848| 297| mesh_faces.push_back(HL1MeshFace{ 849| 297| tricmds[faceIdx + 1], 850| 297| tricmds[faceIdx], 851| 297| tricmds[faceIdx + 2] }); 852| 356| } else { 853| 356| mesh_faces.push_back(HL1MeshFace{ 854| 356| tricmds[faceIdx], 855| 356| tricmds[faceIdx + 1], 856| 356| tricmds[faceIdx + 2] }); 857| 356| } 858| 653| } 859| 142| } 860| | 861| 154| total_triangles += num_faces; 862| 154| } 863| | 864| | // Create the scene mesh. 865| 3| aiMesh *scene_mesh = scene_->mMeshes[mesh_index] = new aiMesh(); 866| 3| scene_mesh->mPrimitiveTypes = aiPrimitiveType::aiPrimitiveType_TRIANGLE; 867| 3| scene_mesh->mMaterialIndex = pskinref[pmesh->skinref]; 868| | 869| 3| scene_mesh->mNumVertices = static_cast(mesh_triverts_indices.size()); 870| | 871| 3| if (scene_mesh->mNumVertices) { ------------------ | Branch (871:21): [True: 3, False: 0] ------------------ 872| 3| scene_mesh->mVertices = new aiVector3D[scene_mesh->mNumVertices]; 873| 3| scene_mesh->mNormals = new aiVector3D[scene_mesh->mNumVertices]; 874| | 875| 3| scene_mesh->mNumUVComponents[0] = 2; 876| 3| scene_mesh->mTextureCoords[0] = new aiVector3D[scene_mesh->mNumVertices]; 877| | 878| | // Add vertices. 879| 611| for (unsigned int v = 0; v < scene_mesh->mNumVertices; ++v) { ------------------ | Branch (879:46): [True: 608, False: 3] ------------------ 880| 608| const HL1MeshTrivert *pTrivert = &triverts[mesh_triverts_indices[v]]; 881| 608| scene_mesh->mVertices[v] = bind_pose_vertices[pTrivert->vertindex]; 882| 608| scene_mesh->mNormals[v] = bind_pose_normals[pTrivert->normindex]; 883| 608| scene_mesh->mTextureCoords[0][v] = aiVector3D( 884| 608| pTrivert->s * texcoords_s_scale, 885| 608| pTrivert->t * -texcoords_t_scale, 0); 886| 608| } 887| | 888| | // Add face and indices. 889| 3| scene_mesh->mNumFaces = static_cast(mesh_faces.size()); 890| 3| scene_mesh->mFaces = new aiFace[scene_mesh->mNumFaces]; 891| | 892| 723| for (unsigned int f = 0; f < scene_mesh->mNumFaces; ++f) { ------------------ | Branch (892:46): [True: 720, False: 3] ------------------ 893| 720| aiFace *face = &scene_mesh->mFaces[f]; 894| 720| face->mNumIndices = 3; 895| 720| face->mIndices = new unsigned int[3]; 896| 720| face->mIndices[0] = mesh_faces[f].v2; 897| 720| face->mIndices[1] = mesh_faces[f].v1; 898| 720| face->mIndices[2] = mesh_faces[f].v0; 899| 720| } 900| | 901| | // Add mesh bones. 902| 3| scene_mesh->mNumBones = static_cast(bone_triverts.size()); 903| 3| scene_mesh->mBones = new aiBone *[scene_mesh->mNumBones]; 904| | 905| 3| aiBone **scene_bone_ptr = scene_mesh->mBones; 906| | 907| 3| for (auto bone_it = bone_triverts.cbegin(); 908| 24| bone_it != bone_triverts.cend(); ------------------ | Branch (908:29): [True: 21, False: 3] ------------------ 909| 21| ++bone_it, ++scene_bone_ptr) { 910| 21| const int bone_index = bone_it->first; 911| | 912| 21| aiBone *scene_bone = (*scene_bone_ptr) = new aiBone(); 913| 21| scene_bone->mName = temp_bones_[bone_index].node->mName; 914| | 915| 21| scene_bone->mOffsetMatrix = temp_bones_[bone_index].offset_matrix; 916| | 917| 21| auto vertex_ids = bone_triverts.at(bone_index); 918| | 919| | // Add vertex weight per bone. 920| 21| scene_bone->mNumWeights = static_cast(vertex_ids.size()); 921| 21| aiVertexWeight *vertex_weight_ptr = scene_bone->mWeights = new aiVertexWeight[scene_bone->mNumWeights]; 922| | 923| 21| for (auto vertex_it = vertex_ids.begin(); 924| 629| vertex_it != vertex_ids.end(); ------------------ | Branch (924:33): [True: 608, False: 21] ------------------ 925| 608| ++vertex_it, ++vertex_weight_ptr) { 926| 608| vertex_weight_ptr->mVertexId = *vertex_it; 927| 608| vertex_weight_ptr->mWeight = 1.0f; 928| 608| } 929| 21| } 930| 3| } 931| 3| } 932| 3| } 933| 4| } 934| | 935| 4| if (total_triangles > AI_MDL_HL1_MAX_TRIANGLES) { ------------------ | | 543| 4|#define AI_MDL_HL1_MAX_TRIANGLES 20000 ------------------ | Branch (935:9): [True: 0, False: 4] ------------------ 936| 0| log_warning_limit_exceeded(total_triangles, "triangles"); 937| 0| } 938| 4|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader15read_animationsEv: 941| 4|void HL1MDLLoader::read_animations() { 942| 4| if (!header_->numseq) { ------------------ | Branch (942:9): [True: 0, False: 4] ------------------ 943| 0| return; 944| 0| } 945| | 946| 4| const SequenceDesc_HL1 *pseqdesc = get_buffer_data(header_->seqindex, header_->numseq); 947| 4| const SequenceGroup_HL1 *pseqgroup = nullptr; 948| 4| const AnimValueOffset_HL1 *panim = nullptr; 949| 4| const AnimValue_HL1 *panimvalue = nullptr; 950| | 951| 4| unique_sequence_names_.resize(header_->numseq); 952| 16| for (int i = 0; i < header_->numseq; ++i) ------------------ | Branch (952:21): [True: 12, False: 4] ------------------ 953| 12| unique_sequence_names_[i] = pseqdesc[i].label; 954| | 955| | // Ensure sequences have unique names. 956| 4| unique_name_generator_.set_template_name("Sequence"); 957| 4| unique_name_generator_.make_unique(unique_sequence_names_); 958| | 959| 4| scene_->mNumAnimations = 0; 960| | 961| 4| int highest_num_blend_animations = SequenceBlendMode_HL1::NoBlend; 962| | 963| | // Count the total number of animations. 964| 16| for (int i = 0; i < header_->numseq; ++i, ++pseqdesc) { ------------------ | Branch (964:21): [True: 12, False: 4] ------------------ 965| 12| scene_->mNumAnimations += pseqdesc->numblends; 966| 12| highest_num_blend_animations = std::max(pseqdesc->numblends, highest_num_blend_animations); 967| 12| } 968| | 969| | // Get the number of available blend controllers for global info. 970| 4| get_num_blend_controllers(highest_num_blend_animations, num_blend_controllers_); 971| | 972| 4| pseqdesc = get_buffer_data(header_->seqindex, header_->numseq); 973| | 974| 4| aiAnimation **scene_animations_ptr = scene_->mAnimations = new aiAnimation *[scene_->mNumAnimations](); 975| | 976| 10| for (int sequence = 0; sequence < header_->numseq; ++sequence, ++pseqdesc) { ------------------ | Branch (976:28): [True: 6, False: 4] ------------------ 977| 6| pseqgroup = get_buffer_data(header_->seqgroupindex + pseqdesc->seqgroup * sizeof(SequenceGroup_HL1), 1); 978| | 979| 6| if (pseqdesc->seqgroup == 0) { ------------------ | Branch (979:13): [True: 3, False: 3] ------------------ 980| 3| panim = get_buffer_data(pseqgroup->unused2 + pseqdesc->animindex, pseqdesc->numblends * header_->numbones); 981| 3| } else { 982| 3| panim = get_anim_buffer_data(pseqdesc->seqgroup, pseqdesc->animindex, pseqdesc->numblends * header_->numbones); 983| 3| } 984| | 985| 11| for (int blend = 0; blend < pseqdesc->numblends; ++blend, ++scene_animations_ptr) { ------------------ | Branch (985:29): [True: 5, False: 6] ------------------ 986| | 987| 5| const Bone_HL1 *pbone = get_buffer_data(header_->boneindex, header_->numbones); 988| | 989| 5| aiAnimation *scene_animation = (*scene_animations_ptr) = new aiAnimation(); 990| | 991| 5| scene_animation->mName = unique_sequence_names_[sequence]; 992| 5| scene_animation->mTicksPerSecond = pseqdesc->fps; 993| 5| scene_animation->mDuration = static_cast(pseqdesc->fps) * pseqdesc->numframes; 994| 5| scene_animation->mNumChannels = static_cast(header_->numbones); 995| 5| scene_animation->mChannels = new aiNodeAnim *[scene_animation->mNumChannels](); 996| | 997| 28| for (int bone = 0; bone < header_->numbones; bone++, ++pbone, ++panim) { ------------------ | Branch (997:32): [True: 23, False: 5] ------------------ 998| 23| aiNodeAnim *node_anim = scene_animation->mChannels[bone] = new aiNodeAnim(); 999| 23| node_anim->mNodeName = temp_bones_[bone].node->mName; 1000| | 1001| 23| node_anim->mNumPositionKeys = pseqdesc->numframes; 1002| 23| node_anim->mNumRotationKeys = node_anim->mNumPositionKeys; 1003| 23| node_anim->mNumScalingKeys = 0; 1004| | 1005| 23| node_anim->mPositionKeys = new aiVectorKey[node_anim->mNumPositionKeys]; 1006| 23| node_anim->mRotationKeys = new aiQuatKey[node_anim->mNumRotationKeys]; 1007| | 1008| 291| for (int frame = 0; frame < pseqdesc->numframes; ++frame) { ------------------ | Branch (1008:37): [True: 268, False: 23] ------------------ 1009| 268| aiVectorKey *position_key = &node_anim->mPositionKeys[frame]; 1010| 268| aiQuatKey *rotation_key = &node_anim->mRotationKeys[frame]; 1011| | 1012| 268| aiVector3D angle1; 1013| 1.07k| for (int j = 0; j < 3; ++j) { ------------------ | Branch (1013:37): [True: 804, False: 268] ------------------ 1014| 804| if (panim->offset[j + 3] != 0) { ------------------ | Branch (1014:29): [True: 672, False: 132] ------------------ 1015| | // Read compressed rotation delta. 1016| 672| panimvalue = (const AnimValue_HL1 *)((uint8_t *)panim + panim->offset[j + 3]); 1017| 672| extract_anim_value(panimvalue, frame, pbone->scale[j + 3], angle1[j]); 1018| 672| } 1019| | 1020| | // Add the default rotation value. 1021| 804| angle1[j] += pbone->value[j + 3]; 1022| | 1023| 804| if (panim->offset[j] != 0) { ------------------ | Branch (1023:29): [True: 12, False: 792] ------------------ 1024| | // Read compressed position delta. 1025| 12| panimvalue = (const AnimValue_HL1 *)((uint8_t *)panim + panim->offset[j]); 1026| 12| extract_anim_value(panimvalue, frame, pbone->scale[j], position_key->mValue[j]); 1027| 12| } 1028| | 1029| | // Add the default position value. 1030| 804| position_key->mValue[j] += pbone->value[j]; 1031| 804| } 1032| | 1033| 268| position_key->mTime = rotation_key->mTime = static_cast(frame); 1034| | /* The Half-Life engine uses X as forward, Y as left, Z as up. Therefore, 1035| | pitch,yaw,roll is represented as (YZX). */ 1036| 268| rotation_key->mValue = aiQuaternion(angle1.y, angle1.z, angle1.x); 1037| 268| rotation_key->mValue.Normalize(); 1038| 268| } 1039| 23| } 1040| 5| } 1041| 6| } 1042| 4|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader25read_sequence_groups_infoEv: 1045| 4|void HL1MDLLoader::read_sequence_groups_info() { 1046| 4| if (!header_->numseqgroups) { ------------------ | Branch (1046:9): [True: 0, False: 4] ------------------ 1047| 0| return; 1048| 0| } 1049| | 1050| 4| aiNode *sequence_groups_node = new aiNode(AI_MDL_HL1_NODE_SEQUENCE_GROUPS); ------------------ | | 54| 4|#define AI_MDL_HL1_NODE_SEQUENCE_GROUPS "" ------------------ 1051| 4| rootnode_children_.push_back(sequence_groups_node); 1052| | 1053| 4| sequence_groups_node->mNumChildren = static_cast(header_->numseqgroups); 1054| 4| sequence_groups_node->mChildren = new aiNode *[sequence_groups_node->mNumChildren]; 1055| | 1056| 4| const SequenceGroup_HL1 *pseqgroup = get_buffer_data(header_->seqgroupindex, header_->numseqgroups); 1057| | 1058| 4| unique_sequence_groups_names_.resize(header_->numseqgroups); 1059| 17| for (int i = 0; i < header_->numseqgroups; ++i) { ------------------ | Branch (1059:21): [True: 13, False: 4] ------------------ 1060| 13| unique_sequence_groups_names_[i] = pseqgroup[i].label; 1061| 13| } 1062| | 1063| | // Ensure sequence groups have unique names. 1064| 4| unique_name_generator_.set_template_name("SequenceGroup"); 1065| 4| unique_name_generator_.make_unique(unique_sequence_groups_names_); 1066| | 1067| 17| for (int i = 0; i < header_->numseqgroups; ++i, ++pseqgroup) { ------------------ | Branch (1067:21): [True: 13, False: 4] ------------------ 1068| 13| aiNode *sequence_group_node = sequence_groups_node->mChildren[i] = new aiNode(unique_sequence_groups_names_[i]); 1069| 13| sequence_group_node->mParent = sequence_groups_node; 1070| | 1071| 13| aiMetadata *md = sequence_group_node->mMetaData = aiMetadata::Alloc(1); 1072| 13| if (i == 0) { ------------------ | Branch (1072:13): [True: 4, False: 9] ------------------ 1073| | /* StudioMDL does not write the file name for the default sequence group, 1074| | so we will write it. */ 1075| 4| md->Set(0, "File", aiString(file_path_)); 1076| 9| } else { 1077| 9| md->Set(0, "File", aiString(pseqgroup->name)); 1078| 9| } 1079| 13| } 1080| 4|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader19read_sequence_infosEv: 1083| 3|void HL1MDLLoader::read_sequence_infos() { 1084| 3| if (!header_->numseq) { ------------------ | Branch (1084:9): [True: 0, False: 3] ------------------ 1085| 0| return; 1086| 0| } 1087| | 1088| 3| const SequenceDesc_HL1 *pseqdesc = get_buffer_data(header_->seqindex, header_->numseq); 1089| | 1090| 3| aiNode *sequence_infos_node = new aiNode(AI_MDL_HL1_NODE_SEQUENCE_INFOS); ------------------ | | 53| 3|#define AI_MDL_HL1_NODE_SEQUENCE_INFOS "" ------------------ 1091| 3| rootnode_children_.push_back(sequence_infos_node); 1092| | 1093| 3| sequence_infos_node->mNumChildren = static_cast(header_->numseq); 1094| 3| sequence_infos_node->mChildren = new aiNode *[sequence_infos_node->mNumChildren]; 1095| | 1096| 3| std::vector sequence_info_node_children; 1097| | 1098| 3| int animation_index = 0; 1099| 6| for (int i = 0; i < header_->numseq; ++i, ++pseqdesc) { ------------------ | Branch (1099:21): [True: 3, False: 3] ------------------ 1100| | // Clear the list of children for the upcoming sequence info node. 1101| 3| sequence_info_node_children.clear(); 1102| | 1103| 3| aiNode *sequence_info_node = sequence_infos_node->mChildren[i] = new aiNode(unique_sequence_names_[i]); 1104| 3| sequence_info_node->mParent = sequence_infos_node; 1105| | 1106| | // Setup sequence info node Metadata. 1107| 3| aiMetadata *md = sequence_info_node->mMetaData = aiMetadata::Alloc(16); 1108| 3| md->Set(0, "AnimationIndex", animation_index); 1109| 3| animation_index += pseqdesc->numblends; 1110| | 1111| | // Reference the sequence group by name. This allows us to search a particular 1112| | // sequence group by name using aiNode(s). 1113| 3| md->Set(1, "SequenceGroup", aiString(unique_sequence_groups_names_[pseqdesc->seqgroup])); 1114| 3| md->Set(2, "FramesPerSecond", pseqdesc->fps); 1115| 3| md->Set(3, "NumFrames", pseqdesc->numframes); 1116| 3| md->Set(4, "NumBlends", pseqdesc->numblends); 1117| 3| md->Set(5, "Activity", pseqdesc->activity); 1118| 3| md->Set(6, "ActivityWeight", pseqdesc->actweight); 1119| 3| md->Set(7, "MotionFlags", pseqdesc->motiontype); 1120| 3| md->Set(8, "MotionBone", temp_bones_[pseqdesc->motionbone].node->mName); 1121| 3| md->Set(9, "LinearMovement", aiVector3D(pseqdesc->linearmovement[0], pseqdesc->linearmovement[1], pseqdesc->linearmovement[2])); 1122| 3| md->Set(10, "BBMin", aiVector3D(pseqdesc->bbmin[0], pseqdesc->bbmin[1], pseqdesc->bbmin[2])); 1123| 3| md->Set(11, "BBMax", aiVector3D(pseqdesc->bbmax[0], pseqdesc->bbmax[1], pseqdesc->bbmax[2])); 1124| 3| md->Set(12, "EntryNode", pseqdesc->entrynode); 1125| 3| md->Set(13, "ExitNode", pseqdesc->exitnode); 1126| 3| md->Set(14, "NodeFlags", pseqdesc->nodeflags); 1127| 3| md->Set(15, "Flags", pseqdesc->flags); 1128| | 1129| 3| if (import_settings_.read_blend_controllers) { ------------------ | Branch (1129:13): [True: 3, False: 0] ------------------ 1130| 3| int num_blend_controllers; 1131| 3| if (get_num_blend_controllers(pseqdesc->numblends, num_blend_controllers) && num_blend_controllers) { ------------------ | Branch (1131:17): [True: 3, False: 0] | Branch (1131:90): [True: 0, False: 3] ------------------ 1132| | // Read blend controllers info. 1133| 0| aiNode *blend_controllers_node = new aiNode(AI_MDL_HL1_NODE_BLEND_CONTROLLERS); ------------------ | | 60| 0|#define AI_MDL_HL1_NODE_BLEND_CONTROLLERS "BlendControllers" ------------------ 1134| 0| sequence_info_node_children.push_back(blend_controllers_node); 1135| 0| blend_controllers_node->mParent = sequence_info_node; 1136| 0| blend_controllers_node->mNumChildren = static_cast(num_blend_controllers); 1137| 0| blend_controllers_node->mChildren = new aiNode *[blend_controllers_node->mNumChildren]; 1138| | 1139| 0| for (unsigned int j = 0; j < blend_controllers_node->mNumChildren; ++j) { ------------------ | Branch (1139:42): [True: 0, False: 0] ------------------ 1140| 0| aiNode *blend_controller_node = blend_controllers_node->mChildren[j] = new aiNode(); 1141| 0| blend_controller_node->mParent = blend_controllers_node; 1142| | 1143| 0| aiMetadata *metaData = blend_controller_node->mMetaData = aiMetadata::Alloc(3); 1144| 0| metaData->Set(0, "Start", pseqdesc->blendstart[j]); 1145| 0| metaData->Set(1, "End", pseqdesc->blendend[j]); 1146| 0| metaData->Set(2, "MotionFlags", pseqdesc->blendtype[j]); 1147| 0| } 1148| 0| } 1149| 3| } 1150| | 1151| 3| if (import_settings_.read_animation_events && pseqdesc->numevents) { ------------------ | Branch (1151:13): [True: 3, False: 0] | Branch (1151:55): [True: 0, False: 3] ------------------ 1152| | // Read animation events. 1153| | 1154| 0| if (pseqdesc->numevents > AI_MDL_HL1_MAX_EVENTS) { ------------------ | | 573| 0|#define AI_MDL_HL1_MAX_EVENTS 1024 ------------------ | Branch (1154:17): [True: 0, False: 0] ------------------ 1155| 0| log_warning_limit_exceeded( 1156| 0| "Sequence " + std::string(pseqdesc->label), 1157| 0| pseqdesc->numevents, "animation events"); 1158| 0| } 1159| | 1160| 0| const AnimEvent_HL1 *pevent = get_buffer_data(pseqdesc->eventindex, pseqdesc->numevents); 1161| | 1162| 0| aiNode *pEventsNode = new aiNode(AI_MDL_HL1_NODE_ANIMATION_EVENTS); ------------------ | | 59| 0|#define AI_MDL_HL1_NODE_ANIMATION_EVENTS "AnimationEvents" ------------------ 1163| 0| sequence_info_node_children.push_back(pEventsNode); 1164| 0| pEventsNode->mParent = sequence_info_node; 1165| 0| pEventsNode->mNumChildren = static_cast(pseqdesc->numevents); 1166| 0| pEventsNode->mChildren = new aiNode *[pEventsNode->mNumChildren]; 1167| | 1168| 0| for (unsigned int j = 0; j < pEventsNode->mNumChildren; ++j, ++pevent) { ------------------ | Branch (1168:38): [True: 0, False: 0] ------------------ 1169| 0| aiNode *pEvent = pEventsNode->mChildren[j] = new aiNode(); 1170| 0| pEvent->mParent = pEventsNode; 1171| | 1172| 0| aiMetadata *metaData = pEvent->mMetaData = aiMetadata::Alloc(3); 1173| 0| metaData->Set(0, "Frame", pevent->frame); 1174| 0| metaData->Set(1, "ScriptEvent", pevent->event); 1175| 0| metaData->Set(2, "Options", aiString(pevent->options)); 1176| 0| } 1177| 0| } 1178| | 1179| 3| if (sequence_info_node_children.size()) { ------------------ | Branch (1179:13): [True: 0, False: 3] ------------------ 1180| 0| sequence_info_node->addChildren( 1181| 0| static_cast(sequence_info_node_children.size()), 1182| 0| sequence_info_node_children.data()); 1183| 0| } 1184| 3| } 1185| 3|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader25read_sequence_transitionsEv: 1188| 3|void HL1MDLLoader::read_sequence_transitions() { 1189| 3| if (!header_->numtransitions) { ------------------ | Branch (1189:9): [True: 3, False: 0] ------------------ 1190| 3| return; 1191| 3| } 1192| | 1193| | // Read sequence transition graph. 1194| 0| aiNode *transition_graph_node = new aiNode(AI_MDL_HL1_NODE_SEQUENCE_TRANSITION_GRAPH); ------------------ | | 55| 0|#define AI_MDL_HL1_NODE_SEQUENCE_TRANSITION_GRAPH "" ------------------ 1195| 0| rootnode_children_.push_back(transition_graph_node); 1196| | 1197| 0| const uint8_t *ptransitions = get_buffer_data(header_->transitionindex, header_->numtransitions * header_->numtransitions); 1198| 0| aiMetadata *md = transition_graph_node->mMetaData = aiMetadata::Alloc(header_->numtransitions * header_->numtransitions); 1199| 0| for (unsigned int i = 0; i < md->mNumProperties; ++i) ------------------ | Branch (1199:30): [True: 0, False: 0] ------------------ 1200| 0| md->Set(i, std::to_string(i), static_cast(ptransitions[i])); 1201| 0|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader16read_attachmentsEv: 1203| 3|void HL1MDLLoader::read_attachments() { 1204| 3| if (!header_->numattachments) { ------------------ | Branch (1204:9): [True: 3, False: 0] ------------------ 1205| 3| return; 1206| 3| } 1207| | 1208| 0| const Attachment_HL1 *pattach = get_buffer_data(header_->attachmentindex, header_->numattachments); 1209| | 1210| 0| aiNode *attachments_node = new aiNode(AI_MDL_HL1_NODE_ATTACHMENTS); ------------------ | | 56| 0|#define AI_MDL_HL1_NODE_ATTACHMENTS "" ------------------ 1211| 0| rootnode_children_.push_back(attachments_node); 1212| 0| attachments_node->mNumChildren = static_cast(header_->numattachments); 1213| 0| attachments_node->mChildren = new aiNode *[attachments_node->mNumChildren]; 1214| | 1215| 0| for (int i = 0; i < header_->numattachments; ++i, ++pattach) { ------------------ | Branch (1215:21): [True: 0, False: 0] ------------------ 1216| 0| aiNode *attachment_node = attachments_node->mChildren[i] = new aiNode(); 1217| 0| attachment_node->mParent = attachments_node; 1218| 0| attachment_node->mMetaData = aiMetadata::Alloc(2); 1219| 0| attachment_node->mMetaData->Set(0, "Position", aiVector3D(pattach->org[0], pattach->org[1], pattach->org[2])); 1220| | // Reference the bone by name. This allows us to search a particular 1221| | // bone by name using aiNode(s). 1222| 0| attachment_node->mMetaData->Set(1, "Bone", temp_bones_[pattach->bone].node->mName); 1223| 0| } 1224| 0|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader13read_hitboxesEv: 1227| 3|void HL1MDLLoader::read_hitboxes() { 1228| 3| if (!header_->numhitboxes) { ------------------ | Branch (1228:9): [True: 1, False: 2] ------------------ 1229| 1| return; 1230| 1| } 1231| | 1232| 2| const Hitbox_HL1 *phitbox = get_buffer_data(header_->hitboxindex, header_->numhitboxes); 1233| | 1234| 2| aiNode *hitboxes_node = new aiNode(AI_MDL_HL1_NODE_HITBOXES); ------------------ | | 57| 2|#define AI_MDL_HL1_NODE_HITBOXES "" ------------------ 1235| 2| rootnode_children_.push_back(hitboxes_node); 1236| 2| hitboxes_node->mNumChildren = static_cast(header_->numhitboxes); 1237| 2| hitboxes_node->mChildren = new aiNode *[hitboxes_node->mNumChildren]; 1238| | 1239| 4| for (int i = 0; i < header_->numhitboxes; ++i, ++phitbox) { ------------------ | Branch (1239:21): [True: 2, False: 2] ------------------ 1240| 2| aiNode *hitbox_node = hitboxes_node->mChildren[i] = new aiNode(); 1241| 2| hitbox_node->mParent = hitboxes_node; 1242| | 1243| 2| aiMetadata *md = hitbox_node->mMetaData = aiMetadata::Alloc(4); 1244| | // Reference the bone by name. This allows us to search a particular 1245| | // bone by name using aiNode(s). 1246| 2| md->Set(0, "Bone", temp_bones_[phitbox->bone].node->mName); 1247| 2| md->Set(1, "HitGroup", phitbox->group); 1248| 2| md->Set(2, "BBMin", aiVector3D(phitbox->bbmin[0], phitbox->bbmin[1], phitbox->bbmin[2])); 1249| 2| md->Set(3, "BBMax", aiVector3D(phitbox->bbmax[0], phitbox->bbmax[1], phitbox->bbmax[2])); 1250| 2| } 1251| 2|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader21read_bone_controllersEv: 1254| 3|void HL1MDLLoader::read_bone_controllers() { 1255| 3| if (!header_->numbonecontrollers) { ------------------ | Branch (1255:9): [True: 3, False: 0] ------------------ 1256| 3| return; 1257| 3| } 1258| | 1259| 0| const BoneController_HL1 *pbonecontroller = get_buffer_data( 1260| 0| header_->bonecontrollerindex, 1261| 0| header_->numbonecontrollers); 1262| | 1263| 0| aiNode *bones_controller_node = new aiNode(AI_MDL_HL1_NODE_BONE_CONTROLLERS); ------------------ | | 52| 0|#define AI_MDL_HL1_NODE_BONE_CONTROLLERS "" ------------------ 1264| 0| rootnode_children_.push_back(bones_controller_node); 1265| 0| bones_controller_node->mNumChildren = static_cast(header_->numbonecontrollers); 1266| 0| bones_controller_node->mChildren = new aiNode *[bones_controller_node->mNumChildren]; 1267| | 1268| 0| for (int i = 0; i < header_->numbonecontrollers; ++i, ++pbonecontroller) { ------------------ | Branch (1268:21): [True: 0, False: 0] ------------------ 1269| 0| aiNode *bone_controller_node = bones_controller_node->mChildren[i] = new aiNode(); 1270| 0| bone_controller_node->mParent = bones_controller_node; 1271| | 1272| 0| aiMetadata *md = bone_controller_node->mMetaData = aiMetadata::Alloc(5); 1273| | // Reference the bone by name. This allows us to search a particular 1274| | // bone by name using aiNode(s). 1275| 0| md->Set(0, "Bone", temp_bones_[pbonecontroller->bone].node->mName); 1276| 0| md->Set(1, "MotionFlags", pbonecontroller->type); 1277| 0| md->Set(2, "Start", pbonecontroller->start); 1278| 0| md->Set(3, "End", pbonecontroller->end); 1279| 0| md->Set(4, "Channel", pbonecontroller->index); 1280| 0| } 1281| 0|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader16read_global_infoEv: 1284| 3|void HL1MDLLoader::read_global_info() { 1285| 3| aiNode *global_info_node = new aiNode(AI_MDL_HL1_NODE_GLOBAL_INFO); ------------------ | | 58| 3|#define AI_MDL_HL1_NODE_GLOBAL_INFO "" ------------------ 1286| 3| rootnode_children_.push_back(global_info_node); 1287| | 1288| 3| aiMetadata *md = global_info_node->mMetaData = aiMetadata::Alloc(import_settings_.read_misc_global_info ? 16 : 11); ------------------ | Branch (1288:70): [True: 3, False: 0] ------------------ 1289| 3| md->Set(0, "Version", AI_MDL_HL1_VERSION); ------------------ | | 540| 3|#define AI_MDL_HL1_VERSION 10 ------------------ 1290| 3| md->Set(1, "NumBodyparts", header_->numbodyparts); 1291| 3| md->Set(2, "NumModels", total_models_); 1292| 3| md->Set(3, "NumBones", header_->numbones); 1293| 3| md->Set(4, "NumAttachments", import_settings_.read_attachments ? header_->numattachments : 0); ------------------ | Branch (1293:34): [True: 3, False: 0] ------------------ 1294| 3| md->Set(5, "NumSkinFamilies", texture_header_->numskinfamilies); 1295| 3| md->Set(6, "NumHitboxes", import_settings_.read_hitboxes ? header_->numhitboxes : 0); ------------------ | Branch (1295:31): [True: 3, False: 0] ------------------ 1296| 3| md->Set(7, "NumBoneControllers", import_settings_.read_bone_controllers ? header_->numbonecontrollers : 0); ------------------ | Branch (1296:38): [True: 3, False: 0] ------------------ 1297| 3| md->Set(8, "NumSequences", import_settings_.read_animations ? header_->numseq : 0); ------------------ | Branch (1297:32): [True: 3, False: 0] ------------------ 1298| 3| md->Set(9, "NumBlendControllers", import_settings_.read_blend_controllers ? num_blend_controllers_ : 0); ------------------ | Branch (1298:39): [True: 3, False: 0] ------------------ 1299| 3| md->Set(10, "NumTransitionNodes", import_settings_.read_sequence_transitions ? header_->numtransitions : 0); ------------------ | Branch (1299:39): [True: 3, False: 0] ------------------ 1300| | 1301| 3| if (import_settings_.read_misc_global_info) { ------------------ | Branch (1301:9): [True: 3, False: 0] ------------------ 1302| 3| md->Set(11, "EyePosition", aiVector3D(header_->eyeposition[0], header_->eyeposition[1], header_->eyeposition[2])); 1303| 3| md->Set(12, "HullMin", aiVector3D(header_->min[0], header_->min[1], header_->min[2])); 1304| 3| md->Set(13, "HullMax", aiVector3D(header_->max[0], header_->max[1], header_->max[2])); 1305| 3| md->Set(14, "CollisionMin", aiVector3D(header_->bbmin[0], header_->bbmin[1], header_->bbmin[2])); 1306| 3| md->Set(15, "CollisionMax", aiVector3D(header_->bbmax[0], header_->bbmax[1], header_->bbmax[2])); 1307| 3| } 1308| 3|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader18extract_anim_valueEPKNS1_13AnimValue_HL1EifRf: 1328| 684| int frame, float bone_scale, ai_real &value) { 1329| 684| int k = frame; 1330| | 1331| | // find span of values that includes the frame we want 1332| 847| while (panimvalue->num.total <= k) { ------------------ | Branch (1332:12): [True: 163, False: 684] ------------------ 1333| 163| k -= panimvalue->num.total; 1334| 163| panimvalue += panimvalue->num.valid + 1; 1335| 163| } 1336| | 1337| | // Bah, missing blend! 1338| 684| if (panimvalue->num.valid > k) { ------------------ | Branch (1338:9): [True: 670, False: 14] ------------------ 1339| 670| value = panimvalue[k + 1].value * bone_scale; 1340| 670| } else { 1341| 14| value = panimvalue[panimvalue->num.valid].value * bone_scale; 1342| 14| } 1343| 684|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader25get_num_blend_controllersEiRi: 1347| 7|bool HL1MDLLoader::get_num_blend_controllers(const int num_blend_animations, int &num_blend_controllers) { 1348| | 1349| 7| switch (num_blend_animations) { 1350| 6| case SequenceBlendMode_HL1::NoBlend: ------------------ | Branch (1350:9): [True: 6, False: 1] ------------------ 1351| 6| num_blend_controllers = 0; 1352| 6| return true; 1353| 0| case SequenceBlendMode_HL1::TwoWayBlending: ------------------ | Branch (1353:9): [True: 0, False: 7] ------------------ 1354| 0| num_blend_controllers = 1; 1355| 0| return true; 1356| 0| case SequenceBlendMode_HL1::FourWayBlending: ------------------ | Branch (1356:9): [True: 0, False: 7] ------------------ 1357| 0| num_blend_controllers = 2; 1358| 0| return true; 1359| 1| default: ------------------ | Branch (1359:9): [True: 1, False: 6] ------------------ 1360| 1| num_blend_controllers = 0; 1361| | ASSIMP_LOG_WARN(MDL_HALFLIFE_LOG_HEADER "Unsupported number of blend animations (", num_blend_animations, ")"); 1362| 1| return false; 1363| 7| } 1364| 7|} HL1MDLLoader.cpp:_ZZN6Assimp3MDL8HalfLife12HL1MDLLoader11read_meshesEvENK3$_0clEis: 688| 608| auto AddTrivertToBone = [&](int bone, short trivert_index) { 689| 608| if (bone_triverts.count(bone) == 0) ------------------ | Branch (689:13): [True: 21, False: 587] ------------------ 690| 21| bone_triverts.insert({ bone, std::set{ trivert_index }}); 691| 587| else 692| 587| bone_triverts[bone].insert(trivert_index); 693| 608| }; HL1MDLLoader.cpp:_ZZN6Assimp3MDL8HalfLife12HL1MDLLoader11read_meshesEvENK3$_1clERKNS1_7TrivertEi: 699| 206| auto AddSimilarTrivert = [&](const Trivert &trivert, const int bone) { 700| 206| HL1MeshTrivert new_trivert(trivert); 701| 206| new_trivert.localindex = static_cast(mesh_triverts_indices.size()); 702| | 703| 206| short new_trivert_index = static_cast(triverts.size()); 704| | 705| 206| if (triverts_similars.count(trivert.vertindex) == 0) ------------------ | Branch (705:13): [True: 160, False: 46] ------------------ 706| 160| triverts_similars.insert({ trivert.vertindex, std::set{ new_trivert_index }}); 707| 46| else 708| 46| triverts_similars[trivert.vertindex].insert(new_trivert_index); 709| | 710| 206| triverts.push_back(new_trivert); 711| | 712| 206| mesh_triverts_indices.push_back(new_trivert_index); 713| 206| tricmds.push_back(new_trivert.localindex); 714| 206| AddTrivertToBone(bone, new_trivert.localindex); 715| 206| }; _ZN6Assimp3MDL8HalfLife12HL1MDLLoader8TempBoneC2Ev: 231| 22| node(nullptr), 232| 22| absolute_transform(), 233| 22| offset_matrix(), 234| 22| children() {} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader15get_buffer_dataINS1_10Header_HL1EEEPKT_ii: 290| 4|const DataType *HL1MDLLoader::get_buffer_data(int offset, int elements) { 291| 4| return buffer_.get_data(offset, elements); 292| 4|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader23get_texture_buffer_dataINS1_10Header_HL1EEEPKT_ii: 276| 4|const DataType *HL1MDLLoader::get_texture_buffer_data(int offset, int elements) { 277| 4| return texture_buffer_.get_data(offset, elements); 278| 4|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader21load_file_into_bufferINS1_18SequenceHeader_HL1EEEvRKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERNS1_13HL1DataBufferE: 253| 9|void HL1MDLLoader::load_file_into_buffer(const std::string &file_path, HL1DataBuffer &buffer) { 254| 9| if (!io_->Exists(file_path)) ------------------ | Branch (254:9): [True: 0, False: 9] ------------------ 255| 0| throw DeadlyImportError("Missing file ", DefaultIOSystem::fileName(file_path), "."); 256| | 257| 9| std::unique_ptr file(io_->Open(file_path)); 258| | 259| 9| if (file == nullptr) { ------------------ | Branch (259:9): [True: 0, False: 9] ------------------ 260| 0| throw DeadlyImportError("Failed to open MDL file ", DefaultIOSystem::fileName(file_path), "."); 261| 0| } 262| | 263| 9| const size_t file_size = file->FileSize(); 264| 9| if (file_size < sizeof(MDLFileHeader)) { ------------------ | Branch (264:9): [True: 0, False: 9] ------------------ 265| 0| throw DeadlyImportError("MDL file is too small."); 266| 0| } 267| | 268| 9| std::unique_ptr data(new unsigned char[1 + file_size]); 269| 9| file->Read(data.get(), 1, file_size); 270| 9| data[file_size] = '\0'; 271| | 272| 9| buffer = HL1DataBuffer::owning(std::move(data), file_size); 273| 9|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader20get_anim_buffer_dataINS1_18SequenceHeader_HL1EEEPKT_iii: 281| 9|const DataType *HL1MDLLoader::get_anim_buffer_data(int animation, int offset, int elements) { 282| 9| if (animation < 0 || animation >= num_sequence_groups_) { ------------------ | Branch (282:9): [True: 0, False: 9] | Branch (282:26): [True: 0, False: 9] ------------------ 283| 0| throw DeadlyImportError("MDL file contains invalid sequence group index (", animation, ")"); 284| 0| } 285| | 286| 9| return anim_buffers_[animation].get_data(offset, elements); 287| 9|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader23get_texture_buffer_dataINS1_11Texture_HL1EEEPKT_ii: 276| 8|const DataType *HL1MDLLoader::get_texture_buffer_data(int offset, int elements) { 277| 8| return texture_buffer_.get_data(offset, elements); 278| 8|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader23get_texture_buffer_dataIhEEPKT_ii: 276| 8|const DataType *HL1MDLLoader::get_texture_buffer_data(int offset, int elements) { 277| 8| return texture_buffer_.get_data(offset, elements); 278| 8|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader23get_texture_buffer_dataIsEEPKT_ii: 276| 4|const DataType *HL1MDLLoader::get_texture_buffer_data(int offset, int elements) { 277| 4| return texture_buffer_.get_data(offset, elements); 278| 4|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader15get_buffer_dataINS1_8Bone_HL1EEEPKT_ii: 290| 9|const DataType *HL1MDLLoader::get_buffer_data(int offset, int elements) { 291| 9| return buffer_.get_data(offset, elements); 292| 9|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader15get_buffer_dataINS1_12Bodypart_HL1EEEPKT_ii: 290| 12|const DataType *HL1MDLLoader::get_buffer_data(int offset, int elements) { 291| 12| return buffer_.get_data(offset, elements); 292| 12|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader15get_buffer_dataINS1_9Model_HL1EEEPKT_ii: 290| 12|const DataType *HL1MDLLoader::get_buffer_data(int offset, int elements) { 291| 12| return buffer_.get_data(offset, elements); 292| 12|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader15get_buffer_dataINS1_8Mesh_HL1EEEPKT_ii: 290| 3|const DataType *HL1MDLLoader::get_buffer_data(int offset, int elements) { 291| 3| return buffer_.get_data(offset, elements); 292| 3|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader15get_buffer_dataIhEEPKT_ii: 290| 6|const DataType *HL1MDLLoader::get_buffer_data(int offset, int elements) { 291| 6| return buffer_.get_data(offset, elements); 292| 6|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader15get_buffer_dataIA3_fEEPKT_ii: 290| 6|const DataType *HL1MDLLoader::get_buffer_data(int offset, int elements) { 291| 6| return buffer_.get_data(offset, elements); 292| 6|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader15get_buffer_dataINS1_16SequenceDesc_HL1EEEPKT_ii: 290| 11|const DataType *HL1MDLLoader::get_buffer_data(int offset, int elements) { 291| 11| return buffer_.get_data(offset, elements); 292| 11|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader15get_buffer_dataINS1_17SequenceGroup_HL1EEEPKT_ii: 290| 10|const DataType *HL1MDLLoader::get_buffer_data(int offset, int elements) { 291| 10| return buffer_.get_data(offset, elements); 292| 10|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader15get_buffer_dataINS1_19AnimValueOffset_HL1EEEPKT_ii: 290| 3|const DataType *HL1MDLLoader::get_buffer_data(int offset, int elements) { 291| 3| return buffer_.get_data(offset, elements); 292| 3|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader20get_anim_buffer_dataINS1_19AnimValueOffset_HL1EEEPKT_iii: 281| 2|const DataType *HL1MDLLoader::get_anim_buffer_data(int animation, int offset, int elements) { 282| 2| if (animation < 0 || animation >= num_sequence_groups_) { ------------------ | Branch (282:9): [True: 0, False: 2] | Branch (282:26): [True: 0, False: 2] ------------------ 283| 0| throw DeadlyImportError("MDL file contains invalid sequence group index (", animation, ")"); 284| 0| } 285| | 286| 2| return anim_buffers_[animation].get_data(offset, elements); 287| 2|} _ZN6Assimp3MDL8HalfLife12HL1MDLLoader15get_buffer_dataINS1_10Hitbox_HL1EEEPKT_ii: 290| 2|const DataType *HL1MDLLoader::get_buffer_data(int offset, int elements) { 291| 2| return buffer_.get_data(offset, elements); 292| 2|} _ZN6Assimp3MDL8HalfLife14HL1MeshTrivertaSERKNS1_7TrivertE: 105| 402| inline HL1MeshTrivert &operator=(const Trivert &other) { 106| 402| vertindex = other.vertindex; 107| 402| normindex = other.normindex; 108| 402| s = other.s; 109| 402| t = other.t; 110| 402| return *this; 111| 402| } _ZNK6Assimp3MDL8HalfLife14HL1MeshTriverteqERKNS1_7TrivertE: 82| 672| inline bool operator==(const Trivert &a) const { 83| 672| return vertindex == a.vertindex && ------------------ | Branch (83:16): [True: 672, False: 0] ------------------ 84| 672| normindex == a.normindex && ------------------ | Branch (84:16): [True: 458, False: 214] ------------------ 85| 458| s == a.s && ------------------ | Branch (85:16): [True: 458, False: 0] ------------------ 86| 458| t == a.t; ------------------ | Branch (86:16): [True: 420, False: 38] ------------------ 87| 672| } _ZN6Assimp3MDL8HalfLife14HL1MeshTrivertC2ERKNS1_7TrivertE: 75| 206| vertindex(a.vertindex), 76| 206| normindex(a.normindex), 77| 206| s(a.s), 78| 206| t(a.t), 79| 206| localindex(-1) { 80| 206| } _ZN6Assimp3MDL8HalfLife14HL1MeshTrivertC2Ev: 59| 402| vertindex(-1), 60| 402| normindex(-1), 61| 402| s(0), 62| 402| t(0), 63| 402| localindex(-1) { 64| 402| } _ZN6Assimp3MDL8HalfLife19UniqueNameGeneratorC2Ev: 57| 4| template_name_("unnamed"), 58| 4| separator_("_") { 59| 4|} _ZN6Assimp3MDL8HalfLife19UniqueNameGeneratorD2Ev: 71| 4|UniqueNameGenerator::~UniqueNameGenerator() = default; _ZN6Assimp3MDL8HalfLife19UniqueNameGenerator11make_uniqueERNSt3__16vectorINS3_12basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEENS8_ISA_EEEE: 73| 20|void UniqueNameGenerator::make_unique(std::vector &names) { 74| 20| struct DuplicateInfo { 75| 20| DuplicateInfo() : 76| 20| indices(), 77| 20| next_id(0) { 78| 20| } 79| | 80| 20| std::list indices; 81| 20| size_t next_id; 82| 20| }; 83| | 84| 20| std::vector empty_names_indices; 85| 20| std::vector template_name_duplicates; 86| 20| std::map names_to_duplicates; 87| | 88| 20| const std::string template_name_with_separator(template_name_ + separator_); 89| | 90| 20| auto format_name = [&](const std::string &base_name, size_t id) -> std::string { 91| 20| return base_name + separator_ + std::to_string(id); 92| 20| }; 93| | 94| 20| auto generate_unique_name = [&](const std::string &base_name) -> std::string { 95| 20| auto *duplicate_info = &names_to_duplicates[base_name]; 96| | 97| 20| std::string new_name; 98| | 99| 20| bool found_identical_name; 100| 20| bool tried_with_base_name_only = false; 101| 20| do { 102| | // Assume that no identical name exists. 103| 20| found_identical_name = false; 104| | 105| 20| if (!tried_with_base_name_only) { 106| | // First try with only the base name. 107| 20| new_name = base_name; 108| 20| } else { 109| | // Create the name expected to be unique. 110| 20| new_name = format_name(base_name, duplicate_info->next_id); 111| 20| } 112| | 113| | // Check in the list of duplicates for an identical name. 114| 20| for (size_t i = 0; 115| 20| i < names.size() && 116| 20| !found_identical_name; 117| 20| ++i) { 118| 20| if (new_name == names[i]) 119| 20| found_identical_name = true; 120| 20| } 121| | 122| 20| if (tried_with_base_name_only) 123| 20| ++duplicate_info->next_id; 124| | 125| 20| tried_with_base_name_only = true; 126| | 127| 20| } while (found_identical_name); 128| | 129| 20| return new_name; 130| 20| }; 131| | 132| 74| for (size_t i = 0; i < names.size(); ++i) { ------------------ | Branch (132:24): [True: 54, False: 20] ------------------ 133| | // Check for empty names. 134| 54| if (names[i].find_first_not_of(' ') == std::string::npos) { ------------------ | Branch (134:13): [True: 10, False: 44] ------------------ 135| 10| empty_names_indices.push_back(i); 136| 10| continue; 137| 10| } 138| | 139| | /* Check for potential duplicate. 140| | a) Either if this name is the same as the template name or 141| | b)