C++ FlipWindingOrderProcess类代码示例

//.........这里部分代码省略.........
		// generate the output mesh
		aiMesh* pMesh = pScene->mMeshes[m++] = new aiMesh();
		const std::vector<aiVector3D>& vPositions = (*it).vPositions;
		const std::vector<aiColor4D>& vColors = (*it).vColors;

		// check whether we need vertex colors here
		aiColor4D* clrOut = NULL;
		const aiColor4D* clr = NULL;
		for (std::vector<aiColor4D>::const_iterator it2 = (*it).vColors.begin(), end2 = (*it).vColors.end();it2 != end2; ++it2)	{
			
			if ((*it2).r == (*it2).r) /* qnan? */ {
				clrOut = pMesh->mColors[0] = new aiColor4D[vPositions.size()];
				for (unsigned int i = 0; i < vPositions.size();++i)
					clrOut[i] = aiColor4D(0.6f,0.6f,0.6f,1.0f);

				clr = &vColors[0];
				break;
			}
		}

		pMesh->mNumFaces = (unsigned int)vPositions.size() / 4u;
		pMesh->mFaces = new aiFace[pMesh->mNumFaces];

		aiVector3D* vpOut = pMesh->mVertices = new aiVector3D[vPositions.size()];
		const aiVector3D* vp = &vPositions[0];

		for (unsigned int i = 0; i < pMesh->mNumFaces;++i)	{
			aiFace& face = pMesh->mFaces[i];

			// check whether we need four, three or two indices here
			if (vp[1] == vp[2])	{
				face.mNumIndices = 2;
			}
			else if (vp[3] == vp[2])	{
				 face.mNumIndices = 3;
			}
			else face.mNumIndices = 4;
			face.mIndices = new unsigned int[face.mNumIndices];

			for (unsigned int a = 0; a < face.mNumIndices;++a)	{
				*vpOut++ = vp[a];
				if (clr)	{
					if (is_not_qnan( clr[a].r )) {
						*clrOut = clr[a];
					}
					++clrOut;
				}
				face.mIndices[a] = pMesh->mNumVertices++;
			}
			vp += 4;
		}
	}

	// generate the output scene graph
	pScene->mRootNode = new aiNode();
	pScene->mRootNode->mName.Set("<DXF_ROOT>");

	if (1 == pScene->mNumMeshes)	{
		pScene->mRootNode->mMeshes = new unsigned int[ pScene->mRootNode->mNumMeshes = 1 ];
		pScene->mRootNode->mMeshes[0] = 0;
	}
	else
	{
		pScene->mRootNode->mChildren = new aiNode*[ pScene->mRootNode->mNumChildren = pScene->mNumMeshes ];
		for (m = 0; m < pScene->mRootNode->mNumChildren;++m)	{
			aiNode* p = pScene->mRootNode->mChildren[m] = new aiNode();
			p->mName.length = ::strlen( mLayers[m].name );
			strcpy(p->mName.data, mLayers[m].name);

			p->mMeshes = new unsigned int[p->mNumMeshes = 1];
			p->mMeshes[0] = m;
			p->mParent = pScene->mRootNode;
		}
	}

	// generate a default material
	MaterialHelper* pcMat = new MaterialHelper();
	aiString s;
	s.Set(AI_DEFAULT_MATERIAL_NAME);
	pcMat->AddProperty(&s, AI_MATKEY_NAME);

	aiColor4D clrDiffuse(0.6f,0.6f,0.6f,1.0f);
	pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_DIFFUSE);

	clrDiffuse = aiColor4D(1.0f,1.0f,1.0f,1.0f);
	pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_SPECULAR);

	clrDiffuse = aiColor4D(0.05f,0.05f,0.05f,1.0f);
	pcMat->AddProperty(&clrDiffuse,1,AI_MATKEY_COLOR_AMBIENT);

	pScene->mNumMaterials = 1;
	pScene->mMaterials = new aiMaterial*[1];
	pScene->mMaterials[0] = pcMat;

	// flip winding order to be ccw
	FlipWindingOrderProcess flipper;
	flipper.Execute(pScene);

	// --- everything destructs automatically ---
}

//.........这里部分代码省略.........
        else {
            tri.matIndex = static_cast<unsigned int>(nt-materials.begin());
            ++nt->numFaces;
        }
    }

    if (!pScene->mNumMeshes) {
        throw DeadlyImportError("UNREAL: Unable to find valid mesh data");
    }

    // allocate meshes and bind them to the node graph
    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
    pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials = pScene->mNumMeshes];

    nd->mNumMeshes  = pScene->mNumMeshes;
    nd->mMeshes = new unsigned int[nd->mNumMeshes];
    for (unsigned int i = 0; i < pScene->mNumMeshes;++i) {
        aiMesh* m = pScene->mMeshes[i] =  new aiMesh();
        m->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;

        const unsigned int num = materials[i].numFaces;
        m->mFaces            = new aiFace     [num];
        m->mVertices         = new aiVector3D [num*3];
        m->mTextureCoords[0] = new aiVector3D [num*3];

        nd->mMeshes[i] = i;

        // create materials, too
        aiMaterial* mat = new aiMaterial();
        pScene->mMaterials[i] = mat;

        // all white by default - texture rulez
        aiColor3D color(1.f,1.f,1.f);

        aiString s;
        ::sprintf(s.data,"mat%u_tx%u_",i,materials[i].tex);

        // set the two-sided flag
        if (materials[i].type == Unreal::MF_NORMAL_TS) {
            const int twosided = 1;
            mat->AddProperty(&twosided,1,AI_MATKEY_TWOSIDED);
            ::strcat(s.data,"ts_");
        }
        else ::strcat(s.data,"os_");

        // make TRANS faces 90% opaque that RemRedundantMaterials won't catch us
        if (materials[i].type == Unreal::MF_NORMAL_TRANS_TS)    {
            const float opac = 0.9f;
            mat->AddProperty(&opac,1,AI_MATKEY_OPACITY);
            ::strcat(s.data,"tran_");
        }
        else ::strcat(s.data,"opaq_");

        // a special name for the weapon attachment point
        if (materials[i].type == Unreal::MF_WEAPON_PLACEHOLDER) {
            s.length = ::sprintf(s.data,"$WeaponTag$");
            color = aiColor3D(0.f,0.f,0.f);
        }

        // set color and name
        mat->AddProperty(&color,1,AI_MATKEY_COLOR_DIFFUSE);
        s.length = ::strlen(s.data);
        mat->AddProperty(&s,AI_MATKEY_NAME);

        // set texture, if any
        const unsigned int tex = materials[i].tex;
        for (std::vector< std::pair< unsigned int, std::string > >::const_iterator it = textures.begin();it != textures.end();++it) {
            if ((*it).first == tex) {
                s.Set((*it).second);
                mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(0));
                break;
            }
        }
    }

    // fill them.
    for (std::vector<Unreal::Triangle>::iterator it = triangles.begin(), end = triangles.end();it != end; ++it) {
        Unreal::Triangle& tri = *it;
        Unreal::TempMat mat(tri);
        std::vector<Unreal::TempMat>::iterator nt = std::find(materials.begin(),materials.end(),mat);

        aiMesh* mesh = pScene->mMeshes[nt-materials.begin()];
        aiFace& f    = mesh->mFaces[mesh->mNumFaces++];
        f.mIndices   = new unsigned int[f.mNumIndices = 3];

        for (unsigned int i = 0; i < 3;++i,mesh->mNumVertices++) {
            f.mIndices[i] = mesh->mNumVertices;

            mesh->mVertices[mesh->mNumVertices] = vertices[ tri.mVertex[i] ];
            mesh->mTextureCoords[0][mesh->mNumVertices] = aiVector3D( tri.mTex[i][0] / 255.f, 1.f - tri.mTex[i][1] / 255.f, 0.f);
        }
    }

    // convert to RH
    MakeLeftHandedProcess hero;
    hero.Execute(pScene);

    FlipWindingOrderProcess flipper;
    flipper.Execute(pScene);
}

//.........这里部分代码省略.........
    if ( !_meshes.size() ) Fail( "No meshes" );

    //Fix nodes/meshes/bones
    for (size_t i=0;i<_nodes.size();++i ){
        aiNode *node=_nodes[i];

        for ( size_t j=0;j<node->mNumMeshes;++j ){
            aiMesh *mesh=_meshes[node->mMeshes[j]];

            int n_tris=mesh->mNumFaces;
            int n_verts=mesh->mNumVertices=n_tris * 3;

            aiVector3D *mv=mesh->mVertices=new aiVector3D[ n_verts ],*mn=0,*mc=0;
            if ( _vflags & 1 ) mn=mesh->mNormals=new aiVector3D[ n_verts ];
            if ( _tcsets ) mc=mesh->mTextureCoords[0]=new aiVector3D[ n_verts ];

            aiFace *face=mesh->mFaces;

            vector< vector<aiVertexWeight> > vweights( _nodes.size() );

            for ( int i=0;i<n_verts;i+=3 ){
                for ( int j=0;j<3;++j ){
                    Vertex &v=_vertices[face->mIndices[j]];

                    *mv++=v.vertex;
                    if ( mn ) *mn++=v.normal;
                    if ( mc ) *mc++=v.texcoords;

                    face->mIndices[j]=i+j;

                    for ( int k=0;k<4;++k ){
                        if ( !v.weights[k] ) break;

                        int bone=v.bones[k];
                        float weight=v.weights[k];

                        vweights[bone].push_back( aiVertexWeight(i+j,weight) );
                    }
                }
                ++face;
            }

            vector<aiBone*> bones;
            for (size_t i=0;i<vweights.size();++i ){
                vector<aiVertexWeight> &weights=vweights[i];
                if ( !weights.size() ) continue;

                aiBone *bone=new aiBone;
                bones.push_back( bone );

                aiNode *bnode=_nodes[i];

                bone->mName=bnode->mName;
                bone->mNumWeights=weights.size();
                bone->mWeights=to_array( weights );

                aiMatrix4x4 mat=bnode->mTransformation;
                while ( bnode->mParent ){
                    bnode=bnode->mParent;
                    mat=bnode->mTransformation * mat;
                }
                bone->mOffsetMatrix=mat.Inverse();
            }
            mesh->mNumBones=bones.size();
            mesh->mBones=to_array( bones );
        }
    }

    //nodes
    scene->mRootNode=_nodes[0];

    //material
    if ( !_materials.size() ){
        _materials.push_back( new MaterialHelper );
    }
    scene->mNumMaterials=_materials.size();
    scene->mMaterials=to_array( _materials );

    //meshes
    scene->mNumMeshes=_meshes.size();
    scene->mMeshes=to_array( _meshes );

    //animations
    if ( _animations.size()==1 && _nodeAnims.size() ){

        aiAnimation *anim=_animations.back();
        anim->mNumChannels=_nodeAnims.size();
        anim->mChannels=to_array( _nodeAnims );

        scene->mNumAnimations=_animations.size();
        scene->mAnimations=to_array( _animations );
    }

    // convert to RH
    MakeLeftHandedProcess makeleft;
    makeleft.Execute( scene );

    FlipWindingOrderProcess flip;
    flip.Execute( scene );
}

//.........这里部分代码省略.........
	// resolve parenting
	for (std::list<LWS::NodeDesc>::iterator it = nodes.begin(); it != nodes.end(); ++it) {
	
		// check whether there is another node which calls us a parent
		for (std::list<LWS::NodeDesc>::iterator dit = nodes.begin(); dit != nodes.end(); ++dit) {
			if (dit != it && *it == (*dit).parent) {
				if ((*dit).parent_resolved) {
					// fixme: it's still possible to produce an overflow due to cross references ..
					DefaultLogger::get()->error("LWS: Found cross reference in scenegraph");
					continue;
				}

				(*it).children.push_back(&*dit);
				(*dit).parent_resolved = &*it;
			}
		}
	}

	// find out how many nodes have no parent yet
	unsigned int no_parent = 0;
	for (std::list<LWS::NodeDesc>::iterator it = nodes.begin(); it != nodes.end(); ++it) {
		if (!(*it).parent_resolved)
			++ no_parent;
	}
	if (!no_parent)
		throw DeadlyImportError("LWS: Unable to find scene root node");


	// Load all subsequent files
	batch.LoadAll();

	// and build the final output graph by attaching the loaded external
	// files to ourselves. first build a master graph 
	aiScene* master = new aiScene();
	aiNode* nd = master->mRootNode = new aiNode();

	// allocate storage for cameras&lights
	if (num_camera) {
		master->mCameras = new aiCamera*[master->mNumCameras = num_camera];
	}
	aiCamera** cams = master->mCameras;
	if (num_light) {
		master->mLights = new aiLight*[master->mNumLights = num_light];
	}
	aiLight** lights = master->mLights;

	std::vector<AttachmentInfo> attach;
	std::vector<aiNodeAnim*> anims;

	nd->mName.Set("<LWSRoot>");
	nd->mChildren = new aiNode*[no_parent];
	for (std::list<LWS::NodeDesc>::iterator it = nodes.begin(); it != nodes.end(); ++it) {
		if (!(*it).parent_resolved) {
			aiNode* ro = nd->mChildren[ nd->mNumChildren++ ] = new aiNode();
			ro->mParent = nd;

			// ... and build the scene graph. If we encounter object nodes,
			// add then to our attachment table.
			BuildGraph(ro,*it, attach, batch, cams, lights, anims);
		}
	}

	// create a master animation channel for us
	if (anims.size()) {
		master->mAnimations = new aiAnimation*[master->mNumAnimations = 1];
		aiAnimation* anim = master->mAnimations[0] = new aiAnimation();
		anim->mName.Set("LWSMasterAnim");

		// LWS uses seconds as time units, but we convert to frames
		anim->mTicksPerSecond = fps;
		anim->mDuration = last-(first-1); /* fixme ... zero or one-based?*/

		anim->mChannels = new aiNodeAnim*[anim->mNumChannels = anims.size()];
		std::copy(anims.begin(),anims.end(),anim->mChannels);
	}

	// convert the master scene to RH
	MakeLeftHandedProcess monster_cheat;
	monster_cheat.Execute(master);

	// .. ccw
	FlipWindingOrderProcess flipper;
	flipper.Execute(master);

	// OK ... finally build the output graph
	SceneCombiner::MergeScenes(&pScene,master,attach,
		AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES    | (!configSpeedFlag ? (
		AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY | AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES) : 0));

	// Check flags
	if (!pScene->mNumMeshes || !pScene->mNumMaterials) {
		pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;

		if (pScene->mNumAnimations) {
			// construct skeleton mesh
			SkeletonMeshBuilder builder(pScene);
		}
	}

}

// ------------------------------------------------------------------------------------------------
aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const char* pPath,
        unsigned int pPreprocessing, const ExportProperties* pProperties) {
    ASSIMP_BEGIN_EXCEPTION_REGION();

    // when they create scenes from scratch, users will likely create them not in verbose
    // format. They will likely not be aware that there is a flag in the scene to indicate
    // this, however. To avoid surprises and bug reports, we check for duplicates in
    // meshes upfront.
    const bool is_verbose_format = !(pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) || IsVerboseFormat(pScene);

    pimpl->mProgressHandler->UpdateFileWrite(0, 4);

    pimpl->mError = "";
    for (size_t i = 0; i < pimpl->mExporters.size(); ++i) {
        const Exporter::ExportFormatEntry& exp = pimpl->mExporters[i];
        if (!strcmp(exp.mDescription.id,pFormatId)) {
            try {
                // Always create a full copy of the scene. We might optimize this one day,
                // but for now it is the most pragmatic way.
                aiScene* scenecopy_tmp = nullptr;
                SceneCombiner::CopyScene(&scenecopy_tmp,pScene);

                pimpl->mProgressHandler->UpdateFileWrite(1, 4);

                std::unique_ptr<aiScene> scenecopy(scenecopy_tmp);
                const ScenePrivateData* const priv = ScenePriv(pScene);

                // steps that are not idempotent, i.e. we might need to run them again, usually to get back to the
                // original state before the step was applied first. When checking which steps we don't need
                // to run, those are excluded.
                const unsigned int nonIdempotentSteps = aiProcess_FlipWindingOrder | aiProcess_FlipUVs | aiProcess_MakeLeftHanded;

                // Erase all pp steps that were already applied to this scene
                const unsigned int pp = (exp.mEnforcePP | pPreprocessing) & ~(priv && !priv->mIsCopy
                    ? (priv->mPPStepsApplied & ~nonIdempotentSteps)
                    : 0u);

                // If no extra post-processing was specified, and we obtained this scene from an
                // Assimp importer, apply the reverse steps automatically.
                // TODO: either drop this, or document it. Otherwise it is just a bad surprise.
                //if (!pPreprocessing && priv) {
                //  pp |= (nonIdempotentSteps & priv->mPPStepsApplied);
                //}

                // If the input scene is not in verbose format, but there is at least post-processing step that relies on it,
                // we need to run the MakeVerboseFormat step first.
                bool must_join_again = false;
                if (!is_verbose_format) {
                    bool verbosify = false;
                    for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++) {
                        BaseProcess* const p = pimpl->mPostProcessingSteps[a];

                        if (p->IsActive(pp) && p->RequireVerboseFormat()) {
                            verbosify = true;
                            break;
                        }
                    }

                    if (verbosify || (exp.mEnforcePP & aiProcess_JoinIdenticalVertices)) {
                        ASSIMP_LOG_DEBUG("export: Scene data not in verbose format, applying MakeVerboseFormat step first");

                        MakeVerboseFormatProcess proc;
                        proc.Execute(scenecopy.get());

                        if(!(exp.mEnforcePP & aiProcess_JoinIdenticalVertices)) {
                            must_join_again = true;
                        }
                    }
                }

                pimpl->mProgressHandler->UpdateFileWrite(2, 4);

                if (pp) {
                    // the three 'conversion' steps need to be executed first because all other steps rely on the standard data layout
                    {
                        FlipWindingOrderProcess step;
                        if (step.IsActive(pp)) {
                            step.Execute(scenecopy.get());
                        }
                    }

                    {
                        FlipUVsProcess step;
                        if (step.IsActive(pp)) {
                            step.Execute(scenecopy.get());
                        }
                    }

                    {
                        MakeLeftHandedProcess step;
                        if (step.IsActive(pp)) {
                            step.Execute(scenecopy.get());
                        }
                    }

                    bool exportPointCloud(false);
                    if (nullptr != pProperties) {
                        exportPointCloud = pProperties->GetPropertyBool(AI_CONFIG_EXPORT_POINT_CLOUDS);
                    }
//.........这里部分代码省略.........

// ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure.
void COBImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
    COB::Scene scene;
    std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE( pIOHandler->Open(pFile,"rb")) );

    // check header
    char head[32];
    stream->CopyAndAdvance(head,32);
    if (strncmp(head,"Caligari ",9)) {
        ThrowException("Could not found magic id: `Caligari`");
    }

    ASSIMP_LOG_INFO_F("File format tag: ",std::string(head+9,6));
    if (head[16]!='L') {
        ThrowException("File is big-endian, which is not supported");
    }

    // load data into intermediate structures
    if (head[15]=='A') {
        ReadAsciiFile(scene, stream.get());
    }
    else {
        ReadBinaryFile(scene, stream.get());
    }
    if(scene.nodes.empty()) {
        ThrowException("No nodes loaded");
    }

    // sort faces by material indices
    for(std::shared_ptr< Node >& n : scene.nodes) {
        if (n->type == Node::TYPE_MESH) {
            Mesh& mesh = (Mesh&)(*n.get());
            for(Face& f : mesh.faces) {
                mesh.temp_map[f.material].push_back(&f);
            }
        }
    }

    // count meshes
    for(std::shared_ptr< Node >& n : scene.nodes) {
        if (n->type == Node::TYPE_MESH) {
            Mesh& mesh = (Mesh&)(*n.get());
            if (mesh.vertex_positions.size() && mesh.texture_coords.size()) {
                pScene->mNumMeshes += static_cast<unsigned int>(mesh.temp_map.size());
            }
        }
    }
    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes]();
    pScene->mMaterials = new aiMaterial*[pScene->mNumMeshes]();
    pScene->mNumMeshes = 0;

    // count lights and cameras
    for(std::shared_ptr< Node >& n : scene.nodes) {
        if (n->type == Node::TYPE_LIGHT) {
            ++pScene->mNumLights;
        }
        else if (n->type == Node::TYPE_CAMERA) {
            ++pScene->mNumCameras;
        }
    }

    if (pScene->mNumLights) {
        pScene->mLights  = new aiLight*[pScene->mNumLights]();
    }
    if (pScene->mNumCameras) {
        pScene->mCameras = new aiCamera*[pScene->mNumCameras]();
    }
    pScene->mNumLights = pScene->mNumCameras = 0;

    // resolve parents by their IDs and build the output graph
    std::unique_ptr<Node> root(new Group());
    for(size_t n = 0; n < scene.nodes.size(); ++n) {
        const Node& nn = *scene.nodes[n].get();
        if(nn.parent_id==0) {
            root->temp_children.push_back(&nn);
        }

        for(size_t m = n; m < scene.nodes.size(); ++m) {
            const Node& mm = *scene.nodes[m].get();
            if (mm.parent_id == nn.id) {
                nn.temp_children.push_back(&mm);
            }
        }
    }

    pScene->mRootNode = BuildNodes(*root.get(),scene,pScene);
	//flip normals after import
    FlipWindingOrderProcess flip;
    flip.Execute( pScene );
}

// ------------------------------------------------------------------------------------------------
aiReturn Exporter :: Export( const aiScene* pScene, const char* pFormatId, const char* pPath, unsigned int pPreprocessing )
{
	ASSIMP_BEGIN_EXCEPTION_REGION();

	pimpl->mError = "";
	for (size_t i = 0; i < pimpl->mExporters.size(); ++i) {
		const Exporter::ExportFormatEntry& exp = pimpl->mExporters[i];
		if (!strcmp(exp.mDescription.id,pFormatId)) {

			try {

				// Always create a full copy of the scene. We might optimize this one day, 
				// but for now it is the most pragmatic way.
				aiScene* scenecopy_tmp;
				SceneCombiner::CopyScene(&scenecopy_tmp,pScene);

				std::auto_ptr<aiScene> scenecopy(scenecopy_tmp);
				const ScenePrivateData* const priv = ScenePriv(pScene);

				// steps that are not idempotent, i.e. we might need to run them again, usually to get back to the
				// original state before the step was applied first. When checking which steps we don't need
				// to run, those are excluded.
				const unsigned int nonIdempotentSteps = aiProcess_FlipWindingOrder | aiProcess_FlipUVs | aiProcess_MakeLeftHanded;

				// Erase all pp steps that were already applied to this scene
				unsigned int pp = (exp.mEnforcePP | pPreprocessing) & ~(priv 
					? (priv->mPPStepsApplied & ~nonIdempotentSteps)
					: 0u);

				// If no extra postprocessing was specified, and we obtained this scene from an
				// Assimp importer, apply the reverse steps automatically.
				if (!pPreprocessing && priv) {
					pp |= (nonIdempotentSteps & priv->mPPStepsApplied);
				}

				// If the input scene is not in verbose format, but there is at least postprocessing step that relies on it,
				// we need to run the MakeVerboseFormat step first.
				if (scenecopy->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) {
					
					bool verbosify = false;
					for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++) {
						BaseProcess* const p = pimpl->mPostProcessingSteps[a];

						if (p->IsActive(pp) && p->RequireVerboseFormat()) {
							verbosify = true;
							break;
						}
					}

					if (verbosify || (exp.mEnforcePP & aiProcess_JoinIdenticalVertices)) {
						DefaultLogger::get()->debug("export: Scene data not in verbose format, applying MakeVerboseFormat step first");

						MakeVerboseFormatProcess proc;
						proc.Execute(scenecopy.get());
					}
				}

				if (pp) {
					// the three 'conversion' steps need to be executed first because all other steps rely on the standard data layout
					{
						FlipWindingOrderProcess step;
						if (step.IsActive(pp)) {
							step.Execute(scenecopy.get());
						}
					}
					
					{
						FlipUVsProcess step;
						if (step.IsActive(pp)) {
							step.Execute(scenecopy.get());
						}
					}

					{
						MakeLeftHandedProcess step;
						if (step.IsActive(pp)) {
							step.Execute(scenecopy.get());
						}
					}

					// dispatch other processes
					for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++) {
						BaseProcess* const p = pimpl->mPostProcessingSteps[a];

						if (p->IsActive(pp) 
							&& !dynamic_cast<FlipUVsProcess*>(p) 
							&& !dynamic_cast<FlipWindingOrderProcess*>(p) 
							&& !dynamic_cast<MakeLeftHandedProcess*>(p)) {

							p->Execute(scenecopy.get());
						}
					}
					ScenePrivateData* const privOut = ScenePriv(scenecopy.get());
					ai_assert(privOut);

					privOut->mPPStepsApplied |= pp;
				}

				exp.mExportFunction(pPath,pimpl->mIOSystem.get(),scenecopy.get());
//.........这里部分代码省略.........

// ------------------------------------------------------------------------------------------------
// Constructs the return data structure out of the imported data.
void XFileImporter::CreateDataRepresentationFromImport( aiScene* pScene, XFile::Scene* pData)
{
    // Read the global materials first so that meshes referring to them can find them later
    ConvertMaterials( pScene, pData->mGlobalMaterials);

    // copy nodes, extracting meshes and materials on the way
    pScene->mRootNode = CreateNodes( pScene, NULL, pData->mRootNode);

    // extract animations
    CreateAnimations( pScene, pData);

    // read the global meshes that were stored outside of any node
    if( pData->mGlobalMeshes.size() > 0)
    {
        // create a root node to hold them if there isn't any, yet
        if( pScene->mRootNode == NULL)
        {
            pScene->mRootNode = new aiNode;
            pScene->mRootNode->mName.Set( "$dummy_node");
        }

        // convert all global meshes and store them in the root node.
        // If there was one before, the global meshes now suddenly have its transformation matrix...
        // Don't know what to do there, I don't want to insert another node under the present root node
        // just to avoid this.
        CreateMeshes( pScene, pScene->mRootNode, pData->mGlobalMeshes);
    }

    if (!pScene->mRootNode) {
        throw DeadlyImportError( "No root node" );
    }

    // Convert everything to OpenGL space... it's the same operation as the conversion back, so we can reuse the step directly
    MakeLeftHandedProcess convertProcess;
    convertProcess.Execute( pScene);

    FlipWindingOrderProcess flipper;
    flipper.Execute(pScene);

    // finally: create a dummy material if not material was imported
    if( pScene->mNumMaterials == 0)
    {
        pScene->mNumMaterials = 1;
        // create the Material
        aiMaterial* mat = new aiMaterial;
        int shadeMode = (int) aiShadingMode_Gouraud;
        mat->AddProperty<int>( &shadeMode, 1, AI_MATKEY_SHADING_MODEL);
        // material colours
        int specExp = 1;

        aiColor3D clr = aiColor3D( 0, 0, 0);
        mat->AddProperty( &clr, 1, AI_MATKEY_COLOR_EMISSIVE);
        mat->AddProperty( &clr, 1, AI_MATKEY_COLOR_SPECULAR);

        clr = aiColor3D( 0.5f, 0.5f, 0.5f);
        mat->AddProperty( &clr, 1, AI_MATKEY_COLOR_DIFFUSE);
        mat->AddProperty( &specExp, 1, AI_MATKEY_SHININESS);

        pScene->mMaterials = new aiMaterial*[1];
        pScene->mMaterials[0] = mat;
    }
}