MStatus FileTranslator::writer ( const MFileObject& file, const MString& options, MPxFileTranslator::FileAccessMode mode ) { MStatus status = MStatus::kFailure; try { // Extract the filename #if defined (OSMac_) char nameBuffer[MAXPATHLEN]; strcpy ( nameBuffer, file.fullName().asChar() ); const MString fileName ( nameBuffer ); #else const MString fileName = file.fullName(); #endif // OSMac // TODO Export the referenced files! // Maya forces the write of all the references, on export. // Intentionally skip known reference file paths. for ( MItDependencyNodes it ( MFn::kReference ); !it.isDone(); it.next() ) { MObject refNode = it.item(); MString refNodeName = MFnDependencyNode ( refNode ).name(); MString refNodeFilename; MGlobal::executeCommand ( MString ( "reference -rfn \"" ) + refNodeName + MString ( "\" -q -filename" ), refNodeFilename ); if ( refNodeFilename == fileName ) return MStatus::kSuccess; if ( ExportOptions::exportXRefs() ) { // TODO Open file export dialog ( !? HOW ?! ) to get a DAE filename // to export the referenced file. } } // Parse the export options ExportOptions::set ( options ); // Check, if we should just export the selected Objects exportSelection = mode == MPxFileTranslator::kExportActiveAccessMode; // Do the actual export now status = exportIntoFile ( fileName, exportSelection ); } catch ( COLLADASW::StreamWriterException* swException ) { String message = "StreamWriterException: " + swException->getMessage(); MGlobal::displayError ( message.c_str() ); } catch ( ... ) { MGlobal::displayError ( "ColladaMaya has thrown an exception!" ); } return status; }
void colorTransformDataTranslator::writeColorSpaceForNodes(fstream& f) { MItDependencyNodes nodeIter; f << "====================== Nodes with color space attribute =======================\n"; for (; !nodeIter.isDone(); nodeIter.next()) { MObject node = nodeIter.item(); if(!node.isNull() && ( (node.apiType()==MFn::kFileTexture) || (node.apiType()==MFn::kImagePlane) ) ) { MString inputColorSpace = getInputColorSpace(node); MString transformId; f << "Found node with colorspace " << inputColorSpace.asUTF8(); if(MColorManagementUtilities::getColorTransformCacheIdForInputSpace( inputColorSpace, transformId)) { f << ", its corresponding transform id: " << transformId.asUTF8() << std::endl; } else { f << ", no corresponding transform id found.\n"; } } } }
void maTranslator::writeNonDagNodes(fstream& f) { MItDependencyNodes nodeIter; for (; !nodeIter.isDone(); nodeIter.next()) { MObject node = nodeIter.item(); MFnDependencyNode nodeFn(node); // // Save default nodes for later processing. // if (nodeFn.isDefaultNode()) { fDefaultNodes.append(node); } else if (!nodeFn.isFromReferencedFile() && !nodeFn.isFlagSet(fCreateFlag)) { // // If this node is either writable or shared, then write it out. // Otherwise don't, but still mark it as having been written so // that we don't end up processing it again at some later time. // if (nodeFn.canBeWritten() || nodeFn.isShared()) { writeCreateNode(f, node); writeNodeAttrs(f, node, true); writeLockNode(f, node); } nodeFn.setFlag(fCreateFlag, true); nodeFn.setFlag(fAttrFlag, true); } } }
// ------------------------------------------------------------ bool SceneGraph::create ( bool selectionOnly ) { // The flag, if just the selected elements should be exported. mExportSelectedOnly = selectionOnly; // Add all the animation expressions MItDependencyNodes depIter ( MFn::kExpression ); for ( ; !depIter.isDone(); depIter.next() ) { MObject item = depIter.item(); if ( item.hasFn ( MFn::kExpression ) ) { mAnimationExpressions.append ( item ); } } // Push all nodes from root down to all meshes which have to be exported in a list. findForcedNodes (); // Fills the list with all root targets to export. bool success = retrieveExportNodes (); // Create a selection list containing only the root nodes (implies export all!) uint length = mTargets.length(); for ( uint i=0; i<mTargets.length(); ++i ) { MDagPath dagPath; MStatus status = mTargets.getDagPath ( i, dagPath ); if ( status != MStatus::kSuccess ) return false; // This node has no transform - i.e., it's the world node MObject transformNode = dagPath.transform ( &status ); if ( !status && status.statusCode () == MStatus::kInvalidParameter ) continue; // Check if it is a valid transform node MFnDagNode transform ( transformNode, &status ); if ( !status ) { status.perror ( "MFnDagNode constructor" ); return false; } // Create a new scene element SceneElement* sceneElement = createSceneElement ( dagPath ); // Push the root nodes into the tree. // If the root node is instanced, push it at the beginning (no instance on root!). if ( dagPath.isInstanced () ) mExportNodesTree.insert ( mExportNodesTree.begin (), sceneElement ); else mExportNodesTree.push_back ( sceneElement ); // Create the child elements //if ( sceneElement->getIsExportNode() ) { createChildSceneElements ( sceneElement ); } } return true; }
void maTranslator::writeReferenceNodes(fstream& f) { // // We don't write out createNode commands for reference nodes, but // we do write out parenting between them and non-reference nodes, // as well as attributes added and attribute values changed after the // referenced file was loaded // writeRefNodeParenting(f); // // Output the commands for DAG nodes first. // MItDag dagIter; for (dagIter.next(); !dagIter.isDone(); dagIter.next()) { MObject node = dagIter.item(); MFnDependencyNode nodeFn(node); if (nodeFn.isFromReferencedFile() && !nodeFn.isFlagSet(fAttrFlag)) { writeNodeAttrs(f, node, false); // // Make note of any connections to this node which have been // broken by the main scene. // MFileIO::getReferenceConnectionsBroken( node, fBrokenConnSrcs, fBrokenConnDests, true, true ); nodeFn.setFlag(fAttrFlag, true); } } // // Now do the remaining, non-DAG nodes. // MItDependencyNodes nodeIter; for (; !nodeIter.isDone(); nodeIter.next()) { MObject node = nodeIter.item(); MFnDependencyNode nodeFn(node); if (nodeFn.isFromReferencedFile() && !nodeFn.isFlagSet(fAttrFlag)) { writeNodeAttrs(f, node, false); // // Make note of any connections to this node which have been // broken by the main scene. // MFileIO::getReferenceConnectionsBroken( node, fBrokenConnSrcs, fBrokenConnDests, true, true ); nodeFn.setFlag(fAttrFlag, true); } } }
// // Maya calls this method to have the translator write out a file. // MStatus maTranslator::writer( const MFileObject& file, const MString& /* options */, MPxFileTranslator::FileAccessMode mode ) { // // For simplicity, we only do full saves/exports. // if ((mode != kSaveAccessMode) && (mode != kExportAccessMode)) return MS::kNotImplemented; // // Let's see if we can open the output file. // fstream output(file.fullName().asChar(), ios::out | ios::trunc); if (!output.good()) return MS::kNotFound; // // Get some node flags to keep track of those nodes for which we // have already done various stages of processing. // MStatus status; fCreateFlag = MFnDependencyNode::allocateFlag(fPluginName, &status); if (status) fAttrFlag = MFnDependencyNode::allocateFlag(fPluginName, &status); if (status) fConnectionFlag = MFnDependencyNode::allocateFlag(fPluginName, &status); if (!status) { MGlobal::displayError( "Could not allocate three free node flags." " Try unloading some other plugins." ); return MS::kFailure; } // // Run through all of the nodes in the scene and clear their flags. // MItDependencyNodes nodesIter; for (; !nodesIter.isDone(); nodesIter.next()) { MObject node = nodesIter.item(); MFnDependencyNode nodeFn(node); nodeFn.setFlag(fCreateFlag, false); nodeFn.setFlag(fAttrFlag, false); nodeFn.setFlag(fConnectionFlag, false); } // // Write out the various sections of the file. // writeHeader(output, file.name()); writeFileInfo(output); writeReferences(output); writeRequirements(output); writeUnits(output); writeDagNodes(output); writeNonDagNodes(output); writeDefaultNodes(output); writeReferenceNodes(output); writeConnections(output); writeFooter(output, file.name()); output.close(); MFnDependencyNode::deallocateFlag(fPluginName, fCreateFlag); return MS::kSuccess; }
// // Write out all of the connections in the scene. // void maTranslator::writeConnections(fstream& f) { // // If the scene has broken any connections which were made in referenced // files, handle those first so that the attributes are free for any new // connections which may come along. // writeBrokenRefConnections(f); // // We're about to write out the scene's connections in three parts: DAG // nodes, non-DAG non-default nodes, then default nodes. // // It's really not necessary that we group them like this and would in // fact be more efficient to do them all in one MItDependencyNodes // traversal. However, this is the order in which the normal MayaAscii // translator does them, so this makes it easier to compare the output // of this translator to Maya's output. // // // Write out connections for the DAG nodes first. // MItDag dagIter; dagIter.traverseUnderWorld(true); for (dagIter.next(); !dagIter.isDone(); dagIter.next()) { MObject node = dagIter.item(); MFnDagNode dagNodeFn(node); if (!dagNodeFn.isFlagSet(fConnectionFlag) && dagNodeFn.canBeWritten() && !dagNodeFn.isDefaultNode()) { writeNodeConnections(f, dagIter.item()); dagNodeFn.setFlag(fConnectionFlag, true); } } // // Now do the non-DAG, non-default nodes. // MItDependencyNodes nodeIter; for (; !nodeIter.isDone(); nodeIter.next()) { MFnDependencyNode nodeFn(nodeIter.item()); if (!nodeFn.isFlagSet(fConnectionFlag) && nodeFn.canBeWritten() && !nodeFn.isDefaultNode()) { writeNodeConnections(f, nodeIter.item()); nodeFn.setFlag(fConnectionFlag, true); } } // // And finish up with the default nodes. // unsigned int numNodes = fDefaultNodes.length(); unsigned int i; for (i = 0; i < numNodes; i++) { MFnDependencyNode nodeFn(fDefaultNodes[i]); if (!nodeFn.isFlagSet(fConnectionFlag) && nodeFn.canBeWritten() && nodeFn.isDefaultNode()) { writeNodeConnections(f, fDefaultNodes[i]); nodeFn.setFlag(fConnectionFlag, true); } } }