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);
}
}
}
//
// 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 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);
}
}
}