void EntityNode::ImportNodeAddedCallback( MObject &addedNode, void* param )
{
MAYA_START_EXCEPTION_HANDLING();
MObjectArray (*nodeArrays)[NodeArrays::Count] = (MObjectArray (*)[NodeArrays::Count])param;
MObjectHandle handle( addedNode );
if( !handle.isValid() )
{
return;
}
MFnDependencyNode nodeFn( addedNode );
nodeFn.setDoNotWrite( true );
// don't gather certain nodes
if( addedNode.hasFn( MFn::kReference ) ||
addedNode.hasFn( MFn::kPartition ) ||
addedNode.hasFn( MFn::kDisplayLayerManager ) ||
addedNode.hasFn( MFn::kDisplayLayer ) ||
addedNode.hasFn( MFn::kRenderLayerManager ) ||
addedNode.hasFn( MFn::kRenderLayer ) ||
addedNode.hasFn( MFn::kScript ) ||
addedNode.hasFn( MFn::kLightLink ) )
{
return;
}
// don't gather reference objects
if( nodeFn.isFromReferencedFile() )
{
return;
}
// don't gather maya-designated "shared" nodes
if( nodeFn.isShared() )
{
return;
}
#ifdef _DEBUG
MString name = nodeFn.name();
MString type = nodeFn.typeName();
std::cout << " - Importing: " << name.asTChar() << " " << type.asTChar() << std::endl;
#endif
nodeArrays[ NodeArrays::KeepNodes ]->append( addedNode );
MAYA_FINISH_EXCEPTION_HANDLING();
}
Helium::TUID Maya::GetNodeID( const MObject& node, bool create )
{
if (node == MObject::kNullObj)
{
return Helium::TUID::Null;
}
MObject attr = MObject::kNullObj;
MStatus status = MS::kFailure;
MFnDependencyNode nodeFn (node);
if ( create )
{
//
// GUID->TUID legacy handling
//
// look for the old GUID attribute
attr = nodeFn.attribute(MString (s_GUIDAttributeName), &status);
// if we found it
if ( status == MS::kSuccess && !attr.isNull() )
{
// get the GUID value
MString str;
MPlug plug (node, attr);
status = plug.getValue(str);
HELIUM_ASSERT( status != MS::kFailure );
// parse it
Helium::GUID id;
bool parsed = id.FromString(str.asTChar());
HELIUM_ASSERT( parsed );
// convert it to a TUID and set the new attribute
Helium::TUID tuid;
tuid.FromGUID( id );
status = SetNodeID( node, tuid );
HELIUM_ASSERT( status != MS::kFailure );
// check to see if we are a locked node
bool nodeWasLocked = nodeFn.isLocked();
if ( nodeWasLocked )
{
// turn off any node locking so an attribute can be added
nodeFn.setLocked( false );
}
// unlock the attribute
status = plug.setLocked( false );
HELIUM_ASSERT( status != MS::kFailure );
// remove the attribute
status = nodeFn.removeAttribute( attr );
HELIUM_ASSERT( status != MS::kFailure );
// reset to the prior state of wasLocked
if ( nodeWasLocked )
{
nodeFn.setLocked( nodeWasLocked );
}
}
}
// look for the TUID attribute
attr = nodeFn.attribute(MString (s_TUIDAttributeName));
// retrieve the attribute value (may be empty if we are not creating a new id)
MString str;
MPlug plug (node, attr);
plug.getValue(str);
// if we don't have an existing id and we should create one
if ( str.length() == 0 && create )
{
// generate a new ID
Helium::TUID id( Helium::TUID::Generate() );
// set the new ID value on the node
if( SetNodeID( node, id ) )
{
return id;
}
else
{
return Helium::TUID::Null;
}
}
// parse the value (this may be null if we did not create the attribute)
Helium::TUID id;
id.FromString(str.asTChar());
return id;
}
void EntityNode::LoadArt()
{
MStatus stat;
bool callbackRemoved = false;
if( s_EditNodeAddedCBId != -1 )
{
MDGMessage::removeCallback( s_EditNodeAddedCBId );
s_EditNodeAddedCBId = -1;
callbackRemoved = true;
}
UnloadArt();
MString artFilePath;
GetArtFilePath( artFilePath );
std::cout << "Importing from: " << artFilePath.asTChar() << "..." << std::endl;
// add the callback to catch all the imported objects
MObjectArray objectArrays[NodeArrays::Count];
s_ImportNodeAddedCBId = MDGMessage::addNodeAddedCallback( ImportNodeAddedCallback, kDefaultNodeType, &objectArrays );
// import stuff
MFileIO::import( artFilePath, NULL, false );
// remove the callback
MDGMessage::removeCallback( s_ImportNodeAddedCBId );
// add all imported stuff under this guy's transform
MFnDagNode nodeFn( thisMObject() );
for( u32 i=0; i<objectArrays[NodeArrays::KeepNodes].length(); ++i )
{
if( objectArrays[NodeArrays::KeepNodes][i].isNull() )
{
continue;
}
MObjectHandle handle( objectArrays[NodeArrays::KeepNodes][i] );
if ( !handle.isValid() )
{
continue;
}
// We should be getting only MFnDagNode in here, but just in case
MFnDagNode dagFn( objectArrays[NodeArrays::KeepNodes][i], &stat );
if ( stat == MStatus::kSuccess )
{
stat = dagFn.setDoNotWrite( true );
}
else
{
MFnDependencyNode depNodeFn( objectArrays[NodeArrays::KeepNodes][i], &stat );
stat = depNodeFn.setDoNotWrite( true );
}
#ifdef _DEBUG
MString name = dagFn.name();
MString type = dagFn.typeName();
std::string nodeTypeStr( objectArrays[NodeArrays::KeepNodes][i].apiTypeStr() );
if ( name.length() )
{
std::cout << " - Importing Child: " << name.asTChar() << " " << type.asTChar() << "(" << nodeTypeStr << ")" << std::endl;
}
#endif
AddImportNode( objectArrays[NodeArrays::KeepNodes][i] );
nodeFn.addChild( objectArrays[NodeArrays::KeepNodes][i] );
}
for( u32 i=0; i<objectArrays[NodeArrays::DeleteNodes].length(); ++i )
{
MGlobal::deleteNode( objectArrays[NodeArrays::DeleteNodes][i] );
}
MFnDagNode otherFn;
for( u32 i=0 ; i<nodeFn.childCount(); ++i )
{
MObject child = nodeFn.child( i );
if( !child.hasFn( MFn::kDagNode ) )
{
continue;
}
otherFn.setObject( child );
if( otherFn.typeId() == EntityNode::s_TypeID )
{
MDagModifier mod;
u32 numChild = otherFn.childCount();
for( u32 j = 0; j < numChild; ++j )
{
stat = mod.reparentNode( otherFn.child( j ), thisMObject() );
}
mod.doIt();
MGlobal::deleteNode( child );
break;
}
}
std::cout << "Done" << std::endl;
}
void EntityNode::AddImportNode( const MObject& object )
{
MStatus stat;
MObjectHandle handle( object );
if( !handle.isValid() )
{
return;
}
MFnDependencyNode nodeFn( object, &stat );
MCheckNoErr( stat, "Unable to create depenency node fn set" );
nodeFn.setDoNotWrite( true );
//MItDependencyGraph childrenIt (MItDependencyGraph::kUpstream);
//for ( childrenIt.reset( nodeFn.object() ); !childrenIt.isDone(); childrenIt.next() )
//{
// MFnDependencyNode( childrenIt.item() ).setDoNotWrite( true );
//}
MString name = nodeFn.name( &stat );
MCheckNoErr( stat, "Unable to get node name" );
if( name == "" )
{
return;
}
// don't connect dag nodes to the ImportNodes attributeb array
if( object.hasFn( MFn::kDagNode ) )
{
return;
}
#ifdef _DEBUG
std::cout << "Adding: " << name.asTChar() << std::endl;
#endif
//create ImportMessage attrib on the imported object if necessary
if( !nodeFn.hasAttribute( "ImportMessage", &stat ) )
{
MFnMessageAttribute mAttr;
MObject importMessage = mAttr.create( "ImportMessage", "imp", &stat );
MCheckNoErr(stat, "Unable to create attr: ImportMessage");
stat = nodeFn.addAttribute( importMessage );
MCheckNoErr(stat, "Unable to add attr: ImportNodes");
}
MPlug importMsg = nodeFn.findPlug( "ImportMessage", &stat );
MCheckNoErr(stat, "Unable to find attr: ImportMessage");
MPlug importPlug( thisMObject(), m_ImportNodes );
u32 currentIdx = importPlug.numConnectedElements();
MPlug importElement = importPlug.elementByLogicalIndex( currentIdx );
MDGModifier mod;
//if it's currently connected, disconnect it
if( importMsg.isConnected() )
{
MPlugArray plugs;
importMsg.connectedTo( plugs, true, false );
if( plugs.length() == 1 )
{
mod.disconnect( importMsg, plugs[0] );
}
}
stat = mod.connect( importMsg, importElement );
mod.doIt();
}
void EntityNode::SetArtFilePath( const MString& artFilePath )
{
MPlug plug( thisMObject(), s_ArtFilePath );
plug.setValue( MString(artFilePath.asTChar()) );
}