MObject GlobalComponent::loadComponent(MDGModifier & dgMod) {
MStatus status = MS::kFailure;
this->m_metaDataNode = dgMod.createNode( "MDGlobalNode", &status );
MyCheckStatus(status, "createNode failed");
MString metaNodeName = "MGN_";
metaNodeName += this->m_rigName + "_";
metaNodeName += this->m_pCompGuide->getName();
dgMod.renameNode(this->m_metaDataNode, metaNodeName);
MFnDependencyNode depMetaDataNodeFn(this->m_metaDataNode);
status = dgMod.newPlugValueFloat( depMetaDataNodeFn.findPlug("version"), this->m_pCompGuide->getVersion() );
MyCheckStatus(status, "newPlugValueFloat() failed");
status = dgMod.newPlugValueString( depMetaDataNodeFn.findPlug("rigId"), this->m_pCompGuide->getRigId() );
MyCheckStatus(status, "newPlugValueInt() failed");
GlobalComponentGuidePtr globalGuide = boost::dynamic_pointer_cast<GlobalComponentGuide>(this->m_pCompGuide);
MString ctlColor = globalGuide->getColor();
MString ctlIcon = globalGuide->getIcon();
status = MGlobal::executeCommand( "python(\"control = rig101().rig101WCGetByName('" + ctlIcon + "')\");" );
status = MGlobal::executeCommand( "python(\"Utils.setControllerColor(control, '" + ctlColor + "')\");" );
MCommandResult res;
status = MGlobal::executeCommand( MString("python(\"control.fullPath()\");"), res );
int resType = res.resultType();
if( resType == MCommandResult::kString ) {
MString sResult;
res.getResult(sResult);
MObject ctlObj;
status = lrutils::getObjFromName(sResult, ctlObj);
MyCheckStatus(status, "lrutils::getObjFromName() failed");
MVectorArray ctlLocation = this->m_pCompGuide->getLocation(0);
MFnTransform transformFn( ctlObj );
lrutils::setLocation(ctlObj, ctlLocation, MFnTransform::MFnTransform(), false, false, true);
MString ctlName = this->m_rigName + "_" + this->m_pCompGuide->getName() + "_CTL";
dgMod.renameNode(ctlObj, ctlName);
dgMod.doIt();
//add the metaParent attribute to the controller
MFnMessageAttribute mAttr;
MObject transformAttr = mAttr.create("metaParent", "metaParent");
transformFn.addAttribute(transformAttr);
//connect the controller's metaParent to the MDGlobal node
status = dgMod.connect( depMetaDataNodeFn.findPlug("controller"), transformFn.findPlug("metaParent") );
MObject ctlGroupObj;
lrutils::makeHomeNull(ctlObj, MFnTransform(), ctlGroupObj);
lrutils::setLocation(ctlGroupObj, ctlLocation, MFnTransform::MFnTransform(), true, true, false);
MFnTransform ctlGroupFn( ctlGroupObj );
//add the metaParent attribute to the controller group
ctlGroupFn.addAttribute(mAttr.create("metaParent", "metaParent"));
//connect the controller group's metaParent to the MDGlobal node
status = dgMod.connect( depMetaDataNodeFn.findPlug("controllerGroup"), ctlGroupFn.findPlug("metaParent") );
MyCheckStatus(status, "connect failed");
MObject metaRootObj;
status = lrutils::getMetaRootByName(metaRootObj, this->m_rigName);
MyCheckStatus(status, "lrutils::getMetaRootByName() failed");
MObject rigCtlGroupObj;
status = lrutils::getMetaNodeConnection(metaRootObj, rigCtlGroupObj, "ctlGroup");
MyCheckStatus(status, "lrutils::getMetaNodeConnection() failed");
MFnTransform rigCtlGroupFn( rigCtlGroupObj );
rigCtlGroupFn.addChild( ctlGroupObj );
//add controller to controller display layer
MObject controlLayerObj;
status = lrutils::getMetaNodeConnection(metaRootObj, controlLayerObj, "ctlLayer");
MyCheckStatus(status, "lrutils::getMetaNodeConnection() failed");
MFnDependencyNode controlLayerFn(controlLayerObj);
MString controlLayerName = controlLayerFn.name();
MGlobal::executeCommand("editDisplayLayerMembers -noRecurse "+controlLayerName+" "+rigCtlGroupFn.name()+";");
//create parent constraints from the global controller to the rig group
MObject rigRigGroupObj;
status = lrutils::getMetaNodeConnection(metaRootObj, rigRigGroupObj, "rigGroup");
MFnTransform rigRigGroupFn( rigRigGroupObj );
MGlobal::executeCommand("parentConstraint -mo "+transformFn.name()+" "+rigRigGroupFn.name()+";", res);
//connect the parent constraint object to the component's metadata node
MStringArray sResults;
res.getResult(sResults);
status = lrutils::getObjFromName(sResults[0], this->m_rigParentConstraint);
MyCheckStatus(status, "lrutils::getObjFromName() failed");
MFnTransform rigParentConstraintFn( this->m_rigParentConstraint);
rigParentConstraintFn.addAttribute(mAttr.create("metaParent", "metaParent"));
status = dgMod.connect( depMetaDataNodeFn.findPlug("rigParentConstraint"), rigParentConstraintFn.findPlug("metaParent"));
//create the scale constraint from the global controller to the rig group
MGlobal::executeCommand("scaleConstraint -mo "+transformFn.name()+" "+rigRigGroupFn.name()+";", res);
//connect the scale constraint object to the component's metadata node
res.getResult(sResults);
status = lrutils::getObjFromName(sResults[0], this->m_rigScaleConstraint);
MyCheckStatus(status, "lrutils::getObjFromName() failed");
MFnTransform rigScaleConstraintFn( this->m_rigScaleConstraint );
rigScaleConstraintFn.addAttribute(mAttr.create("metaParent", "metaParent"));
status = dgMod.connect( depMetaDataNodeFn.findPlug("rigScaleConstraint"), rigScaleConstraintFn.findPlug("metaParent"));
//create scale constraint from the global controller to the noTransform group
MObject rigNoTransformGroupObj;
status = lrutils::getMetaNodeConnection(metaRootObj, rigNoTransformGroupObj, "noTransformGroup");
MFnTransform rigNoTransformGroupFn( rigNoTransformGroupObj );
MGlobal::executeCommand("scaleConstraint -mo "+transformFn.name()+" "+rigNoTransformGroupFn.name()+";", res);
//connect the scale constraint object to the component's metadata node
res.getResult(sResults);
status = lrutils::getObjFromName(sResults[0], this->m_noTransformScaleConstraint);
MyCheckStatus(status, "lrutils::getObjFromName() failed");
MFnTransform noTransformScaleConstraintFn( this->m_noTransformScaleConstraint);
noTransformScaleConstraintFn.addAttribute(mAttr.create("metaParent", "metaParent"));
status = dgMod.connect( depMetaDataNodeFn.findPlug("noTransformScaleConstraint"), noTransformScaleConstraintFn.findPlug("metaParent"));
}
return this->m_metaDataNode;
}
IECore::DataPtr convert( const MCommandResult &result )
{
MStatus s;
switch (result.resultType())
{
case MCommandResult::kInvalid:
{
// No result
return 0;
}
case MCommandResult::kInt:
{
int i;
s = result.getResult(i);
assert(s);
IECore::IntDataPtr data = new IECore::IntData();
data->writable() = i;
return data;
}
case MCommandResult::kIntArray:
{
MIntArray v;
s = result.getResult(v);
assert(s);
unsigned sz = v.length();
IECore::IntVectorDataPtr data = new IECore::IntVectorData();
data->writable().resize(sz);
for (unsigned i = 0; i < sz; i++)
{
(data->writable())[i] = v[i];
}
return data;
}
case MCommandResult::kDouble:
{
double d;
s = result.getResult(d);
assert(s);
IECore::FloatDataPtr data = new IECore::FloatData();
data->writable() = static_cast<float>(d);
return data;
}
case MCommandResult::kDoubleArray:
{
MDoubleArray v;
s = result.getResult(v);
assert(s);
unsigned sz = v.length();
IECore::DoubleVectorDataPtr data = new IECore::DoubleVectorData();
data->writable().resize(sz);
for (unsigned i = 0; i < sz; i++)
{
data->writable()[i] = v[i];
}
return data;
}
case MCommandResult::kString:
{
MString str;
s = result.getResult(str);
assert(s);
IECore::StringDataPtr data = new IECore::StringData();
data->writable() = std::string(str.asChar());
return data;
}
case MCommandResult::kStringArray:
{
MStringArray v;
s = result.getResult(v);
assert(s);
unsigned sz = v.length();
IECore::StringVectorDataPtr data = new IECore::StringVectorData();
data->writable().resize(sz);
for (unsigned i = 0; i < sz; i++)
{
data->writable()[i] = std::string(v[i].asChar());
}
return data;
}
case MCommandResult::kVector:
{
MVector v;
s = result.getResult(v);
assert(s);
IECore::V3fDataPtr data = new IECore::V3fData();
data->writable() = Imath::V3f(v.x, v.y, v.z);
return data;
}
case MCommandResult::kVectorArray:
{
MVectorArray v;
s = result.getResult(v);
assert(s);
unsigned sz = v.length();
IECore::V3fVectorDataPtr data = new IECore::V3fVectorData();
data->writable().resize(sz);
for (unsigned i = 0; i < sz; i++)
{
data->writable()[i] = Imath::V3f(v[i].x, v[i].y, v[i].z);
}
return data;
}
case MCommandResult::kMatrix:
{
MDoubleArray v;
int numRows, numColumns;
s = result.getResult(v, numRows, numColumns);
assert(s);
if (numRows > 4 || numColumns > 4)
{
throw IECoreMaya::StatusException( MS::kFailure );
}
IECore::M44fDataPtr data = new IECore::M44fData();
for (int i = 0; i < numColumns; i++)
{
for (int j = 0; j < numRows; j++)
{
(data->writable())[i][j] = v[i*numRows+j];
}
}
return data;
}
case MCommandResult::kMatrixArray:
{
return 0;
}
default:
assert( false );
return 0;
}
}
MStatus puttyNode::deform( MDataBlock& block, MItGeometry& iter, const MMatrix& worldMatrix, unsigned int multiIndex)
{
// MGlobal::displayInfo("deform");
MStatus status = MS::kSuccess;
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// get inputs
//
// get the node ready flag
MDataHandle dh = block.inputValue(aScriptSourced,&status);
SYS_ERROR_CHECK(status, "Error getting aScriptSourced data handle\n");
bool scriptSourced = dh.asBool();
if (!scriptSourced)
return MS::kSuccess;
dh = block.inputValue(aNodeReady,&status);
SYS_ERROR_CHECK(status, "Error getting node ready data handle\n");
bool nodeReady = dh.asBool();
// if it's not ready, don't do anything
if (!nodeReady)
return MS::kSuccess;
dh = block.inputValue(aDefSpace,&status);
SYS_ERROR_CHECK(status, "Error getting defSpace data handle\n");
short defSpace = dh.asShort();
dh = block.inputValue(aDefWeights,&status);
SYS_ERROR_CHECK(status, "Error getting defWeights data handle\n");
short defWeights = dh.asShort();
dh = block.inputValue(aDefEnvelope,&status);
SYS_ERROR_CHECK(status, "Error getting defEnvelope data handle\n");
short defEnvelope = dh.asShort();
// get the command
dh = block.inputValue(aCmdBaseName,&status);
SYS_ERROR_CHECK(status, "Error getting aCmdBaseName handle\n");
MString script = dh.asString();
/* if (script == "")
{
status = MS::kFailure;
USER_ERROR_CHECK(status, "no script provided!\n");
}
*/
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// build mel cmd string
//
// check if it's a valid cmd
// get the envelope
//
double env = 1;
if (defEnvelope == MSD_ENVELOPE_AUTO)
{
dh = block.inputValue(envelope,&status);
SYS_ERROR_CHECK(status, "Error getting envelope data handle\n");
env = double(dh.asFloat());
// early stop 'cause there is nothing more to do
if (env == 0.0)
return MS::kSuccess;
}
// get the points, transform them into the right space if needed
//
int count = iter.count();
MVectorArray points(count);
for ( ; !iter.isDone(); iter.next())
points[iter.index()] = iter.position();
if ( defSpace == MSD_SPACE_WORLD )
{
for (int i = 0;i<count;i++)
points[i] = MPoint(points[i]) * worldMatrix;
}
// get the weights
//
MDoubleArray weights;
if ( defWeights == MSD_WEIGHTS_AUTO)
{
weights.setLength(count);
for (int i = 0;i<count;i++)
weights[i] = weightValue(block,multiIndex,i);
}
// get the object name and type
// get the input geometry, traverse through the data handles
MArrayDataHandle adh = block.outputArrayValue( input, &status );
SYS_ERROR_CHECK(status,"error getting input array data handle.\n");
status = adh.jumpToElement( multiIndex );
SYS_ERROR_CHECK(status, "input jumpToElement failed.\n");
// compound data
MDataHandle cdh = adh.inputValue( &status );
SYS_ERROR_CHECK(status, "error getting input inputValue\n");
// input geometry child
dh = cdh.child( inputGeom );
MObject dInputGeometry = dh.data();
// get the type
MString geometryType = dInputGeometry.apiTypeStr();
// get the name
// MFnDagNode dagFn( dInputGeometry, &status);
// SYS_ERROR_CHECK(status, "error converting geometry obj to dag node\n");
// MString geometryName = dagFn.fullPathName(&status);
// SYS_ERROR_CHECK(status, "error getting full path name \n");
// MString geometryType = "";
// MString geometryName = "";
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// set the current values on the temp plugs for the script to be picked up
//
// the position
MObject thisNode = thisMObject();
MPlug currPlug(thisNode,aCurrPosition);
MFnVectorArrayData vecD;
MObject currObj = vecD.create(points,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currPosPlug value\n");
// the weights
currPlug =MPlug(thisNode,aCurrWeight);
MFnDoubleArrayData dblD;
currObj = dblD.create(weights,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currWeightsPlug value\n");
// world matrix
currPlug =MPlug(thisNode,aCurrWorldMatrix);
MFnMatrixData matD;
currObj = matD.create(worldMatrix,&status);
currPlug.setValue(currObj);
SYS_ERROR_CHECK(status, "error setting currWorldMatrixPlug value\n");
// the multi index
currPlug =MPlug(thisNode,aCurrMultiIndex);
currPlug.setValue(int(multiIndex));
SYS_ERROR_CHECK(status, "error setting currMultiIndexPlug value\n");
// geometry name/type
// currPlug =MPlug(thisNode,aCurrGeometryName);
// currPlug.setValue(geometryName);
// SYS_ERROR_CHECK(status, "error setting aCurrGeometryName value\n");
currPlug =MPlug(thisNode,aCurrGeometryType);
currPlug.setValue(geometryType);
SYS_ERROR_CHECK(status, "error setting aCurrGeometryType value\n");
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// execute the mel script
//
MString melCmd = script+"(\"" +name()+"\","+count+")";
MCommandResult melResult;
status = MGlobal::executeCommand(melCmd,melResult);
// if the command did not work, then try to resource the script
// (might have been that we were in a fresh scene and nothing was ready yet
if (status != MS::kSuccess)
{
dh = block.inputValue(aScript,&status);
SYS_ERROR_CHECK(status, "Error getting aCmdBaseName handle\n");
MString scriptFile = dh.asString();
// try to source the script
MString cmd = "source \"" + scriptFile+"\"";
MCommandResult melResult;
status = MGlobal::executeCommand(cmd,melResult);
// if successfull, retry the command
if (!status.error())
{
status = MGlobal::executeCommand(melCmd,melResult);
}
}
USER_ERROR_CHECK(status, "Error executing mel command, please check the function you provided is valid, error free and has the appropriate parameters!");
// check the result type
if ((melResult.resultType()) != (MCommandResult::kDoubleArray))
{
USER_ERROR_CHECK(MS::kFailure, "result of mel command has wrong type, should be doubleArray (which will be interpreted as vectorArray)!");
}
// get the result as a double array
MDoubleArray newP;
status = melResult.getResult(newP);
USER_ERROR_CHECK(status, "Error getting result of mel command!");
int newCount = newP.length()/3;
// size check
if (newCount != count)
{
USER_ERROR_CHECK(MS::kFailure, "the size of the result does not match the size of the input!");
}
// convert the double array into a vector array
MPointArray newPoints(newCount);
for(int i=0;i<newCount;i++)
newPoints[i]=MPoint(newP[i*3],newP[i*3+1],newP[i*3+2]);
/////////////////////////////////////////////////////////////////////////////////////////////////
//
// interprete and apply the result
//
// do the envelope and weights
if ((defEnvelope == MSD_ENVELOPE_AUTO)||((defWeights == MSD_WEIGHTS_AUTO)))
{
MDoubleArray envPP(count, env);
if (defWeights == MSD_WEIGHTS_AUTO)
{
for (int i = 0;i<count;i++)
envPP[i] *= weights[i];
}
// linear interpolation between old and new points
for (int i = 0;i<count;i++)
newPoints[i] = (points[i] * (1-envPP[i])) + (newPoints[i] * envPP[i]);
}
// retransform the result if it was in world space
if ( defSpace == MSD_SPACE_WORLD )
{
MMatrix worldMatrixInv = worldMatrix.inverse();
for (int i = 0;i<count;i++)
newPoints[i] *= worldMatrixInv;
}
// set the points
iter.reset();
for ( ; !iter.isDone(); iter.next())
iter.setPosition(newPoints[iter.index()]);
return status;
}
