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