vrshoot: b2f14e535253 libs/assimp/ColladaLoader.cpp

475 DefaultLogger::get()->warn( boost::str( boost::format( "Collada: No material specified for subgroup <%s> in geometry <%s>.") % submesh.mMaterial % mid.mMeshOrController));

476 if( !mid.mMaterials.empty() )

477 meshMaterial = mid.mMaterials.begin()->second.mMatName;

478 }

479

480 // OK ... here the *real* fun starts ... we have the vertex-input-to-effect-semantic-table

481 // given. The only mapping stuff which we do actually support is the UV channel.

482 std::map<std::string, size_t>::const_iterator matIt = mMaterialIndexByName.find( meshMaterial);

483 unsigned int matIdx;

484 if( matIt != mMaterialIndexByName.end())

485 matIdx = matIt->second;

486 else

487 matIdx = 0;

488

489 if (table && !table->mMap.empty() ) {

490 std::pair<Collada::Effect*, aiMaterial*>& mat = newMats[matIdx];

491

492 // Iterate through all texture channels assigned to the effect and

493 // check whether we have mapping information for it.

494 ApplyVertexToEffectSemanticMapping(mat.first->mTexDiffuse, *table);

495 ApplyVertexToEffectSemanticMapping(mat.first->mTexAmbient, *table);

496 ApplyVertexToEffectSemanticMapping(mat.first->mTexSpecular, *table);

497 ApplyVertexToEffectSemanticMapping(mat.first->mTexEmissive, *table);

498 ApplyVertexToEffectSemanticMapping(mat.first->mTexTransparent,*table);

499 ApplyVertexToEffectSemanticMapping(mat.first->mTexBump, *table);

500 }

501

502 // built lookup index of the Mesh-Submesh-Material combination

503 ColladaMeshIndex index( mid.mMeshOrController, sm, meshMaterial);

504

505 // if we already have the mesh at the library, just add its index to the node's array

506 std::map<ColladaMeshIndex, size_t>::const_iterator dstMeshIt = mMeshIndexByID.find( index);

507 if( dstMeshIt != mMeshIndexByID.end()) {

508 newMeshRefs.push_back( dstMeshIt->second);

509 }

510 else

511 {

512 // else we have to add the mesh to the collection and store its newly assigned index at the node

513 aiMesh* dstMesh = CreateMesh( pParser, srcMesh, submesh, srcController, vertexStart, faceStart);

514

515 // store the mesh, and store its new index in the node

516 newMeshRefs.push_back( mMeshes.size());

517 mMeshIndexByID[index] = mMeshes.size();

518 mMeshes.push_back( dstMesh);

519 vertexStart += dstMesh->mNumVertices; faceStart += submesh.mNumFaces;

520

521 // assign the material index

522 dstMesh->mMaterialIndex = matIdx;

523 dstMesh->mName = mid.mMeshOrController;

524 }

525 }

526 }

527

528 // now place all mesh references we gathered in the target node

529 pTarget->mNumMeshes = newMeshRefs.size();

530 if( newMeshRefs.size())

531 {

532 pTarget->mMeshes = new unsigned int[pTarget->mNumMeshes];

533 std::copy( newMeshRefs.begin(), newMeshRefs.end(), pTarget->mMeshes);

534 }

535 }

536

537 // ------------------------------------------------------------------------------------------------

538 // Creates a mesh for the given ColladaMesh face subset and returns the newly created mesh

539 aiMesh* ColladaLoader::CreateMesh( const ColladaParser& pParser, const Collada::Mesh* pSrcMesh, const Collada::SubMesh& pSubMesh,

540 const Collada::Controller* pSrcController, size_t pStartVertex, size_t pStartFace)

541 {

542 aiMesh* dstMesh = new aiMesh;

543

544 // count the vertices addressed by its faces

545 const size_t numVertices = std::accumulate( pSrcMesh->mFaceSize.begin() + pStartFace,

546 pSrcMesh->mFaceSize.begin() + pStartFace + pSubMesh.mNumFaces, 0);

547

548 // copy positions

549 dstMesh->mNumVertices = numVertices;

550 dstMesh->mVertices = new aiVector3D[numVertices];

551 std::copy( pSrcMesh->mPositions.begin() + pStartVertex, pSrcMesh->mPositions.begin() +

552 pStartVertex + numVertices, dstMesh->mVertices);

553

554 // normals, if given. HACK: (thom) Due to the glorious Collada spec we never

555 // know if we have the same number of normals as there are positions. So we

556 // also ignore any vertex attribute if it has a different count

557 if( pSrcMesh->mNormals.size() >= pStartVertex + numVertices)

558 {

559 dstMesh->mNormals = new aiVector3D[numVertices];

560 std::copy( pSrcMesh->mNormals.begin() + pStartVertex, pSrcMesh->mNormals.begin() +

561 pStartVertex + numVertices, dstMesh->mNormals);

562 }

563

564 // tangents, if given.

565 if( pSrcMesh->mTangents.size() >= pStartVertex + numVertices)

566 {

567 dstMesh->mTangents = new aiVector3D[numVertices];

568 std::copy( pSrcMesh->mTangents.begin() + pStartVertex, pSrcMesh->mTangents.begin() +

569 pStartVertex + numVertices, dstMesh->mTangents);

570 }

571

572 // bitangents, if given.

573 if( pSrcMesh->mBitangents.size() >= pStartVertex + numVertices)

574 {

575 dstMesh->mBitangents = new aiVector3D[numVertices];

576 std::copy( pSrcMesh->mBitangents.begin() + pStartVertex, pSrcMesh->mBitangents.begin() +

577 pStartVertex + numVertices, dstMesh->mBitangents);

578 }

579

580 // same for texturecoords, as many as we have

581 // empty slots are not allowed, need to pack and adjust UV indexes accordingly

582 for( size_t a = 0, real = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++)

583 {

584 if( pSrcMesh->mTexCoords[a].size() >= pStartVertex + numVertices)

585 {

586 dstMesh->mTextureCoords[real] = new aiVector3D[numVertices];

587 for( size_t b = 0; b < numVertices; ++b)

588 dstMesh->mTextureCoords[real][b] = pSrcMesh->mTexCoords[a][pStartVertex+b];

589

590 dstMesh->mNumUVComponents[real] = pSrcMesh->mNumUVComponents[a];

591 ++real;

592 }

593 }

594

595 // same for vertex colors, as many as we have. again the same packing to avoid empty slots

596 for( size_t a = 0, real = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++)

597 {

598 if( pSrcMesh->mColors[a].size() >= pStartVertex + numVertices)

599 {

600 dstMesh->mColors[real] = new aiColor4D[numVertices];

601 std::copy( pSrcMesh->mColors[a].begin() + pStartVertex, pSrcMesh->mColors[a].begin() + pStartVertex + numVertices,dstMesh->mColors[real]);

602 ++real;

603 }

604 }

605

606 // create faces. Due to the fact that each face uses unique vertices, we can simply count up on each vertex

607 size_t vertex = 0;

608 dstMesh->mNumFaces = pSubMesh.mNumFaces;

609 dstMesh->mFaces = new aiFace[dstMesh->mNumFaces];

610 for( size_t a = 0; a < dstMesh->mNumFaces; ++a)

611 {

612 size_t s = pSrcMesh->mFaceSize[ pStartFace + a];

613 aiFace& face = dstMesh->mFaces[a];

614 face.mNumIndices = s;

615 face.mIndices = new unsigned int[s];

616 for( size_t b = 0; b < s; ++b)

617 face.mIndices[b] = vertex++;

618 }

619

620 // create bones if given

621 if( pSrcController)

622 {

623 // refuse if the vertex count does not match

624 // if( pSrcController->mWeightCounts.size() != dstMesh->mNumVertices)

625 // throw DeadlyImportError( "Joint Controller vertex count does not match mesh vertex count");

626

627 // resolve references - joint names

628 const Collada::Accessor& jointNamesAcc = pParser.ResolveLibraryReference( pParser.mAccessorLibrary, pSrcController->mJointNameSource);

629 const Collada::Data& jointNames = pParser.ResolveLibraryReference( pParser.mDataLibrary, jointNamesAcc.mSource);

630 // joint offset matrices

631 const Collada::Accessor& jointMatrixAcc = pParser.ResolveLibraryReference( pParser.mAccessorLibrary, pSrcController->mJointOffsetMatrixSource);

632 const Collada::Data& jointMatrices = pParser.ResolveLibraryReference( pParser.mDataLibrary, jointMatrixAcc.mSource);

633 // joint vertex_weight name list - should refer to the same list as the joint names above. If not, report and reconsider

634 const Collada::Accessor& weightNamesAcc = pParser.ResolveLibraryReference( pParser.mAccessorLibrary, pSrcController->mWeightInputJoints.mAccessor);

635 if( &weightNamesAcc != &jointNamesAcc)

636 throw DeadlyImportError( "Temporary implementational lazyness. If you read this, please report to the author.");

637 // vertex weights

638 const Collada::Accessor& weightsAcc = pParser.ResolveLibraryReference( pParser.mAccessorLibrary, pSrcController->mWeightInputWeights.mAccessor);

639 const Collada::Data& weights = pParser.ResolveLibraryReference( pParser.mDataLibrary, weightsAcc.mSource);

640

641 if( !jointNames.mIsStringArray || jointMatrices.mIsStringArray || weights.mIsStringArray)

642 throw DeadlyImportError( "Data type mismatch while resolving mesh joints");

643 // sanity check: we rely on the vertex weights always coming as pairs of BoneIndex-WeightIndex

644 if( pSrcController->mWeightInputJoints.mOffset != 0 || pSrcController->mWeightInputWeights.mOffset != 1)

645 throw DeadlyImportError( "Unsupported vertex_weight addressing scheme. ");

646

647 // create containers to collect the weights for each bone

648 size_t numBones = jointNames.mStrings.size();

649 std::vector<std::vector<aiVertexWeight> > dstBones( numBones);

650

651 // build a temporary array of pointers to the start of each vertex's weights

652 typedef std::vector< std::pair<size_t, size_t> > IndexPairVector;

653 std::vector<IndexPairVector::const_iterator> weightStartPerVertex;

654 weightStartPerVertex.resize(pSrcController->mWeightCounts.size(),pSrcController->mWeights.end());

655

656 IndexPairVector::const_iterator pit = pSrcController->mWeights.begin();

657 for( size_t a = 0; a < pSrcController->mWeightCounts.size(); ++a)

658 {

659 weightStartPerVertex[a] = pit;

660 pit += pSrcController->mWeightCounts[a];

661 }

662

663 // now for each vertex put the corresponding vertex weights into each bone's weight collection

664 for( size_t a = pStartVertex; a < pStartVertex + numVertices; ++a)

665 {

666 // which position index was responsible for this vertex? that's also the index by which

667 // the controller assigns the vertex weights

668 size_t orgIndex = pSrcMesh->mFacePosIndices[a];

669 // find the vertex weights for this vertex

670 IndexPairVector::const_iterator iit = weightStartPerVertex[orgIndex];

671 size_t pairCount = pSrcController->mWeightCounts[orgIndex];

672

673 for( size_t b = 0; b < pairCount; ++b, ++iit)

674 {

675 size_t jointIndex = iit->first;

676 size_t vertexIndex = iit->second;

677

678 float weight = ReadFloat( weightsAcc, weights, vertexIndex, 0);

679

680 // one day I gonna kill that XSI Collada exporter

681 if( weight > 0.0f)

682 {

683 aiVertexWeight w;

684 w.mVertexId = a - pStartVertex;

685 w.mWeight = weight;

686 dstBones[jointIndex].push_back( w);

687 }

688 }

689 }

690

691 // count the number of bones which influence vertices of the current submesh

692 size_t numRemainingBones = 0;

693 for( std::vector<std::vector<aiVertexWeight> >::const_iterator it = dstBones.begin(); it != dstBones.end(); ++it)

694 if( it->size() > 0)

695 numRemainingBones++;

696

697 // create bone array and copy bone weights one by one

698 dstMesh->mNumBones = numRemainingBones;

699 dstMesh->mBones = new aiBone*[numRemainingBones];

700 size_t boneCount = 0;

701 for( size_t a = 0; a < numBones; ++a)

702 {

703 // omit bones without weights

704 if( dstBones[a].size() == 0)

705 continue;

706

707 // create bone with its weights

708 aiBone* bone = new aiBone;

709 bone->mName = ReadString( jointNamesAcc, jointNames, a);

710 bone->mOffsetMatrix.a1 = ReadFloat( jointMatrixAcc, jointMatrices, a, 0);

711 bone->mOffsetMatrix.a2 = ReadFloat( jointMatrixAcc, jointMatrices, a, 1);

712 bone->mOffsetMatrix.a3 = ReadFloat( jointMatrixAcc, jointMatrices, a, 2);

713 bone->mOffsetMatrix.a4 = ReadFloat( jointMatrixAcc, jointMatrices, a, 3);

714 bone->mOffsetMatrix.b1 = ReadFloat( jointMatrixAcc, jointMatrices, a, 4);

715 bone->mOffsetMatrix.b2 = ReadFloat( jointMatrixAcc, jointMatrices, a, 5);

716 bone->mOffsetMatrix.b3 = ReadFloat( jointMatrixAcc, jointMatrices, a, 6);

717 bone->mOffsetMatrix.b4 = ReadFloat( jointMatrixAcc, jointMatrices, a, 7);

718 bone->mOffsetMatrix.c1 = ReadFloat( jointMatrixAcc, jointMatrices, a, 8);

719 bone->mOffsetMatrix.c2 = ReadFloat( jointMatrixAcc, jointMatrices, a, 9);

720 bone->mOffsetMatrix.c3 = ReadFloat( jointMatrixAcc, jointMatrices, a, 10);

721 bone->mOffsetMatrix.c4 = ReadFloat( jointMatrixAcc, jointMatrices, a, 11);

722 bone->mNumWeights = dstBones[a].size();

723 bone->mWeights = new aiVertexWeight[bone->mNumWeights];

724 std::copy( dstBones[a].begin(), dstBones[a].end(), bone->mWeights);

725

726 // apply bind shape matrix to offset matrix

727 aiMatrix4x4 bindShapeMatrix;

728 bindShapeMatrix.a1 = pSrcController->mBindShapeMatrix[0];

729 bindShapeMatrix.a2 = pSrcController->mBindShapeMatrix[1];

730 bindShapeMatrix.a3 = pSrcController->mBindShapeMatrix[2];

731 bindShapeMatrix.a4 = pSrcController->mBindShapeMatrix[3];

732 bindShapeMatrix.b1 = pSrcController->mBindShapeMatrix[4];

733 bindShapeMatrix.b2 = pSrcController->mBindShapeMatrix[5];

734 bindShapeMatrix.b3 = pSrcController->mBindShapeMatrix[6];

735 bindShapeMatrix.b4 = pSrcController->mBindShapeMatrix[7];

736 bindShapeMatrix.c1 = pSrcController->mBindShapeMatrix[8];

737 bindShapeMatrix.c2 = pSrcController->mBindShapeMatrix[9];

738 bindShapeMatrix.c3 = pSrcController->mBindShapeMatrix[10];

739 bindShapeMatrix.c4 = pSrcController->mBindShapeMatrix[11];

740 bindShapeMatrix.d1 = pSrcController->mBindShapeMatrix[12];

741 bindShapeMatrix.d2 = pSrcController->mBindShapeMatrix[13];

742 bindShapeMatrix.d3 = pSrcController->mBindShapeMatrix[14];

743 bindShapeMatrix.d4 = pSrcController->mBindShapeMatrix[15];

744 bone->mOffsetMatrix *= bindShapeMatrix;

745

746 // HACK: (thom) Some exporters address the bone nodes by SID, others address them by ID or even name.

747 // Therefore I added a little name replacement here: I search for the bone's node by either name, ID or SID,

748 // and replace the bone's name by the node's name so that the user can use the standard

749 // find-by-name method to associate nodes with bones.

750 const Collada::Node* bnode = FindNode( pParser.mRootNode, bone->mName.data);

751 if( !bnode)

752 bnode = FindNodeBySID( pParser.mRootNode, bone->mName.data);

753

754 // assign the name that we would have assigned for the source node

755 if( bnode)

756 bone->mName.Set( FindNameForNode( bnode));

757 else

758 DefaultLogger::get()->warn( boost::str( boost::format( "ColladaLoader::CreateMesh(): could not find corresponding node for joint \"%s\".") % bone->mName.data));

759

760 // and insert bone

761 dstMesh->mBones[boneCount++] = bone;

762 }

763 }

764

765 return dstMesh;

766 }

767

768 // ------------------------------------------------------------------------------------------------

769 // Stores all meshes in the given scene

770 void ColladaLoader::StoreSceneMeshes( aiScene* pScene)

771 {

772 pScene->mNumMeshes = mMeshes.size();

773 if( mMeshes.size() > 0)

774 {

775 pScene->mMeshes = new aiMesh*[mMeshes.size()];

776 std::copy( mMeshes.begin(), mMeshes.end(), pScene->mMeshes);

777 mMeshes.clear();

778 }

779 }

780

781 // ------------------------------------------------------------------------------------------------

782 // Stores all cameras in the given scene

783 void ColladaLoader::StoreSceneCameras( aiScene* pScene)

784 {

785 pScene->mNumCameras = mCameras.size();

786 if( mCameras.size() > 0)

787 {

788 pScene->mCameras = new aiCamera*[mCameras.size()];

789 std::copy( mCameras.begin(), mCameras.end(), pScene->mCameras);

790 mCameras.clear();

791 }

792 }

793

794 // ------------------------------------------------------------------------------------------------

795 // Stores all lights in the given scene

796 void ColladaLoader::StoreSceneLights( aiScene* pScene)

797 {

798 pScene->mNumLights = mLights.size();

799 if( mLights.size() > 0)

800 {

801 pScene->mLights = new aiLight*[mLights.size()];

802 std::copy( mLights.begin(), mLights.end(), pScene->mLights);

803 mLights.clear();

804 }

805 }

806

807 // ------------------------------------------------------------------------------------------------

808 // Stores all textures in the given scene

809 void ColladaLoader::StoreSceneTextures( aiScene* pScene)

810 {

811 pScene->mNumTextures = mTextures.size();

812 if( mTextures.size() > 0)

813 {

814 pScene->mTextures = new aiTexture*[mTextures.size()];

815 std::copy( mTextures.begin(), mTextures.end(), pScene->mTextures);

816 mTextures.clear();

817 }

818 }

819

820 // ------------------------------------------------------------------------------------------------

821 // Stores all materials in the given scene

822 void ColladaLoader::StoreSceneMaterials( aiScene* pScene)

823 {

824 pScene->mNumMaterials = newMats.size();

825

826 if (newMats.size() > 0) {

827 pScene->mMaterials = new aiMaterial*[newMats.size()];

828 for (unsigned int i = 0; i < newMats.size();++i)

829 pScene->mMaterials[i] = newMats[i].second;

830

831 newMats.clear();

832 }

833 }

834

835 // ------------------------------------------------------------------------------------------------

836 // Stores all animations

837 void ColladaLoader::StoreAnimations( aiScene* pScene, const ColladaParser& pParser)

838 {

839 // recursivly collect all animations from the collada scene

840 StoreAnimations( pScene, pParser, &pParser.mAnims, "");

841

842 // catch special case: many animations with the same length, each affecting only a single node.

843 // we need to unite all those single-node-anims to a proper combined animation

844 for( size_t a = 0; a < mAnims.size(); ++a)

845 {

846 aiAnimation* templateAnim = mAnims[a];

847 if( templateAnim->mNumChannels == 1)

848 {

849 // search for other single-channel-anims with the same duration

850 std::vector<size_t> collectedAnimIndices;

851 for( size_t b = a+1; b < mAnims.size(); ++b)

852 {

853 aiAnimation* other = mAnims[b];

854 if( other->mNumChannels == 1 && other->mDuration == templateAnim->mDuration && other->mTicksPerSecond == templateAnim->mTicksPerSecond )

855 collectedAnimIndices.push_back( b);

856 }

857

858 // if there are other animations which fit the template anim, combine all channels into a single anim

859 if( !collectedAnimIndices.empty() )

860 {

861 aiAnimation* combinedAnim = new aiAnimation();

862 combinedAnim->mName = aiString( std::string( "combinedAnim_") + char( '0' + a));

863 combinedAnim->mDuration = templateAnim->mDuration;

864 combinedAnim->mTicksPerSecond = templateAnim->mTicksPerSecond;

865 combinedAnim->mNumChannels = collectedAnimIndices.size() + 1;

866 combinedAnim->mChannels = new aiNodeAnim*[combinedAnim->mNumChannels];

867 // add the template anim as first channel by moving its aiNodeAnim to the combined animation

868 combinedAnim->mChannels[0] = templateAnim->mChannels[0];

869 templateAnim->mChannels[0] = NULL;

870 delete templateAnim;

871 // combined animation replaces template animation in the anim array

872 mAnims[a] = combinedAnim;

873

874 // move the memory of all other anims to the combined anim and erase them from the source anims

875 for( size_t b = 0; b < collectedAnimIndices.size(); ++b)

876 {

877 aiAnimation* srcAnimation = mAnims[collectedAnimIndices[b]];

878 combinedAnim->mChannels[1 + b] = srcAnimation->mChannels[0];

879 srcAnimation->mChannels[0] = NULL;

880 delete srcAnimation;

881 }

882

883 // in a second go, delete all the single-channel-anims that we've stripped from their channels

884 // back to front to preserve indices - you know, removing an element from a vector moves all elements behind the removed one

885 while( !collectedAnimIndices.empty() )

886 {

887 mAnims.erase( mAnims.begin() + collectedAnimIndices.back());

888 collectedAnimIndices.pop_back();

889 }

890 }

891 }

892 }

893

894 // now store all anims in the scene

895 if( !mAnims.empty())

896 {

897 pScene->mNumAnimations = mAnims.size();

898 pScene->mAnimations = new aiAnimation*[mAnims.size()];

899 std::copy( mAnims.begin(), mAnims.end(), pScene->mAnimations);

900 }

901 }

902

903 // ------------------------------------------------------------------------------------------------

904 // Constructs the animations for the given source anim

905 void ColladaLoader::StoreAnimations( aiScene* pScene, const ColladaParser& pParser, const Collada::Animation* pSrcAnim, const std::string pPrefix)

906 {

907 std::string animName = pPrefix.empty() ? pSrcAnim->mName : pPrefix + "_" + pSrcAnim->mName;

908

909 // create nested animations, if given

910 for( std::vector<Collada::Animation*>::const_iterator it = pSrcAnim->mSubAnims.begin(); it != pSrcAnim->mSubAnims.end(); ++it)

911 StoreAnimations( pScene, pParser, *it, animName);

912

913 // create animation channels, if any

914 if( !pSrcAnim->mChannels.empty())

915 CreateAnimation( pScene, pParser, pSrcAnim, animName);

916 }

917