// getBindPoseMatrix.
// should be a relatively harmless function.
// well you're wrong: this is one of the most stupid/difficult things in
// Maya:
// 1st try: just get the "bindPose"-plug, and use it as matrix:
// MFnIkJoint joint(jointPath.node());
// MPlug bindMatrixPlug = joint.findPlug("bindPose");
// MObject bindMatrixObject;
// bindMatrixPlug.getValue(bindMatrixObject);
// MFnMatrixData matrixData(bindMatrixObject);
// MMatrix bindMatrix = matrixData.matrix();
// Looks correct. But isn't. Not only, that we want the local
// transform (but that wouldn't be difficult (just look at the
// parent...), the bindPose plug seems
// to be shared between instances. If a joint is instanced, the
// bindMatrix would be the same as for the other instance. Bad luck :(
// 2nd try: extract the local-transform out of the bindPose-plug. That's
// what is done here. (at least for now. (seen first in
// MS' xporttranslator).
// Still not the really correct way: it's possible to break the
// bindPose-plug. Maya still works, but our exporter doesn't.
// 3rd (and correct way):
// http://www.greggman.com/pages/mayastuff.htm
//
// again: not yet very much error-checking...
MMatrix
BindPoseTool::getBindPoseMatrix(MFnIkJoint joint) const
{
// get bindPose-plug on joint
MPlug tempBindPosePlug = joint.findPlug("bindPose");
MPlugArray mapConnections;
tempBindPosePlug.connectedTo(mapConnections, false, true);
if (mapConnections.length() != 1)
{
//cout << "returning currentMatrix" << endl;
// certainly not the most correct way of dealing with the problem...
return joint.transformation().asMatrix();
}
// find the other end. actually we shouldn't call it "bindPosePlug",
// but worldTransformPlug (as that's where it enters).
// theoretically someone could bind the bindPose to other nodes,
// than the bindPose-node. in this case there's a problem.
MPlug bindPosePlug = mapConnections[0];
// this node should be a "dagPose"-node (in case you want to look it
// up in the help)
MFnDependencyNode bindPoseNode(bindPosePlug.node());
// and as such, has the "xformMatrix"-attribute.
MObject xformMatrixAttribute = bindPoseNode.attribute("xformMatrix");
MPlug localTransformPlug(bindPosePlug.node(), xformMatrixAttribute);
// xformMatrix is an array. to get our localmatrix we need to select
// the same index, as our bindPosePlug (logicalIndex()).
localTransformPlug.selectAncestorLogicalIndex(
bindPosePlug.logicalIndex(), xformMatrixAttribute);
MObject localMatrixObject;
localTransformPlug.getValue(localMatrixObject);
// extract the matrix out of the object.
return MFnMatrixData(localMatrixObject).matrix();
}
MStatus
HRBFSkinCluster::deform( MDataBlock& block,
MItGeometry& iter,
const MMatrix& m,
unsigned int multiIndex)
//
// Method: deform1
//
// Description: Deforms the point with a simple smooth skinning algorithm
//
// Arguments:
// block : the datablock of the node
// iter : an iterator for the geometry to be deformed
// m : matrix to transform the point into world space
// multiIndex : the index of the geometry that we are deforming
//
//
{
MStatus returnStatus;
// get HRBF status
MDataHandle HRBFstatusData = block.inputValue(rebuildHRBF, &returnStatus);
McheckErr(returnStatus, "Error getting rebuildHRBF handle\n");
int rebuildHRBFStatusNow = HRBFstatusData.asInt();
// handle signaling to the rest of deform that HRBFs must be rebuild
bool signalRebuildHRBF = false;
signalRebuildHRBF = (rebuildHRBFStatus != rebuildHRBFStatusNow);
MMatrixArray bindTFs; // store just the bind transforms in here.
MMatrixArray boneTFs; // ALWAYS store just the bone transforms in here.
// get HRBF export status
MDataHandle exportCompositionData = block.inputValue(exportComposition, &returnStatus);
McheckErr(returnStatus, "Error getting exportComposition handle\n");
int exportCompositionStatusNow = exportCompositionData.asInt();
MDataHandle HRBFExportSamplesData = block.inputValue(exportHRBFSamples, &returnStatus);
McheckErr(returnStatus, "Error getting exportHRBFSamples handle\n");
std::string exportHRBFSamplesStatusNow = HRBFExportSamplesData.asString().asChar();
MDataHandle HRBFExportValuesData = block.inputValue(exportHRBFValues, &returnStatus);
McheckErr(returnStatus, "Error getting exportHRBFValues handle\n");
std::string exportHRBFValuesStatusNow = HRBFExportValuesData.asString().asChar();
// get skinning type
MDataHandle useDQData = block.inputValue(useDQ, &returnStatus);
McheckErr(returnStatus, "Error getting useDQ handle\n");
int useDQNow = useDQData.asInt();
// determine if we're using HRBF
MDataHandle useHRBFData = block.inputValue(useHRBF, &returnStatus);
McheckErr(returnStatus, "Error getting useHRBFData handle\n");
int useHRBFnow = useHRBFData.asInt();
// get envelope because why not
MDataHandle envData = block.inputValue(envelope, &returnStatus);
float env = envData.asFloat();
// get point in space for evaluating HRBF
MDataHandle checkHRBFAtData = block.inputValue(checkHRBFAt, &returnStatus);
McheckErr(returnStatus, "Error getting useDQ handle\n");
double* data = checkHRBFAtData.asDouble3();
// get the influence transforms
//
MArrayDataHandle transformsHandle = block.inputArrayValue( matrix ); // tell block what we want
int numTransforms = transformsHandle.elementCount();
if ( numTransforms == 0 ) { // no transforms, no problems
return MS::kSuccess;
}
MMatrixArray transforms; // fetch transform matrices -> actual joint matrices
for ( int i=0; i<numTransforms; ++i ) {
MMatrix worldTF = MFnMatrixData(transformsHandle.inputValue().data()).matrix();
transforms.append(worldTF);
boneTFs.append(worldTF);
transformsHandle.next();
}
// inclusive matrices inverse of the driving transform at time of bind
// matrices for transforming vertices to joint local space
MArrayDataHandle bindHandle = block.inputArrayValue( bindPreMatrix ); // tell block what we want
if ( bindHandle.elementCount() > 0 ) {
for ( int i=0; i<numTransforms; ++i ) {
MMatrix bind = MFnMatrixData(bindHandle.inputValue().data()).matrix();
transforms[i] = bind * transforms[i];
bindHandle.next();
if (signalRebuildHRBF) bindTFs.append(bind);
}
}
MArrayDataHandle weightListHandle = block.inputArrayValue(weightList);
if (weightListHandle.elementCount() == 0) {
// no weights - nothing to do
std::cout << "no weights!" << std::endl;
//rebuildHRBFStatus = rebuildHRBFStatusNow - 1; // HRBFs will need to rebuilt no matter what
return MS::kSuccess;
}
// print HRBF samples if requested
if (exportHRBFSamplesStatusNow != exportHRBFSamplesStatus) {
std::cout << "instructed to export HRBF samples: " << exportHRBFSamplesStatusNow.c_str() << std::endl;
exportHRBFSamplesStatus = exportHRBFSamplesStatusNow;
// TODO: handle exporting HRBFs to the text file format
hrbfMan->debugSamplesToConsole(exportHRBFSamplesStatus);
}
// print HRBF values if requested
if (exportHRBFValuesStatusNow != exportHRBFValuesStatus) {
std::cout << "instructed to export HRBF values: " << exportHRBFValuesStatusNow.c_str() << std::endl;
exportHRBFValuesStatus = exportHRBFValuesStatusNow;
// TODO: handle exporting HRBFs to the text file format
hrbfMan->debugValuesToConsole(exportHRBFValuesStatus);
}
// print HRBF composition if requested
if (exportCompositionStatusNow != exportCompositionStatus) {
std::cout << "instructed to export HRBF composition." << std::endl;
exportCompositionStatus = exportCompositionStatusNow;
// TODO: handle exporting HRBFs to the text file format
hrbfMan->debugCompositionToConsole(boneTFs, numTransforms);
}
// check the HRBF value if the new point is significantly different
MPoint checkHRBFHereNow(data[0], data[1], data[2]);
if ((checkHRBFHereNow - checkHRBFHere).length() > 0.0001) {
if (hrbfMan->m_HRBFs.size() == numTransforms) {
std::cout << "checking HRBF at x:" << data[0] << " y: " << data[1] << " z: " << data[2] << std::endl;
hrbfMan->compose(boneTFs);
float val = 0.0f;
float dx = 0.0f;
float dy = 0.0f;
float dz = 0.0f;
float grad = 0.0f;
hrbfMan->mf_vals->trilinear(data[0], data[1], data[2], val);
hrbfMan->mf_gradX->trilinear(data[0], data[1], data[2], dx);
hrbfMan->mf_gradY->trilinear(data[0], data[1], data[2], dy);
hrbfMan->mf_gradZ->trilinear(data[0], data[1], data[2], dz);
hrbfMan->mf_gradMag->trilinear(data[0], data[1], data[2], grad);
std::cout << "val: " << val << " dx: " << dx << " dy: " << dy << " dz: " << dz << " grad: " << grad << std::endl;
checkHRBFHere = checkHRBFHereNow;
}
}
// rebuild HRBFs if needed
if (signalRebuildHRBF) {
std::cout << "instructed to rebuild HRBFs" << std::endl;
rebuildHRBFStatus = rebuildHRBFStatusNow;
MArrayDataHandle parentIDCsHandle = block.inputArrayValue(jointParentIdcs); // tell block what we want
std::vector<int> jointParentIndices(numTransforms);
if (parentIDCsHandle.elementCount() > 0) {
for (int i = 0; i<numTransforms; ++i) {
jointParentIndices[i] = parentIDCsHandle.inputValue().asInt();
parentIDCsHandle.next();
}
}
MArrayDataHandle jointNamesHandle = block.inputArrayValue(jointNames); // tell block what we want
std::vector<std::string> jointNames(numTransforms);
if (jointNamesHandle.elementCount() > 0) {
for (int i = 0; i<numTransforms; ++i) {
jointNames[i] = jointNamesHandle.inputValue().asString().asChar();
jointNamesHandle.next();
}
}
// debug
//std::cout << "got joint hierarchy info! it's:" << std::endl;
//for (int i = 0; i < numTransforms; ++i) {
// std::cout << i << ": " << jointNames[i].c_str() << " : " << jointParentIndices[i] << std::endl;
//}
std::cout << "rebuilding HRBFs... " << std::endl;
hrbfMan->buildHRBFs(jointParentIndices, jointNames, bindTFs, boneTFs,
weightListHandle, iter, weights);
std::cout << "done rebuilding!" << std::endl;
weightListHandle.jumpToElement(0); // reset this, it's an iterator. trust me.
iter.reset(); // reset this iterator so we can go do normal skinning
}
// perform traditional skinning
if (useDQNow != 0) {
returnStatus = skinDQ(transforms, numTransforms, weightListHandle, iter);
}
else {
returnStatus = skinLB(transforms, numTransforms, weightListHandle, iter);
}
// do HRBF corrections
if (useHRBFnow != 0) {
if (hrbfMan->m_HRBFs.size() == numTransforms) {
hrbfMan->compose(boneTFs);
iter.reset();
hrbfMan->correct(iter);
}
}
return returnStatus;
}
