//---------------------------------------------------
bool DagHelper::setPlugValue ( MPlug& plug, const MColor& value )
{
MStatus status;
if ( plug.isCompound() && plug.numChildren() >= 3 )
{
MPlug rPlug = plug.child ( 0, &status );
if ( status != MStatus::kSuccess ) return false;
status = rPlug.setValue ( value.r );
if ( status != MStatus::kSuccess ) return false;
MPlug gPlug = plug.child ( 1, &status );
if ( status != MStatus::kSuccess ) return false;
status = gPlug.setValue ( value.g );
if ( status != MStatus::kSuccess ) return false;
MPlug bPlug = plug.child ( 2, &status );
if ( status != MStatus::kSuccess ) return false;
status = bPlug.setValue ( value.b );
if ( status != MStatus::kSuccess ) return false;
if ( plug.numChildren() >= 4 )
{
MPlug aPlug = plug.child ( 3, &status );
if ( status != MStatus::kSuccess ) return false;
status = aPlug.setValue ( value.a );
if ( status != MStatus::kSuccess ) return false;
}
}
return true;
}
void getConnectedChildPlugs(const char *attrName, MFnDependencyNode& depFn, bool dest, MPlugArray& thisNodePlugs, MPlugArray& otherSidePlugs)
{
MPlug p = depFn.findPlug(attrName);
if (p.isCompound() && !p.isArray())
{
getConnectedChildPlugs(p, dest, thisNodePlugs, otherSidePlugs);
return;
}
if (p.isArray())
{
for (uint i = 0; i < p.numElements(); i++)
{
if (p[i].numConnectedChildren() == 0)
continue;
if (!p[i].isCompound())
getConnectedChildPlugs(p[i], dest, thisNodePlugs, otherSidePlugs);
else
{
if (getAttributeNameFromPlug(p) == MString("colorEntryList"))
{
getConnectedChildPlugs(p[i].child(1), dest, thisNodePlugs, otherSidePlugs);
}
}
}
}
}
//---------------------------------------------------
bool DagHelper::getPlugValue ( const MPlug& plug, MColor& value )
{
MStatus status;
if ( plug.isCompound() && plug.numChildren() >= 3 )
{
status = plug.child ( 0 ).getValue ( value.r );
if ( status != MStatus::kSuccess ) return false;
status = plug.child ( 1 ).getValue ( value.g );
if ( status != MStatus::kSuccess ) return false;
status = plug.child ( 2 ).getValue ( value.b );
if ( status != MStatus::kSuccess ) return false;
if ( plug.numChildren() >= 4 )
{
status = plug.child ( 3 ).getValue ( value.a );
if ( status != MStatus::kSuccess ) return false;
}
else value.a = 1.0f;
return true;
}
else return false;
}
// -------------------------------------------
MPlug AnimationHelper::getTargetedPlug ( MPlug parentPlug, int index )
{
if ( index >= 0 && parentPlug.isCompound() )
{
return parentPlug.child ( index );
}
else if ( index >= 0 && parentPlug.isArray() )
{
return parentPlug.elementByLogicalIndex ( index );
}
else return parentPlug;
}
void getDirectConnectedPlugs(const char *attrName, MFnDependencyNode& depFn, bool dest, MPlugArray& thisNodePlugs, MPlugArray& otherSidePlugs)
{
MPlug thisPlug = depFn.findPlug(attrName);
if (!thisPlug.isArray())
{
if (thisPlug.isConnected())
{
thisNodePlugs.append(thisPlug);
otherSidePlugs.append(getDirectConnectedPlug(thisPlug, dest));
}
return;
}
for (uint i = 0; i < thisPlug.numElements(); i++)
{
if (thisPlug.isCompound())
{
// we only support simple compounds like colorListEntry
if (MString(attrName) == MString("colorEntryList"))
{
MPlug element = thisPlug[i];
if (element.child(0).isConnected())
{
MPlug connectedPlug = element.child(0);
thisNodePlugs.append(connectedPlug);
otherSidePlugs.append(getDirectConnectedPlug(connectedPlug, dest));
}
if (element.child(1).isConnected())
{
MPlug connectedPlug = element.child(1);
thisNodePlugs.append(connectedPlug);
otherSidePlugs.append(getDirectConnectedPlug(connectedPlug, dest));
}
}
}
else{
if (!thisPlug[i].isConnected())
{
continue;
}
MPlug connectedPlug = thisPlug[i];
thisNodePlugs.append(connectedPlug);
otherSidePlugs.append(getDirectConnectedPlug(connectedPlug, dest));
}
}
}
//---------------------------------------------------
bool DagHelper::getPlugValue ( const MObject& node, const String attributeName, MEulerRotation& value )
{
MStatus status;
MPlug plug = MFnDependencyNode ( node ).findPlug ( attributeName.c_str(), &status );
if ( status != MStatus::kSuccess ) return false;
if ( plug.isCompound() && plug.numChildren() >= 3 )
{
status = plug.child ( 0 ).getValue ( value.x );
if ( status != MStatus::kSuccess ) return false;
status = plug.child ( 1 ).getValue ( value.y );
if ( status != MStatus::kSuccess ) return false;
status = plug.child ( 2 ).getValue ( value.z );
if ( status != MStatus::kSuccess ) return false;
return true;
}
else return false;
}
// returns 0 if static, 1 if sampled, and 2 if a curve
int util::getSampledType(const MPlug& iPlug)
{
MPlugArray conns;
iPlug.connectedTo(conns, true, false);
// it's possible that only some element of an array plug or
// some component of a compound plus is connected
if (conns.length() == 0)
{
if (iPlug.isArray())
{
unsigned int numConnectedElements = iPlug.numConnectedElements();
for (unsigned int e = 0; e < numConnectedElements; e++)
{
int retVal = getSampledType(iPlug.connectionByPhysicalIndex(e));
if (retVal > 0)
return retVal;
}
}
else if (iPlug.isCompound() && iPlug.numConnectedChildren() > 0)
{
unsigned int numChildren = iPlug.numChildren();
for (unsigned int c = 0; c < numChildren; c++)
{
int retVal = getSampledType(iPlug.child(c));
if (retVal > 0)
return retVal;
}
}
return 0;
}
MObject ob;
MFnDependencyNode nodeFn;
for (unsigned i = 0; i < conns.length(); i++)
{
ob = conns[i].node();
MFn::Type type = ob.apiType();
switch (type)
{
case MFn::kAnimCurveTimeToAngular:
case MFn::kAnimCurveTimeToDistance:
case MFn::kAnimCurveTimeToTime:
case MFn::kAnimCurveTimeToUnitless:
{
nodeFn.setObject(ob);
MPlug incoming = nodeFn.findPlug("i", true);
// sampled
if (incoming.isConnected())
return 1;
// curve
else
return 2;
}
break;
case MFn::kMute:
{
nodeFn.setObject(ob);
MPlug mutePlug = nodeFn.findPlug("mute", true);
// static
if (mutePlug.asBool())
return 0;
// curve
else
return 2;
}
break;
default:
break;
}
}
return 1;
}
// --------------------------------------------------------------------------------------------
MStatus polyModifierCmd::processTweaks( modifyPolyData& data )
// --------------------------------------------------------------------------------------------
{
MStatus status = MS::kSuccess;
// Clear tweak undo information (to be rebuilt)
//
fTweakIndexArray.clear();
fTweakVectorArray.clear();
// Extract the tweaks and place them into a polyTweak node. This polyTweak node
// will be placed ahead of the modifier node to maintain the order of operations.
// Special care must be taken into recreating the tweaks:
//
// 1) Copy tweak info (including connections!)
// 2) Remove tweak info from both meshNode and a duplicate meshNode (if applicable)
// 3) Cache tweak info for undo operations
//
//if( fHasTweaks && fHasHistory && !speedupTweakProcessing())
if( fHasTweaks && fHasHistory )
{
// Declare our function sets
//
MFnDependencyNode depNodeFn;
// Declare our attributes and plugs
//
MPlug meshTweakPlug;
MPlug upstreamTweakPlug;
MObject tweakNodeTweakAttr;
// Declare our tweak processing variables
//
MPlug tweak;
MPlug tweakChild;
MObject tweakData;
MObjectArray tweakDataArray;
MFloatVector tweakVector;
MIntArray tweakSrcConnectionCountArray;
MPlugArray tweakSrcConnectionPlugArray;
MIntArray tweakDstConnectionCountArray;
MPlugArray tweakDstConnectionPlugArray;
MPlugArray tempPlugArray;
unsigned i;
unsigned j;
unsigned k;
// Create the tweak node and get its attributes
//
data.tweakNode = fDGModifier.MDGModifier::createNode( "polyTweak" );
depNodeFn.setObject( data.tweakNode );
data.tweakNodeSrcAttr = depNodeFn.attribute( "output" );
data.tweakNodeDestAttr = depNodeFn.attribute( "inputPolymesh" );
tweakNodeTweakAttr = depNodeFn.attribute( "tweak" );
depNodeFn.setObject( data.meshNodeShape );
meshTweakPlug = depNodeFn.findPlug( "pnts" );
// ASSERT: meshTweakPlug should be an array plug!
//
MStatusAssert( (meshTweakPlug.isArray()),
"meshTweakPlug.isArray() -- meshTweakPlug is not an array plug" );
unsigned numElements = meshTweakPlug.numElements();
// Gather meshTweakPlug data
//
for( i = 0; i < numElements; i++ )
{
// MPlug::numElements() only returns the number of physical elements
// in the array plug. Thus we must use elementByPhysical index when using
// the index i.
//
tweak = meshTweakPlug.elementByPhysicalIndex(i);
// If the method fails, the element is NULL. Only append the index
// if it is a valid plug.
//
if( !tweak.isNull() )
{
// Cache the logical index of this element plug
//
unsigned logicalIndex = tweak.logicalIndex();
// Collect tweak data and cache the indices and float vectors
//
tweak.getValue( tweakData );
tweakDataArray.append( tweakData );
getFloat3PlugValue( tweak, tweakVector );
fTweakIndexArray.append( logicalIndex );
fTweakVectorArray.append( tweakVector );
// Collect tweak connection data
//
// Parse down to the deepest level of the plug tree and check
// for connections - look at the child nodes of the element plugs.
// If any connections are found, record the connection and disconnect
// it.
//
// ASSERT: The element plug should be compound!
//
MStatusAssert( (tweak.isCompound()),
"tweak.isCompound() -- Element tweak plug is not compound" );
unsigned numChildren = tweak.numChildren();
for( j = 0; j < numChildren; j++ )
{
tweakChild = tweak.child(j);
if( tweakChild.isConnected() )
{
// Get all connections with this plug as source, if they exist
//
tempPlugArray.clear();
if( tweakChild.connectedTo( tempPlugArray, false, true ) )
{
unsigned numSrcConnections = tempPlugArray.length();
tweakSrcConnectionCountArray.append( numSrcConnections );
for( k = 0; k < numSrcConnections; k++ )
{
tweakSrcConnectionPlugArray.append( tempPlugArray[k] );
fDGModifier.disconnect( tweakChild, tempPlugArray[k] );
}
}
else
{
tweakSrcConnectionCountArray.append(0);
}
// Get the connection with this plug as destination, if it exists
//
tempPlugArray.clear();
if( tweakChild.connectedTo( tempPlugArray, true, false ) )
{
// ASSERT: tweakChild should only have one connection as destination!
//
MStatusAssert( (tempPlugArray.length() == 1),
"tempPlugArray.length() == 1 -- 0 or >1 connections on tweakChild" );
tweakDstConnectionCountArray.append(1);
tweakDstConnectionPlugArray.append( tempPlugArray[0] );
fDGModifier.disconnect( tempPlugArray[0], tweakChild );
}
else
{
tweakDstConnectionCountArray.append(0);
}
}
else
{
tweakSrcConnectionCountArray.append(0);
tweakDstConnectionCountArray.append(0);
}
}
}
}
// Apply meshTweakPlug data to our polyTweak node
//
MPlug polyTweakPlug( data.tweakNode, tweakNodeTweakAttr );
unsigned numTweaks = fTweakIndexArray.length();
int srcOffset = 0;
int dstOffset = 0;
//Progress initialisieren
progressBar progress("Processing Tweaks", numTweaks);
for( i = 0; i < numTweaks; i++ )
{
// Apply tweak data
//
tweak = polyTweakPlug.elementByLogicalIndex( fTweakIndexArray[i] );
tweak.setValue( tweakDataArray[i] );
// ASSERT: Element plug should be compound!
//
MStatusAssert( (tweak.isCompound()),
"tweak.isCompound() -- Element plug, 'tweak', is not compound" );
unsigned numChildren = tweak.numChildren();
for( j = 0; j < numChildren; j++ )
{
tweakChild = tweak.child(j);
// Apply tweak source connection data
//
if( 0 < tweakSrcConnectionCountArray[i*numChildren + j] )
{
for( k = 0;
k < (unsigned) tweakSrcConnectionCountArray[i*numChildren + j];
k++ )
{
fDGModifier.connect( tweakChild,
tweakSrcConnectionPlugArray[srcOffset] );
srcOffset++;
}
}
// Apply tweak destination connection data
//
if( 0 < tweakDstConnectionCountArray[i*numChildren + j] )
{
fDGModifier.connect( tweakDstConnectionPlugArray[dstOffset],
tweakChild );
dstOffset++;
}
}
if(i%50 == 0)
{
progress.set(i);
}
}
// Now, set the tweak values on the meshNode(s) to zero (History dependent)
//
MFnNumericData numDataFn;
MObject nullVector;
// Create a NULL vector (0,0,0) using MFnNumericData to pass into the plug
//
numDataFn.create( MFnNumericData::k3Float );
numDataFn.setData( 0, 0, 0 );
nullVector = numDataFn.object();
for( i = 0; i < numTweaks; i++ )
{
// Access using logical indices since they are the only plugs guaranteed
// to hold tweak data.
//
tweak = meshTweakPlug.elementByLogicalIndex( fTweakIndexArray[i] );
tweak.setValue( nullVector );
}
// Only have to clear the tweaks off the duplicate mesh if we do not have history
// and we want history.
//
if( !fHasHistory && fHasRecordHistory )
{
depNodeFn.setObject( data.upstreamNodeShape );
upstreamTweakPlug = depNodeFn.findPlug( "pnts" );
if( !upstreamTweakPlug.isNull() )
{
for( i = 0; i < numTweaks; i++ )
{
tweak = meshTweakPlug.elementByLogicalIndex( fTweakIndexArray[i] );
tweak.setValue( nullVector );
}
}
}
}
else
fHasTweaks = false;
return status;
}
void ShadingNetworkExporter::createShader(const MObject& node)
{
MStatus status;
MFnDependencyNode depNodeFn(node);
const OSLShaderInfo *shaderInfo =
ShadingNodeRegistry::getShaderInfo(depNodeFn.typeName());
if(!shaderInfo)
{
std::cout << "Skipping unsupported shader: " << depNodeFn.typeName() << "\n";
return;
}
if(m_shadersExported.count(depNodeFn.name()) != 0)
{
std::cout << "Skipping already exported shader: " << depNodeFn.name() << "\n";
return;
}
m_shadersExported.insert(depNodeFn.name());
asr::ParamArray shaderParams;
for(int i = 0, e = shaderInfo->paramInfo.size(); i < e; ++i)
{
const OSLParamInfo& paramInfo = shaderInfo->paramInfo[i];
// Skip output attributes.
if(paramInfo.isOutput)
{
std::cout << "Skipping output attribute: " << "\n";
std::cout << paramInfo << std::endl;
continue;
}
if(!paramInfo.validDefault)
{
std::cout << "Skipping attribute without valid default: " << "\n";
std::cout << paramInfo << std::endl;
continue;
}
if(paramInfo.isArray)
{
std::cout << "Skipping array attribute: " << "\n";
std::cout << paramInfo << std::endl;
continue;
}
MPlug plug = depNodeFn.findPlug(paramInfo.mayaAttributeName, &status);
if(!status)
{
std::cout << "Skipping unknown attribute: "
<< paramInfo.mayaAttributeName << std::endl;
continue;
}
if(plug.isConnected())
{
MObject srcNode;
if(AttributeUtils::get(plug, srcNode))
createShader(srcNode);
continue;
}
if(plug.isCompound() && plug.numConnectedChildren() != 0)
{
std::cout << "Skipping connected compound attribute: " << plug.name() << "\n";
continue;
}
if(plug.isArray() && plug.numConnectedElements() != 0)
{
std::cout << "Skipping connected array attribute: " << plug.name() << "\n";
continue;
}
processAttribute(plug, paramInfo, shaderParams);
}
m_shaderGroup->add_shader(
shaderInfo->shaderType.asChar(),
shaderInfo->shaderName.asChar(),
depNodeFn.name().asChar(),
shaderParams);
}
void ShadingNetworkExporter::addConnections(const MObject& node)
{
MStatus status;
MFnDependencyNode depNodeFn(node);
const OSLShaderInfo *shaderInfo =
ShadingNodeRegistry::getShaderInfo(depNodeFn.typeName());
if(!shaderInfo)
{
std::cout << "Skipping unsupported shader: " << depNodeFn.typeName() << "\n";
return;
}
if(m_shadersExported.count(depNodeFn.name()) != 0)
{
std::cout << "Skipping already exported shader: " << depNodeFn.name() << "\n";
return;
}
m_shadersExported.insert(depNodeFn.name());
for(int i = 0, e = shaderInfo->paramInfo.size(); i < e; ++i)
{
const OSLParamInfo& paramInfo = shaderInfo->paramInfo[i];
// Skip output attributes.
if(paramInfo.isOutput)
continue;
MPlug plug = depNodeFn.findPlug(paramInfo.mayaAttributeName, &status);
if(!status)
{
std::cout << "Skipping unknown attribute: "
<< paramInfo.mayaAttributeName << std::endl;
continue;
}
if(plug.isConnected())
{
MPlug srcPlug;
if(AttributeUtils::getPlugConnectedTo(plug, srcPlug))
{
MFnDependencyNode srcDepNodeFn(srcPlug.node());
const OSLShaderInfo *srcShaderInfo =
ShadingNodeRegistry::getShaderInfo(srcDepNodeFn.typeName());
if(!srcShaderInfo)
continue;
if(const OSLParamInfo *srcParamInfo = srcShaderInfo->findParam(srcPlug.name()))
{
m_shaderGroup->add_connection(
srcDepNodeFn.name().asChar(),
srcParamInfo->paramName.asChar(),
depNodeFn.name().asChar(),
paramInfo.paramName.asChar());
}
addConnections(srcPlug.node());
}
}
if(plug.isCompound() && plug.numConnectedChildren() != 0)
{
// ???
}
if(plug.isArray() && plug.numConnectedElements() != 0)
{
// ???
}
}
}
