// --------------------------------------------------------------------------------------------
MStatus polyModifierCmd::processMeshNode( modifyPolyData& data )
// --------------------------------------------------------------------------------------------
{
MStatus status = MS::kSuccess;
// Declare our function sets. Use MFnDagNode here so
// we can retrieve the parent transform.
//
MFnDagNode dagNodeFn;
// Use the DAG path to retrieve our mesh shape node.
//
data.meshNodeShape = fDagPath.node();
dagNodeFn.setObject( data.meshNodeShape );
// ASSERT: meshNodeShape node should have a parent transform!
//
MStatusAssert( (0 < dagNodeFn.parentCount()),
"0 < dagNodeFn.parentCount() -- meshNodeshape has no parent transform" );
data.meshNodeTransform = dagNodeFn.parent(0);
data.meshNodeDestPlug = dagNodeFn.findPlug( "inMesh" );
data.meshNodeDestAttr = data.meshNodeDestPlug.attribute();
return status;
}
void tLocatorMgr::scanScene(const float lframe__, const int sample__,
boost::shared_ptr< liqRibHT > &htable__,
int &count__,
MStatus &returnStatus__)
{
CM_TRACE_FUNC("tLocatorMgr::scanScene("<<lframe__<<","<<sample__<<",htable__,count__,returnStatus__)");
//[refactor 10] beg from scanScene()
MItDag dagCoordSysIterator( MItDag::kDepthFirst, MFn::kLocator, &returnStatus__);
for (; !dagCoordSysIterator.isDone(); dagCoordSysIterator.next())
{
#if (Refactoring == 0)
LIQ_CHECK_CANCEL_REQUEST;
#endif
MDagPath path;
MObject currentNode;
currentNode = dagCoordSysIterator.item();
MFnDagNode dagNode;
dagCoordSysIterator.getPath( path );
if(MS::kSuccess != returnStatus__)
continue;
if(!currentNode.hasFn(MFn::kDagNode))
continue;
returnStatus__ = dagNode.setObject( currentNode );
if(MS::kSuccess != returnStatus__)
continue;
// scanScene: if it's a coordinate system then insert it into the hash table
if( dagNode.typeName() == "liquidCoordSys" )
{
int coordType = 0;
MPlug typePlug = dagNode.findPlug( "type", &returnStatus__ );
if( MS::kSuccess == returnStatus__ )
typePlug.getValue( coordType );
bool useSamples( ( sample__ > 0 ) && isObjectMotionBlur( path ) );
ObjectType mrttype = getMRTType(currentNode, coordType);
ObjectType mrttype_shouldbe = ( coordType == 5 )? MRT_ClipPlane : MRT_Coord;
if( mrttype != mrttype_shouldbe ){
liquidMessage2(messageError, "mrttype[%d] should be %d", mrttype_shouldbe);
}
htable__->insert( path,
lframe__,
( useSamples )? sample__ : 0,
mrttype, //( coordType == 5 )? MRT_ClipPlane : MRT_Coord,
count__++ );
continue;
}
}
//[refactor 10] end from scanScene()
}
MStatus sgBDataCmd_key::importData()
{
MStatus status;
MTime::Unit currentUnit = MTime().unit();
MPlugArray connections;
sgObject_keyData& objectKeyData = m_objectKeyDataImport;
MObject& oTarget = objectKeyData.oTargetNode;
MDoubleArray& dArrTime = objectKeyData.dArrTime;
MTime::Unit unit = (MTime::Unit)objectKeyData.unit;
MFnDagNode fnNode = oTarget;
MPlugArray targetPlugs;
unsigned int numAttr = objectKeyData.namesAttribute.length();
unsigned int lengthTime = dArrTime.length();
for( unsigned int j=0; j<numAttr; j++ )
{
if( numAttr <= j ) break;
MPlug targetPlug = fnNode.findPlug( objectKeyData.namesAttribute[j] );
targetPlug.connectedTo( connections, true, false );
if( connections.length() ){
m_dgMod_connection.disconnect( connections[0], targetPlug );
m_dgMod_delete.deleteNode( connections[0].node() );
}
m_dgMod_connection.doIt();
m_dgMod_delete.doIt();
MObject oAnimCurve = MFnAnimCurve().create( targetPlug );
m_oArrKeyAfter.append( oAnimCurve );
MFnAnimCurve fnAnimCurve( oAnimCurve );
for( unsigned int k=0; k<lengthTime; k++ )
{
double& dTime = dArrTime[k];
double& dValue = objectKeyData.dArrValuesArray[ k*numAttr+j ];
MTime mTime( dTime, unit );
mTime.setUnit( currentUnit );
fnAnimCurve.addKeyframe( mTime, dValue );
}
}
return MS::kSuccess;
};
bool polyExporter::isVisible(MFnDagNode & fnDag, MStatus& status)
//Summary: determines if the given DAG node is currently visible
//Args : fnDag - the DAG node to check
//Returns: true if the node is visible;
// false otherwise
{
if(fnDag.isIntermediateObject())
return false;
MPlug visPlug = fnDag.findPlug("visibility", &status);
if (MStatus::kFailure == status) {
MGlobal::displayError("MPlug::findPlug");
return false;
} else {
bool visible;
status = visPlug.getValue(visible);
if (MStatus::kFailure == status) {
MGlobal::displayError("MPlug::getValue");
}
return visible;
}
}
MStatus sgBDataCmd_key::setObjectKeyDataDefault( sgObject_keyData& objectKeyData, const MDagPath& dagPathTarget, bool bMatrixType )
{
MStatus status;
objectKeyData.oTargetNode = dagPathTarget.node();
objectKeyData.numAttr = 0;
objectKeyData.namesAttribute.clear();
objectKeyData.lengthTime = 0;
objectKeyData.dArrTime.clear();
objectKeyData.dArrValuesArray.clear();
MFnDagNode fnDagNode = dagPathTarget;
MPlugArray plugArrTransform;
MPlugArray plugArrVis;
plugArrTransform.append( fnDagNode.findPlug( "tx" ) );
plugArrTransform.append( fnDagNode.findPlug( "ty" ) );
plugArrTransform.append( fnDagNode.findPlug( "tz" ) );
plugArrTransform.append( fnDagNode.findPlug( "rx" ) );
plugArrTransform.append( fnDagNode.findPlug( "ry" ) );
plugArrTransform.append( fnDagNode.findPlug( "rz" ) );
plugArrTransform.append( fnDagNode.findPlug( "sx" ) );
plugArrTransform.append( fnDagNode.findPlug( "sy" ) );
plugArrTransform.append( fnDagNode.findPlug( "sz" ) );
plugArrVis.append( fnDagNode.findPlug( "v" ) );
if( bMatrixType )
{
if( plugsHasConnection( plugArrVis ) )
{
objectKeyData.numAttr++;
objectKeyData.namesAttribute.append( "visibility" );
}
if( plugsHasConnection( plugArrTransform ) )
{
objectKeyData.numAttr += 9;
objectKeyData.namesAttribute.append( "translateX" );
objectKeyData.namesAttribute.append( "translateY" );
objectKeyData.namesAttribute.append( "translateZ" );
objectKeyData.namesAttribute.append( "rotateX" );
objectKeyData.namesAttribute.append( "rotateY" );
objectKeyData.namesAttribute.append( "rotateZ" );
objectKeyData.namesAttribute.append( "scaleX" );
objectKeyData.namesAttribute.append( "scaleY" );
objectKeyData.namesAttribute.append( "scaleZ" );
}
}
else
{
MPlugArray plugArr;
for( unsigned int j=0; j< plugArrTransform.length(); j++ )
{
MPlug& plug = plugArrTransform[j];
plug.connectedTo( plugArr, true, false );
if( !plugArr.length() )
{
MPlug plugParent = plug.parent( &status );
if( !status ) continue;
plugParent.connectedTo( plugArr, true, false );
if( !plugArr.length() ) continue;
}
objectKeyData.numAttr++;
objectKeyData.namesAttribute.append( MFnAttribute( plug.attribute() ).name() );
}
plugArrVis[0].connectedTo( plugArr, true, false );
if( plugArr.length() )
{
objectKeyData.numAttr++;
objectKeyData.namesAttribute.append( MFnAttribute( plugArrVis[0].attribute() ).name() );
}
}
objectKeyData.dArrValuesArray.clear();
return MS::kSuccess;
}
MStatus polyModifierCmd::processUpstreamNode( modifyPolyData& data )
{
MStatus status = MS::kSuccess;
// Declare our function sets - Although dagNodeFn derives from depNodeFn, we need
// both since dagNodeFn can only refer to DAG objects.
// We will use depNodeFn for all times other when dealing
// with the DAG.
//
MFnDependencyNode depNodeFn;
MFnDagNode dagNodeFn;
// Use the selected node's plug connections to find the upstream plug.
// Since we are looking at the selected node's inMesh attribute, it will
// always have only one connection coming in if it has history, and none
// otherwise.
//
// If there is no history, copy the selected node and place it ahead of the
// modifierNode as the new upstream node so that the modifierNode has an
// input mesh to operate on.
//
MPlugArray tempPlugArray;
if( fHasHistory )
{
// Since we have history, look for what connections exist on the
// meshNode "inMesh" plug. "inMesh" plugs should only ever have one
// connection.
//
data.meshNodeDestPlug.connectedTo( tempPlugArray, true, false);
// ASSERT: Only one connection should exist on meshNodeShape.inMesh!
//
MStatusAssert( (tempPlugArray.length() == 1),
"tempPlugArray.length() == 1 -- 0 or >1 connections on meshNodeShape.inMesh" );
data.upstreamNodeSrcPlug = tempPlugArray[0];
// Construction history only deals with shapes, so we can grab the
// upstreamNodeShape off of the source plug.
//
data.upstreamNodeShape = data.upstreamNodeSrcPlug.node();
depNodeFn.setObject( data.upstreamNodeShape );
data.upstreamNodeSrcAttr = data.upstreamNodeSrcPlug.attribute();
// Disconnect the upstream node and the selected node, so we can
// replace them with our own connections below.
//
fDGModifier.disconnect( data.upstreamNodeSrcPlug,
data.meshNodeDestPlug );
}
else // No History (!fHasHistory)
{
// Use the DAG node function set to duplicate the shape of the meshNode.
// The duplicate method will return an MObject handle to the transform
// of the duplicated shape, so traverse the dag to locate the shape. Store
// this duplicate shape as our "upstream" node to drive the input for the
// modifierNode.
//
dagNodeFn.setObject( data.meshNodeShape );
data.upstreamNodeTransform = dagNodeFn.duplicate( false, false );
dagNodeFn.setObject( data.upstreamNodeTransform );
// Ensure that our upstreamNode is pointing to a shape.
//
MStatusAssert( (0 < dagNodeFn.childCount()),
"0 < dagNodeFn.childCount() -- Duplicate meshNode transform has no shape." );
data.upstreamNodeShape = dagNodeFn.child(0);
// Re-parent the upstreamNodeShape under our original transform
//
status = fDagModifier.reparentNode( data.upstreamNodeShape, data.meshNodeTransform );
MCheckStatus( status, "reparentNode" );
// Perform the DAG re-parenting
//
// Note: This reparent must be performed before the deleteNode() is called.
// See polyModifierCmd.h (see definition of fDagModifier) for more details.
//
status = fDagModifier.doIt();
MCheckStatus( status, "fDagModifier.doIt()" );
// Mark the upstreamNodeShape (the original shape) as an intermediate object
// (making it invisible to the user)
//
dagNodeFn.setObject( data.upstreamNodeShape );
dagNodeFn.setIntermediateObject( true );
// Get the upstream node source attribute
//
data.upstreamNodeSrcAttr = dagNodeFn.attribute( "outMesh" );
data.upstreamNodeSrcPlug = dagNodeFn.findPlug( "outMesh", &status );
// Remove the duplicated transform node (clean up)
//
status = fDagModifier.deleteNode( data.upstreamNodeTransform );
MCheckStatus( status, "deleteNode" );
// Perform the DAG delete node
//
// Note: This deleteNode must be performed after the reparentNode() method is
// completed. See polyModifierCmd.h (see definition of fDagModifier) for
// details.
//
status = fDagModifier.doIt();
MCheckStatus( status, "fDagModifier.doIt()" );
// Cache the DAG path to the duplicate shape
//
dagNodeFn.getPath( fDuplicateDagPath );
}
return status;
}