// // Write out all of the connections in the scene. // protected void writeConnections(FileStream 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 = new MItDag(); dagIter.traverseUnderWorld(true); for (dagIter.next(); !dagIter.isDone; dagIter.next()) { MObject node = dagIter.item(); MFnDagNode dagNodeFn = new MFnDagNode(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 = new MItDependencyNodes(); for (; !nodeIter.isDone; nodeIter.next()) { MFnDependencyNode nodeFn = new MFnDependencyNode(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. // uint numNodes = fDefaultNodes.length; int i; for (i = 0; i < numNodes; i++) { MFnDependencyNode nodeFn = new MFnDependencyNode(fDefaultNodes[i]); if (!nodeFn.isFlagSet(fConnectionFlag) && nodeFn.canBeWritten && nodeFn.isDefaultNode) { writeNodeConnections(f, fDefaultNodes[i]); nodeFn.setFlag(fConnectionFlag, true); } } }
protected void writeReferenceNodes(FileStream 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 = new MItDag(); for (dagIter.next(); !dagIter.isDone; dagIter.next()) { MObject node = dagIter.item(); MFnDependencyNode nodeFn = new MFnDependencyNode(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 = new MItDependencyNodes(); for (; !nodeIter.isDone; nodeIter.next()) { MObject node = nodeIter.item; MFnDependencyNode nodeFn = new MFnDependencyNode(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); } } }
protected void writeNonDagNodes(FileStream f) { MItDependencyNodes nodeIter = new MItDependencyNodes(); for (; !nodeIter.isDone; nodeIter.next()) { MObject node = nodeIter.item; MFnDependencyNode nodeFn = new MFnDependencyNode(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); } } }
protected void writeDefaultNodes(FileStream f) { uint numNodes = fDefaultNodes.length; int i; for (i = 0; i < numNodes; i++) { writeNodeAttrs(f, fDefaultNodes[i], false); MFnDependencyNode nodeFn = new MFnDependencyNode(fDefaultNodes[i]); nodeFn.setFlag(fAttrFlag, true); } }
// // Maya calls this method to have the translator write out a file. // public override void writer(MFileObject file, string optionsString, MPxFileTranslator.FileAccessMode mode) { // // For simplicity, we only do full saves/exports. // if ((mode != MPxFileTranslator.FileAccessMode.kSaveAccessMode) && (mode != MPxFileTranslator.FileAccessMode.kExportAccessMode)) throw new System.NotImplementedException( "We only support support SaveAccessMode and ExportAccessMode"); // // Let's see if we can open the output file. // FileStream output = null; try { output = new FileStream(file.fullName, FileMode.Create, FileAccess.Write); } catch (ArgumentException ex) { MGlobal.displayInfo("File access invalid!"); if(output != null) output.Close(); throw ex; } // // Get some node flags to keep track of those nodes for which we // have already done various stages of processing. // fCreateFlag = MFnDependencyNode.allocateFlag(fPluginName); fAttrFlag = MFnDependencyNode.allocateFlag(fPluginName); fConnectionFlag = MFnDependencyNode.allocateFlag(fPluginName); // // Run through all of the nodes in the scene and clear their flags. // MItDependencyNodes nodesIter = new MItDependencyNodes(); for (; !nodesIter.isDone; nodesIter.next()) { MObject node = nodesIter.item; MFnDependencyNode nodeFn = new MFnDependencyNode(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; }