//---------------------------------------------------
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;
}
//---------------------------------------------------
// set the bind pose for a transform
//
MStatus DagHelper::setBindPoseInverse ( const MObject& node, const MMatrix& bindPoseInverse )
{
MStatus status;
MFnDependencyNode dgFn ( node );
MPlug bindPosePlug = dgFn.findPlug ( "bindPose", &status );
if ( status != MS::kSuccess )
{
MGlobal::displayWarning ( MString ( "No bindPose found on node " ) + dgFn.name() );
return status;
}
MFnMatrixData matrixFn;
MObject val = matrixFn.create ( bindPoseInverse.inverse(), &status );
MObject invval = matrixFn.create ( bindPoseInverse, &status );
if ( status != MS::kSuccess )
{
MGlobal::displayWarning ( MString ( "Error setting bindPose on node " ) + dgFn.name() );
return status;
}
// set the bind pose on the joint itself
bindPosePlug.setValue ( val );
// Now, perhaps more significantly, see if there's a
// skinCluster using this bone and update its bind
// pose (as the joint bind pose is not connected to
// the skin - it's set at bind time from the joint's
// current position, and our importer may not want to
// disturb the current scene state just to put bones
// in a bind position before creating skin clusters)
MObject _node ( node );
MItDependencyGraph it ( _node, MFn::kSkinClusterFilter );
while ( !it.isDone() )
{
MPlug plug = it.thisPlug();
unsigned int idx = plug.logicalIndex();
MFnDependencyNode skinFn ( plug.node() );
MPlug skinBindPosePlug = skinFn.findPlug ( "bindPreMatrix", &status );
if ( status == MS::kSuccess )
{
// The skinCluster stores inverse inclusive matrix
// so notice we use invval (the MObject created off
// the inverse matrix here)
skinBindPosePlug = skinBindPosePlug.elementByLogicalIndex ( idx );
skinBindPosePlug.setValue ( invval );
}
it.next();
}
return status;
}
MStatus MeshParameterHandler::doSetValue( IECore::ConstParameterPtr parameter, MPlug &plug ) const
{
IECore::ConstObjectParameterPtr p = IECore::runTimeCast<const IECore::ObjectParameter>( parameter );
if( !p )
{
return MS::kFailure;
}
MFnMeshData fnData;
MObject data = fnData.create();
/// \todo Pull in userData from parameter to set up conversion parameters
ToMayaObjectConverterPtr converter = ToMayaObjectConverter::create( p->getValue(), MFn::kMeshData );
assert(converter);
bool conversionSuccess = converter->convert( data );
if ( !conversionSuccess )
{
return MS::kFailure;
}
/// \todo It seems like this can occassionally fail, usually with an empty mesh, but sometimes not. Try to establish exactly why.
plug.setValue( data );
return MS::kSuccess;
}
//---------------------------------------------------
bool DagHelper::setPlugValue ( MPlug& plug, MStringArray& stringArray )
{
MObject obj;
MFnStringArrayData fstr;
obj = fstr.create ( stringArray );
return plug.setValue ( obj );
}
//############################################### tima:
bool polyModifierCmd::setZeroTweaks()
{
MFnNumericData numDataFn;
MObject nullVector;
MFnDependencyNode depNodeFn;
numDataFn.create( MFnNumericData::k3Float );
numDataFn.setData( 0, 0, 0 );
nullVector = numDataFn.object();
MObject object = fDagPath.node();
depNodeFn.setObject( object);
MPlug meshTweakPlug = depNodeFn.findPlug( "pnts" );
MPlug tweak;
unsigned numTweaks = fTweakIndexArray.length();
if( !meshTweakPlug.isNull() )
{
for( unsigned i = 0; i < numTweaks; i++ )
{
tweak = meshTweakPlug.elementByLogicalIndex( fTweakIndexArray[i] );
tweak.setValue( nullVector );
}
}
return true;
}
//---------------------------------------------------
bool DagHelper::setPlugValue ( MPlug& plug, float x, float y )
{
MFnNumericData data;
MObject obj = data.create ( MFnNumericData::k2Float );
data.setData ( x, y );
return plug.setValue ( obj );
}
// --------------------------------------------------------------------------------------------
void polyModifierCmd::deleteTweaks()
// --------------------------------------------------------------------------------------------
{
// Now, set the tweak values on the meshNode(s) to zero (History dependent)
//
MStatus stat;
MFnNumericData numDataFn;
MObject nullVector;
// Create a NULL vector (0,0,0) using MFnNumericData to pass into the plug
//
MFnDependencyNode depTmpFn(fDagPath.node(),&stat);
//stat.perror("");
MPlug meshTweakPlug = depTmpFn.findPlug("pnts");
numDataFn.create( MFnNumericData::k3Float );
numDataFn.setData( 0, 0, 0 );
nullVector = numDataFn.object();
unsigned numTweaks = meshTweakPlug.numElements();
MPlug tweak;
for(unsigned i = 0; i < numTweaks; i++ )
{
// Access using logical indices since they are the only plugs guaranteed
// to hold tweak data.
//
tweak = meshTweakPlug.elementByPhysicalIndex(i);
tweak.setValue( nullVector );
}
}
MStatus ClassParameterHandler::storeClass( IECore::ConstParameterPtr parameter, MPlug &plug )
{
IECorePython::ScopedGILLock gilLock;
try
{
boost::python::object pythonParameter( IECore::constPointerCast<IECore::Parameter>( parameter ) );
boost::python::object classInfo = pythonParameter.attr( "getClass" )( true );
std::string className = boost::python::extract<std::string>( classInfo[1] );
int classVersion = boost::python::extract<int>( classInfo[2] );
std::string searchPathEnvVar = boost::python::extract<std::string>( classInfo[3] );
MString storedClassName;
int storedClassVersion;
MString storedSearchPathEnvVar;
currentClass( plug, storedClassName, storedClassVersion, storedSearchPathEnvVar );
// only set the plug values if the new value is genuinely different, as otherwise
// we end up generating unwanted reference edits.
if ( storedClassName != className.c_str() || storedClassVersion != classVersion || storedSearchPathEnvVar != searchPathEnvVar.c_str() )
{
MStringArray updatedClassInfo;
updatedClassInfo.append( className.c_str() );
MString classVersionStr;
classVersionStr.set( classVersion, 0 );
updatedClassInfo.append( classVersionStr );
updatedClassInfo.append( searchPathEnvVar.c_str() );
MObject attribute = plug.attribute();
MFnTypedAttribute fnTAttr( attribute );
if ( fnTAttr.attrType() == MFnData::kStringArray )
{
MObject data = MFnStringArrayData().create( updatedClassInfo );
plug.setValue( data );
}
else
{
// compatibility for the deprecated compound plug behaviour. keeping this code
// so we can still read old scenes. creation of these plugs has been removed.
/// \todo: find all such notes and remove the unnecessary code for Cortex 9.
plug.child( 0 ).setString( className.c_str() );
plug.child( 1 ).setInt( classVersion );
plug.child( 2 ).setString( searchPathEnvVar.c_str() );
}
}
}
catch( boost::python::error_already_set )
{
PyErr_Print();
return MS::kFailure;
}
catch( const std::exception &e )
{
MGlobal::displayError( MString( "ClassParameterHandler::setClass : " ) + e.what() );
return MS::kFailure;
}
return MS::kSuccess;
}
virtual void postLoad()
{
MFnDependencyNode fnDN( m_node->thisMObject() );
MPlug plug = fnDN.findPlug( aResultDependency );
plug.setValue( 1 );
m_node->m_postLoadCallback = 0; // remove this callback
}
MStatus DateTimeParameterHandler::doSetValue( IECore::ConstParameterPtr parameter, MPlug &plug ) const
{
IECore::ConstDateTimeParameterPtr p = IECore::runTimeCast<const IECore::DateTimeParameter>( parameter );
if( !p )
{
return MS::kFailure;
}
return plug.setValue( boost::posix_time::to_iso_string( p->getTypedValue() ).c_str() );
}
MStatus NumericParameterHandler<T>::doSetValue( IECore::ConstParameterPtr parameter, MPlug &plug ) const
{
typename IECore::NumericParameter<T>::ConstPtr p = IECore::runTimeCast<const IECore::NumericParameter<T> >( parameter );
if( !p )
{
return MS::kFailure;
}
return plug.setValue( p->getNumericValue() );
}
//---------------------------------------------------
bool DagHelper::setPlugValue ( MPlug& plug, const MMatrix& value )
{
MStatus status;
MFnMatrixData dataCreator;
MObject matrixData = dataCreator.create ( value, &status );
if ( status != MStatus::kSuccess ) return false;
status = plug.setValue ( matrixData );
if ( status != MStatus::kSuccess ) return false;
return true;
}
void
VertexPolyColourCommand::WriteColoursToNode(MDagPath& dagPath, MColorArray& colors, bool isSource)
{
MStatus status;
// Try to find the colour node attached to the mesh
// If it's not found, create it
MObject ourNode;
if (!FindNodeOnMesh(dagPath,ourNode))
{
CreateNodeOnMesh(dagPath, ourNode);
}
// Send the selection to the node
{
// Pass the component list down to the node.
// To do so, we create/retrieve the current plug
// from the uvList attribute on the node and simply
// set the value to our component list.
//
MDoubleArray dcols;
dcols.setLength(colors.length()*4);
int idx = 0;
for (unsigned int i=0; i<colors.length(); i++)
{
dcols[idx] = (double)colors[i].r; idx++;
dcols[idx] = (double)colors[i].g; idx++;
dcols[idx] = (double)colors[i].b; idx++;
dcols[idx] = (double)colors[i].a; idx++;
}
MFnDoubleArrayData wrapper;
wrapper.create(dcols,&status);
MPlug* colourPlug = NULL;
if (isSource)
{
colourPlug = new MPlug(ourNode, PolyColourNode::m_colors);
}
else
{
colourPlug = new MPlug(ourNode, PolyColourNode::m_colorsDest);
}
// Warning, we have to do this as GCC doesn't like to pass by temporary reference
MObject wrapperObjRef = wrapper.object();
status = colourPlug->setValue(wrapperObjRef);
delete colourPlug;
}
}
//---------------------------------------------------
bool DagHelper::setPlugValue ( MPlug& plug, const MVector& value )
{
MStatus status;
MFnNumericData dataCreator;
MObject float3Data = dataCreator.create ( MFnNumericData::k3Float, &status );
if ( status != MStatus::kSuccess ) return false;
dataCreator.setData ( ( float ) value.x, ( float ) value.y, ( float ) value.z );
status = plug.setValue ( float3Data );
if ( status != MStatus::kSuccess ) return false;
return true;
}
MStatus Maya::SetNodeID( const MObject& node, const Helium::TUID& id )
{
MStatus status;
MFnDependencyNode nodeFn (node);
// make sure we have the dynamic attribute to store our id created
MObject attr = nodeFn.attribute(MString (s_TUIDAttributeName), &status);
if (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 );
}
// create the attribute
MFnTypedAttribute attrFn;
attr = attrFn.create(MString (s_TUIDAttributeName), MString (s_TUIDAttributeName), MFnData::kString);
status = nodeFn.addAttribute(attr);
// reset to the prior state of wasLocked
if ( nodeWasLocked )
{
nodeFn.setLocked( nodeWasLocked );
}
// error check
if (status == MS::kFailure)
{
MGlobal::displayError(MString ("Unable to create TUID attribute on maya node: ") + nodeFn.name());
return status;
}
}
MPlug plug (node, nodeFn.attribute(MString (s_TUIDAttributeName)));
plug.setLocked(false);
tstring s;
id.ToString(s);
plug.setValue(MString(s.c_str()));
plug.setLocked(true);
return status;
}
void MVGMesh::setIsActive(const bool isActive) const
{
MStatus status;
// Check is flag exists
MFnMesh fn(_dagpath);
MPlug mvgPlug = fn.findPlug(_MVG, false, &status);
if(!status && !isActive)
return;
if(!status && isActive)
{
// Create MayaMVG attribute
MDagModifier dagModifier;
MFnNumericAttribute nAttr;
MObject mvgAttr = nAttr.create(_MVG, "mvg", MFnNumericData::kBoolean);
status = dagModifier.addAttribute(_object, mvgAttr);
CHECK(status)
dagModifier.doIt();
mvgPlug = fn.findPlug(_MVG, false, &status);
}
status = mvgPlug.setValue(isActive);
CHECK(status)
if(isActive)
{
status = MGlobal::executePythonCommand("from mayaMVG import scale");
CHECK(status)
MString cmd;
// Retrieve transform node
cmd.format("scale.getParent(\"^1s\")", _dagpath.fullPathName());
MString transform;
status = MGlobal::executePythonCommand(cmd, transform);
// Freeze transform mesh
cmd.format("makeIdentity -apply true \"^1s\"", transform);
status = MGlobal::executeCommand(cmd);
CHECK(status)
// Lock node
cmd.format("scale.lockNode(\"^1s\", True)", transform);
status = MGlobal::executePythonCommand(cmd);
CHECK(status)
}
else
{
//------------------------------------------------------------------------------
//
bool CacheRepresentation::activate()
{
AssemblyDefinition* const assembly =
dynamic_cast< AssemblyDefinition* >( getAssembly() );
if ( assembly == 0 ) {
return false;
}
// Create a gpuCache node, and parent it to our container.
MDagModifier dagMod;
MStatus status;
MObject cacheObj = dagMod.createNode(
MString("gpuCache"), assembly->thisMObject(), &status);
if (status != MStatus::kSuccess) {
int isLoaded = false;
// Validate that the gpuCache plugin is loaded.
MGlobal::executeCommand( "pluginInfo -query -loaded gpuCache", isLoaded );
if(!isLoaded){
MString errorString = MStringResource::getString(rCreateGPUCacheNodeError, status);
MGlobal::displayError(errorString);
}
return false;
}
status = dagMod.doIt();
if (status != MStatus::kSuccess) {
return false;
}
// Set the cache attribute to point to our Alembic file.
MFnDependencyNode cache(cacheObj);
MPlug fileName = cache.findPlug(MString("cacheFileName"), true, &status);
if (status != MStatus::kSuccess) {
return false;
}
fileName.setValue(assembly->getRepData(getName()));
return status == MStatus::kSuccess;
}
// --------------------------------------------------------------------------------------------
MStatus polyModifierCmd::undoTweakProcessing()
// --------------------------------------------------------------------------------------------
{
MStatus status = MS::kSuccess;
if( fHasTweaks )
{
MFnDependencyNode depNodeFn;
MObject meshNodeShape;
MPlug meshTweakPlug;
MPlug tweak;
MObject tweakData;
meshNodeShape = fDagPath.node();
depNodeFn.setObject( meshNodeShape );
meshTweakPlug = depNodeFn.findPlug( "pnts" );
MStatusAssert( (meshTweakPlug.isArray()),
"meshTweakPlug.isArray() -- meshTweakPlug is not an array plug" );
unsigned i;
unsigned numElements = fTweakIndexArray.length();
for( i = 0; i < numElements; i++ )
{
tweak = meshTweakPlug.elementByLogicalIndex( fTweakIndexArray[i] );
getFloat3asMObject( fTweakVectorArray[i], tweakData );
tweak.setValue( tweakData );
}
// In the case of no history, the duplicate node shape will be disconnected on undo
// so, there is no need to undo the tweak processing on it.
//
}
return status;
}
MStatus ObjectParameterHandler::doSetValue( IECore::ConstParameterPtr parameter, MPlug &plug ) const
{
IECore::ConstObjectParameterPtr p = IECore::runTimeCast<const IECore::ObjectParameter>( parameter );
if( !p )
{
return MS::kFailure;
}
// Keep trying all the available handlers until we find one that works.
/// \todo Investigate whether we can do a parameter->getValue() here and just get the handler which represents it
for (IECore::ObjectParameter::TypeIdSet::const_iterator it = p->validTypes().begin(); it != p->validTypes().end(); ++it)
{
ConstParameterHandlerPtr h = ParameterHandler::create( *it );
if (h)
{
if ( h->doSetValue( parameter, plug) )
{
return MS::kSuccess;
}
}
}
MStatus s;
MFnPluginData fnData;
MObject plugData = fnData.create( ObjectData::id );
assert( plugData != MObject::kNullObj );
s = fnData.setObject( plugData );
assert(s);
ObjectData* data = dynamic_cast<ObjectData *>( fnData.data(&s) );
assert(s);
assert(data);
data->setObject( p->getValue()->copy() );
return plug.setValue( plugData );
}
MStatus CmpMeshModifierCmd::undoIt()
{
dagMods[2].undoIt();
// Manually delete the duplicated shape
if( !copyTransform.isNull() )
MGlobal::deleteNode( copyTransform );
dagMods[1].undoIt();
dagMods[0].undoIt();
if( !hasHistory )
// Manually restore the original mesh data since
// it would have been destroyed when the construction
// history was applied
{
MFnDagNode origShapeNodeFn( meshShapePath );
MPlug meshPlug = origShapeNodeFn.findPlug( hasInternalTweaks ? "cachedInMesh" : "outMesh" );
meshPlug.setValue( origMeshData );
}
return MS::kSuccess;
}
//---------------------------------------------------
MObject DagHelper::createAttribute (
const MObject& node,
const char* attributeName,
const char* attributeShortName,
MFnData::Type type,
const char *value )
{
// Before creating a new attribute: verify that an old one doesn't already exist
MStatus status;
MObject attribute;
MFnDependencyNode nodeFn ( node );
MPlug plug = nodeFn.findPlug ( attributeShortName, status );
if ( status != MStatus::kSuccess )
{
MFnTypedAttribute attr;
MStatus status;
attribute = attr.create ( attributeName,attributeShortName,type,&status );
if ( status != MStatus::kSuccess ) return MObject::kNullObj;
attr.setStorable ( true );
attr.setKeyable ( false );
attr.setCached ( true );
attr.setReadable ( true );
attr.setWritable ( true );
status = nodeFn.addAttribute ( attribute, MFnDependencyNode::kLocalDynamicAttr );
if ( status != MStatus::kSuccess ) return MObject::kNullObj;
plug = nodeFn.findPlug ( attribute, &status );
if ( status != MStatus::kSuccess ) return MObject::kNullObj;
}
status = plug.setValue ( value );
if ( status != MStatus::kSuccess ) return MObject::kNullObj;
return attribute;
}
int tm_polygon::removeTweaks_Func( MSelectionList &selectionList)
{
MStatus status;
MObject object;
status = selectionList.getDependNode( 0, object);
if(!status)
{
MGlobal::displayError("***### tm_polygon: Can't find object.");
return 0;
}
MFnMesh mesh( object, &status);
if(!status)
{
MGlobal::displayError("***### tm_polygon: Can't find mesh.");
return 0;
}
int pntsCount = 0;
MPlug pntsPlug = mesh.findPlug( "pnts" );
if( !pntsPlug.isNull() )
{
MPlug tweakPlug;
MObject nullVector_object;
MFnNumericData numDataFn( nullVector_object );
// numDataFn.setData3Double( 0.0, 0.0, 0.0 );
numDataFn.setData( 0.0, 0.0, 0.0 );
pntsCount = pntsPlug.numElements();
for( int i = 0; i < pntsCount; i++ )
{
tweakPlug = pntsPlug.elementByPhysicalIndex( (unsigned int)i, &status );
if( status == MS::kSuccess && !tweakPlug.isNull() )
tweakPlug.setValue( nullVector_object );
}
}
return pntsCount;
}
bool ToMayaSkinClusterConverter::doConversion( IECore::ConstObjectPtr from, MObject &to, IECore::ConstCompoundObjectPtr operands ) const
{
MStatus s;
IECore::ConstSmoothSkinningDataPtr skinningData = IECore::runTimeCast<const IECore::SmoothSkinningData>( from );
assert( skinningData );
const std::vector<std::string> &influenceNames = skinningData->influenceNames()->readable();
const std::vector<Imath::M44f> &influencePoseData = skinningData->influencePose()->readable();
const std::vector<int> &pointIndexOffsets = skinningData->pointIndexOffsets()->readable();
const std::vector<int> &pointInfluenceCounts = skinningData->pointInfluenceCounts()->readable();
const std::vector<int> &pointInfluenceIndices = skinningData->pointInfluenceIndices()->readable();
const std::vector<float> &pointInfluenceWeights = skinningData->pointInfluenceWeights()->readable();
MFnDependencyNode fnSkinClusterNode( to, &s );
MFnSkinCluster fnSkinCluster( to, &s );
if ( s != MS::kSuccess )
{
/// \todo: optional parameter to allow custom node types and checks for the necessary attributes
/// \todo: create a new skinCluster if we want a kSkinClusterFilter and this isn't one
throw IECore::Exception( ( boost::format( "ToMayaSkinClusterConverter: \"%s\" is not a valid skinCluster" ) % fnSkinClusterNode.name() ).str() );
}
const unsigned origNumInfluences = influenceNames.size();
unsigned numInfluences = origNumInfluences;
std::vector<bool> ignoreInfluence( origNumInfluences, false );
std::vector<int> indexMap( origNumInfluences, -1 );
const bool ignoreMissingInfluences = m_ignoreMissingInfluencesParameter->getTypedValue();
const bool ignoreBindPose = m_ignoreBindPoseParameter->getTypedValue();
// gather the influence objects
MObject mObj;
MDagPath path;
MSelectionList influenceList;
MDagPathArray influencePaths;
for ( unsigned i=0, index=0; i < origNumInfluences; i++ )
{
MString influenceName( influenceNames[i].c_str() );
s = influenceList.add( influenceName );
if ( !s )
{
if ( ignoreMissingInfluences )
{
ignoreInfluence[i] = true;
MGlobal::displayWarning( MString( "ToMayaSkinClusterConverter: \"" + influenceName + "\" is not a valid influence" ) );
continue;
}
throw IECore::Exception( ( boost::format( "ToMayaSkinClusterConverter: \"%s\" is not a valid influence" ) % influenceName ).str() );
}
influenceList.getDependNode( index, mObj );
MFnIkJoint fnInfluence( mObj, &s );
if ( !s )
{
if ( ignoreMissingInfluences )
{
ignoreInfluence[i] = true;
influenceList.remove( index );
MGlobal::displayWarning( MString( "ToMayaSkinClusterConverter: \"" + influenceName + "\" is not a valid influence" ) );
continue;
}
throw IECore::Exception( ( boost::format( "ToMayaSkinClusterConverter: \"%s\" is not a valid influence" ) % influenceName ).str() );
}
fnInfluence.getPath( path );
influencePaths.append( path );
indexMap[i] = index;
index++;
}
MPlugArray connectedPlugs;
bool existingBindPose = true;
MPlug bindPlug = fnSkinClusterNode.findPlug( "bindPose", true, &s );
if ( !bindPlug.connectedTo( connectedPlugs, true, false ) )
{
existingBindPose = false;
if ( !ignoreBindPose )
{
throw IECore::Exception( ( boost::format( "ToMayaSkinClusterConverter: \"%s\" does not have a valid bindPose" ) % fnSkinClusterNode.name() ).str() );
}
}
MPlug bindPoseMatrixArrayPlug;
MPlug bindPoseMemberArrayPlug;
if ( existingBindPose )
{
MFnDependencyNode fnBindPose( connectedPlugs[0].node() );
if ( fnBindPose.typeName() != "dagPose" )
{
throw IECore::Exception( ( boost::format( "ToMayaSkinClusterConverter: \"%s\" is not a valid bindPose" ) % fnBindPose.name() ).str() );
}
bindPoseMatrixArrayPlug = fnBindPose.findPlug( "worldMatrix", true, &s );
bindPoseMemberArrayPlug = fnBindPose.findPlug( "members", true, &s );
}
/// \todo: optional parameter to reset the skinCluster's geomMatrix plug
// break existing influence connections to the skinCluster
MDGModifier dgModifier;
MMatrixArray ignoredPreMatrices;
MPlug matrixArrayPlug = fnSkinClusterNode.findPlug( "matrix", true, &s );
MPlug bindPreMatrixArrayPlug = fnSkinClusterNode.findPlug( "bindPreMatrix", true, &s );
for ( unsigned i=0; i < matrixArrayPlug.numConnectedElements(); i++ )
{
MPlug matrixPlug = matrixArrayPlug.connectionByPhysicalIndex( i, &s );
matrixPlug.connectedTo( connectedPlugs, true, false );
if ( !connectedPlugs.length() )
{
continue;
}
MFnIkJoint fnInfluence( connectedPlugs[0].node() );
fnInfluence.getPath( path );
if ( ignoreMissingInfluences && !influenceList.hasItem( path ) )
{
MPlug preMatrixPlug = bindPreMatrixArrayPlug.elementByLogicalIndex( i );
preMatrixPlug.getValue( mObj );
MFnMatrixData matFn( mObj );
ignoredPreMatrices.append( matFn.matrix() );
ignoreInfluence.push_back( false );
indexMap.push_back( influenceList.length() );
influenceList.add( connectedPlugs[0].node() );
numInfluences++;
}
dgModifier.disconnect( connectedPlugs[0], matrixPlug );
}
MPlug lockArrayPlug = fnSkinClusterNode.findPlug( "lockWeights", true, &s );
for ( unsigned i=0; i < lockArrayPlug.numConnectedElements(); i++ )
{
MPlug lockPlug = lockArrayPlug.connectionByPhysicalIndex( i, &s );
lockPlug.connectedTo( connectedPlugs, true, false );
if ( connectedPlugs.length() )
{
dgModifier.disconnect( connectedPlugs[0], lockPlug );
}
}
MPlug paintPlug = fnSkinClusterNode.findPlug( "paintTrans", true, &s );
paintPlug.connectedTo( connectedPlugs, true, false );
if ( connectedPlugs.length() )
{
dgModifier.disconnect( connectedPlugs[0], paintPlug );
}
// break existing influence connections to the bind pose
if ( existingBindPose )
{
for ( unsigned i=0; i < bindPoseMatrixArrayPlug.numConnectedElements(); i++ )
{
MPlug matrixPlug = bindPoseMatrixArrayPlug.connectionByPhysicalIndex( i, &s );
matrixPlug.connectedTo( connectedPlugs, true, false );
if ( connectedPlugs.length() )
{
dgModifier.disconnect( connectedPlugs[0], matrixPlug );
}
}
for ( unsigned i=0; i < bindPoseMemberArrayPlug.numConnectedElements(); i++ )
{
MPlug memberPlug = bindPoseMemberArrayPlug.connectionByPhysicalIndex( i, &s );
memberPlug.connectedTo( connectedPlugs, true, false );
if ( connectedPlugs.length() )
{
dgModifier.disconnect( connectedPlugs[0], memberPlug );
}
}
}
if ( !dgModifier.doIt() )
{
dgModifier.undoIt();
throw IECore::Exception( "ToMayaSkinClusterConverter: Unable to break the influence connections" );
}
// make connections from influences to skinCluster and bindPose
for ( unsigned i=0; i < numInfluences; i++ )
{
if ( ignoreInfluence[i] )
{
continue;
}
int index = indexMap[i];
s = influenceList.getDependNode( index, mObj );
MFnIkJoint fnInfluence( mObj, &s );
MPlug influenceMatrixPlug = fnInfluence.findPlug( "worldMatrix", true, &s ).elementByLogicalIndex( 0, &s );
MPlug influenceMessagePlug = fnInfluence.findPlug( "message", true, &s );
MPlug influenceBindPosePlug = fnInfluence.findPlug( "bindPose", true, &s );
MPlug influenceLockPlug = fnInfluence.findPlug( "lockInfluenceWeights", true, &s );
if ( !s )
{
// add the lockInfluenceWeights attribute if it doesn't exist
MFnNumericAttribute nAttr;
MObject attribute = nAttr.create( "lockInfluenceWeights", "liw", MFnNumericData::kBoolean, false );
fnInfluence.addAttribute( attribute );
influenceLockPlug = fnInfluence.findPlug( "lockInfluenceWeights", true, &s );
}
// connect influence to the skinCluster
MPlug matrixPlug = matrixArrayPlug.elementByLogicalIndex( index );
MPlug lockPlug = lockArrayPlug.elementByLogicalIndex( index );
dgModifier.connect( influenceMatrixPlug, matrixPlug );
dgModifier.connect( influenceLockPlug, lockPlug );
// connect influence to the bindPose
if ( !ignoreBindPose )
{
MPlug bindPoseMatrixPlug = bindPoseMatrixArrayPlug.elementByLogicalIndex( index );
MPlug memberPlug = bindPoseMemberArrayPlug.elementByLogicalIndex( index );
dgModifier.connect( influenceMessagePlug, bindPoseMatrixPlug );
dgModifier.connect( influenceBindPosePlug, memberPlug );
}
}
unsigned firstIndex = find( ignoreInfluence.begin(), ignoreInfluence.end(), false ) - ignoreInfluence.begin();
influenceList.getDependNode( firstIndex, mObj );
MFnDependencyNode fnInfluence( mObj );
MPlug influenceMessagePlug = fnInfluence.findPlug( "message", true, &s );
dgModifier.connect( influenceMessagePlug, paintPlug );
if ( !dgModifier.doIt() )
{
dgModifier.undoIt();
throw IECore::Exception( "ToMayaSkinClusterConverter: Unable to create the influence connections" );
}
// use influencePoseData as bindPreMatrix
for ( unsigned i=0; i < numInfluences; i++ )
{
if ( ignoreInfluence[i] )
{
continue;
}
MMatrix preMatrix = ( i < origNumInfluences ) ? IECore::convert<MMatrix>( influencePoseData[i] ) : ignoredPreMatrices[i-origNumInfluences];
MPlug preMatrixPlug = bindPreMatrixArrayPlug.elementByLogicalIndex( indexMap[i], &s );
s = preMatrixPlug.getValue( mObj );
if ( s )
{
MFnMatrixData matFn( mObj );
matFn.set( preMatrix );
mObj = matFn.object();
}
else
{
MFnMatrixData matFn;
mObj = matFn.create( preMatrix );
}
preMatrixPlug.setValue( mObj );
}
// remove unneeded bindPreMatrix children
unsigned existingElements = bindPreMatrixArrayPlug.numElements();
for ( unsigned i=influenceList.length(); i < existingElements; i++ )
{
MPlug preMatrixPlug = bindPreMatrixArrayPlug.elementByLogicalIndex( i, &s );
/// \todo: surely there is a way to accomplish this in c++...
MGlobal::executeCommand( ( boost::format( "removeMultiInstance %s" ) % preMatrixPlug.name() ).str().c_str() );
}
// get the geometry
MObjectArray outputGeoObjs;
if ( !fnSkinCluster.getOutputGeometry( outputGeoObjs ) )
{
throw IECore::Exception( ( boost::format( "ToMayaSkinClusterConverter: skinCluster \"%s\" does not have any output geometry!" ) % fnSkinCluster.name() ).str() );
}
MFnDagNode dagFn( outputGeoObjs[0] );
MDagPath geoPath;
dagFn.getPath( geoPath );
// loop through all the points of the geometry and set the weights
MItGeometry geoIt( outputGeoObjs[0] );
MPlug weightListArrayPlug = fnSkinClusterNode.findPlug( "weightList", true, &s );
for ( unsigned pIndex=0; !geoIt.isDone(); geoIt.next(), pIndex++ )
{
MPlug pointWeightsPlug = weightListArrayPlug.elementByLogicalIndex( pIndex, &s ).child( 0 );
// remove existing influence weight plugs
MIntArray existingInfluenceIndices;
pointWeightsPlug.getExistingArrayAttributeIndices( existingInfluenceIndices );
for( unsigned i=0; i < existingInfluenceIndices.length(); i++ )
{
MPlug influenceWeightPlug = pointWeightsPlug.elementByLogicalIndex( existingInfluenceIndices[i], &s );
MGlobal::executeCommand( ( boost::format( "removeMultiInstance -break 1 %s" ) % influenceWeightPlug.name() ).str().c_str() );
}
// add new influence weight plugs
int firstIndex = pointIndexOffsets[pIndex];
for( int i=0; i < pointInfluenceCounts[pIndex]; i++ )
{
int influenceIndex = pointInfluenceIndices[ firstIndex + i ];
if ( ignoreInfluence[ influenceIndex ] )
{
continue;
}
int skinClusterInfluenceIndex = fnSkinCluster.indexForInfluenceObject( influencePaths[ indexMap[ influenceIndex ] ] );
MPlug influenceWeightPlug = pointWeightsPlug.elementByLogicalIndex( skinClusterInfluenceIndex, &s );
influenceWeightPlug.setValue( pointInfluenceWeights[ firstIndex + i ] );
}
}
return true;
}
//---------------------------------------------------
bool DagHelper::setPlugValue ( MPlug& plug, bool value )
{
MStatus status;
status = plug.setValue ( value );
return status == MStatus::kSuccess;
}
bool DagHelper::setPlugValue ( MPlug& plug, const String& value )
{
MStatus status;
status = plug.setValue ( MString ( value.c_str() ) );
return status == MStatus::kSuccess;
}
// --------------------------------------------------------------------------------------------
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;
}
MStatus customAttrCmd::action( int flag )
//
// Description
// Do the actual work here to move the objects by the
// command's delta value. The objects will come from those
// on the active selection list.
//
{
MStatus stat;
double d = delta;
switch( flag )
{
case UNDOIT: // undo
d = -d;
break;
case REDOIT: // redo
break;
case DOIT: // do command
break;
default:
break;
}
// Create a selection list iterator
//
MSelectionList slist;
MGlobal::getActiveSelectionList( slist );
MItSelectionList iter( slist, MFn::kInvalid, &stat );
if ( MS::kSuccess == stat ) {
MDagPath mdagPath; // Item dag path
MObject mComponent; // Current component
// Processs all selected objects
//
for ( ; !iter.isDone(); iter.next() )
{
// Get path and possibly a component
//
iter.getDagPath( mdagPath, mComponent );
MFnTransform transFn( mdagPath, &stat );
if ( MS::kSuccess == stat ) {
// If the selected object is of type rockingTransform,
// then set the appropriate plug value depending on which axes
// the command is operating on.
if (transFn.typeId() == rockingTransformNode::id)
{
MPlug plg = transFn.findPlug(customAttributeString);
double val;
plg.getValue(val);
plg.setValue(val+d);
}
continue;
}
} // for
}
else {
cerr << "Error creating selection list iterator" << endl;
}
return MS::kSuccess;
}
bool ToMayaLocatorConverter::doConversion( IECore::ConstObjectPtr from, MObject &to, IECore::ConstCompoundObjectPtr operands ) const
{
ConstCoordinateSystemPtr coordSys = IECore::runTimeCast<const CoordinateSystem>( from );
if ( !coordSys )
{
IECore::msg( IECore::Msg::Warning, "ToMayaLocatorConverter::doConversion", "The source object is not an IECore::CoordinateSystem." );
return false;
}
// check if incoming object is a locator itself
MObject locatorObj;
if ( to.hasFn( MFn::kLocator ) )
{
locatorObj = to;
}
// check if incoming object is a parent of an existing locator
if ( locatorObj.isNull() )
{
MFnDagNode fnTo( to );
for ( unsigned i=0; i < fnTo.childCount(); ++i )
{
MObject child = fnTo.child( i );
if ( child.hasFn( MFn::kLocator ) )
{
locatorObj = child;
break;
}
}
}
// make a new locator and parent it to the incoming object
if ( locatorObj.isNull() )
{
if ( !MFnTransform().hasObj( to ) )
{
IECore::msg( IECore::Msg::Warning, "ToMayaLocatorConverter::doConversion", "Unable to create a locator as a child of the input object." );
return false;
}
MDagModifier dagMod;
locatorObj = dagMod.createNode( "locator", to );
dagMod.renameNode( locatorObj, coordSys->getName().c_str() );
if ( !dagMod.doIt() )
{
IECore::msg( IECore::Msg::Warning, "ToMayaLocatorConverter::doConversion", "Unable to modify the DAG correctly." );
dagMod.undoIt();
return false;
}
}
if ( locatorObj.isNull() )
{
IECore::msg( IECore::Msg::Warning, "ToMayaLocatorConverter::doConversion", "Unable to find or create a locator from the input object." );
return false;
}
MFnDagNode fnLocator( locatorObj );
Imath::M44f m = coordSys->getTransform()->transform();
Imath::V3f s,h,r,t;
Imath::extractSHRT(m, s, h, r, t);
/// obtain local position and scale from locator
MStatus st;
MPlug positionPlug = fnLocator.findPlug( "localPositionX", &st );
if ( !st ) return false;
positionPlug.setValue(t[0]);
positionPlug = fnLocator.findPlug( "localPositionY", &st );
if ( !st ) return false;
positionPlug.setValue(t[1]);
positionPlug = fnLocator.findPlug( "localPositionZ", &st );
if ( !st ) return false;
positionPlug.setValue(t[2]);
MPlug scalePlug = fnLocator.findPlug( "localScaleX", &st );
if ( !st ) return false;
scalePlug.setValue(s[0]);
scalePlug = fnLocator.findPlug( "localScaleY", &st );
if ( !st ) return false;
scalePlug.setValue(s[1]);
scalePlug = fnLocator.findPlug( "localScaleZ", &st );
if ( !st ) return false;
scalePlug.setValue(s[2]);
return true;
}
//
// Deform computation
//
MStatus jhMeshBlur::deform( MDataBlock& block,MItGeometry& iter,const MMatrix& m,unsigned int multiIndex)
{
MStatus returnStatus;
// Envelope
float envData = block.inputValue(envelope, &returnStatus).asFloat();
CHECK_MSTATUS(returnStatus);
if(envData == 0)
return MS::kFailure;
/*
VARIABLES
*/
//float factor = block.inputValue(aShapeFactor, &returnStatus).asFloat();
float fStrength = block.inputValue(aStrength, &returnStatus).asFloat();
CHECK_MSTATUS(returnStatus);
if (fStrength == 0)
return MS::kFailure;
float fThreshold = block.inputValue(aTreshhold, &returnStatus).asFloat();
CHECK_MSTATUS(returnStatus);
float fW = 0.0f; // weight
float fDistance;
fStrength *= envData;
double dKracht = block.inputValue(aInterpPower, &returnStatus).asDouble();
CHECK_MSTATUS(returnStatus);
double dDotProduct; // Dotproduct of the point
bool bTweakblur = block.inputValue(aTweakBlur, &returnStatus).asBool();
CHECK_MSTATUS(returnStatus);
bool bQuad = block.inputValue(aQuadInterp, &returnStatus).asBool();
CHECK_MSTATUS(returnStatus);
MTime inTime = block.inputValue(aTime).asTime();
int nTijd = (int)inTime.as(MTime::kFilm);
MFloatVectorArray currentNormals; // normals of mesh
MFnPointArrayData fnPoints; // help converting to MPointArrays
MFloatVector dirVector; // direction vector of the point
MFloatVector normal; // normal of the point
MPointArray savedPoints; // save all point before edited
MMatrix matInv = m.inverse(); // inversed matrix
MPoint ptA; // current point (iter mesh)
MPoint ptB; // previous point (iter mesh)
MPoint ptC; // mesh before previous point (iter mesh)
// get node, use node to get inputGeom, use inputGeom to get mesh data, use mesh data to get normal data
MFnDependencyNode nodeFn(this->thisMObject());
MPlug inGeomPlug(nodeFn.findPlug(this->inputGeom,true));
MObject inputObject(inGeomPlug.asMObject());
MFnMesh inMesh(inputObject);
inMesh.getVertexNormals(true, currentNormals);
// get the previous mesh data
MPlug oldMeshPlug = nodeFn.findPlug(MString("oldMesh"));
MPlug oldMeshPositionsAPlug = oldMeshPlug.elementByLogicalIndex((multiIndex*4) + 0);
MPlug oldMeshPositionsBPlug = oldMeshPlug.elementByLogicalIndex((multiIndex*4) + 1);
MPlug oldMeshPositionsCPlug = oldMeshPlug.elementByLogicalIndex((multiIndex*4) + 2); // cache for tweak mode
MPlug oldMeshPositionsDPlug = oldMeshPlug.elementByLogicalIndex((multiIndex*4) + 3); // cache for tweak mode
// convert to MPointArrays
MObject objOldMeshA;
MObject objOldMeshB;
MObject objOldMeshC; // cache
MObject objOldMeshD; // cache
oldMeshPositionsAPlug.getValue(objOldMeshA);
oldMeshPositionsBPlug.getValue(objOldMeshB);
oldMeshPositionsCPlug.getValue(objOldMeshC); // cache
oldMeshPositionsDPlug.getValue(objOldMeshD); // cache
fnPoints.setObject(objOldMeshA);
MPointArray oldMeshPositionsA = fnPoints.array();
fnPoints.setObject(objOldMeshB);
MPointArray oldMeshPositionsB = fnPoints.array();
fnPoints.setObject(objOldMeshC);
MPointArray oldMeshPositionsC = fnPoints.array(); // cache
fnPoints.setObject(objOldMeshD);
MPointArray oldMeshPositionsD = fnPoints.array(); // cache
// If mesh position variables are empty,fill them with default values
if(oldMeshPositionsA.length() == 0 || nTijd <= 1){
iter.allPositions(oldMeshPositionsA);
for(int i=0; i < oldMeshPositionsA.length(); i++)
{
// convert to world
oldMeshPositionsA[i] = oldMeshPositionsA[i] * m;
}
oldMeshPositionsB.copy(oldMeshPositionsA);
oldMeshPositionsC.copy(oldMeshPositionsA); // cache
oldMeshPositionsD.copy(oldMeshPositionsA); // cache
}
// get back old date again
if (bTweakblur == true) { // restore cache
oldMeshPositionsA.copy(oldMeshPositionsC);
oldMeshPositionsB.copy(oldMeshPositionsD);
}
iter.allPositions(savedPoints);
for(int i=0; i < savedPoints.length(); i++)
{
// convert points to world points
savedPoints[i] = savedPoints[i] * m;
}
// Actual Iteration through points
for (; !iter.isDone(); iter.next()){
// get current position
ptA = iter.position();
// get old positions
ptB = oldMeshPositionsA[iter.index()] * matInv;
ptC = oldMeshPositionsB[iter.index()] * matInv;
fDistance = ptA.distanceTo(ptB);
fW = weightValue(block,multiIndex,iter.index());
if (fDistance * (fStrength*fW) < fThreshold && fThreshold > 0){
iter.setPosition(ptA);
} else {
// aim/direction vector to calculate strength
dirVector = (ptA - ptB); // (per punt)
dirVector.normalize();
normal = currentNormals[iter.index()];
dDotProduct = normal.x * dirVector.x + normal.y * dirVector.y + normal.z * dirVector.z;
if(bQuad == true){
MVector vecA(((ptB - ptC) + (ptA - ptB)) / 2);
vecA.normalize();
MPoint hiddenPt(ptB + (vecA * fDistance) * dKracht);
ptA = quadInterpBetween(ptB, hiddenPt, ptA, (1 - fStrength * fW) + (linearInterp(dDotProduct, -1, 1) * (fStrength * fW) ) );
} else {
MPoint halfway = (ptA - ptB) * 0.5;
MPoint offset = halfway * dDotProduct * (fStrength*fW);
ptA = ptA - ((halfway * (fStrength*fW)) - offset); // + (offset * strength);
}
// set new value
iter.setPosition(ptA);
}
}
if(bTweakblur == false){
oldMeshPositionsD.copy(oldMeshPositionsB);
oldMeshPositionsC.copy(oldMeshPositionsA);
oldMeshPositionsB.copy(oldMeshPositionsA);
oldMeshPositionsA.copy(savedPoints);
// Save back to plugs
objOldMeshA = fnPoints.create(oldMeshPositionsA);
objOldMeshB = fnPoints.create(oldMeshPositionsB);
objOldMeshC = fnPoints.create(oldMeshPositionsC);
objOldMeshD = fnPoints.create(oldMeshPositionsD);
oldMeshPositionsAPlug.setValue(objOldMeshA);
oldMeshPositionsBPlug.setValue(objOldMeshB);
oldMeshPositionsCPlug.setValue(objOldMeshC);
oldMeshPositionsDPlug.setValue(objOldMeshD);
}
return returnStatus;
}
bool ToMayaMeshConverter::setMeshInterpolationAttribute( MObject &object, std::string interpolation )
{
MStatus st;
MFnMesh fnMesh(object, &st);
if ( !st )
{
return false;
}
int interpolationValue = 0;
FromMayaMeshConverter fromMaya(object);
const IECore::Parameter::PresetsContainer &presets = fromMaya.interpolationParameter()->presets();
IECore::Parameter::PresetsContainer::const_iterator it;
if ( interpolation != "default" )
{
int index = 0;
for ( it = presets.begin(); it != presets.end(); it++, index++ )
{
if ( interpolation == it->first || interpolation == IECore::staticPointerCast< IECore::StringData >(it->second)->readable() )
{
interpolationValue = index;
break;
}
}
if ( it == presets.end() )
{
return false;
}
}
MPlug interpPlug = fnMesh.findPlug( "ieMeshInterpolation", &st );
if ( !st )
{
MFnEnumAttribute fnAttrib;
MObject newAttr = fnAttrib.create( "ieMeshInterpolation", "interp", 0, &st );
if ( !st )
{
return false;
}
int index = 0;
for ( it = presets.begin(); it != presets.end(); it++ )
{
if ( it->first == "default" )
{
continue;
}
fnAttrib.addField( it->first.c_str(), index );
index++;
}
// looks like the attribute does not exist yet..
st = fnMesh.addAttribute( newAttr );
if ( !st )
{
return false;
}
interpPlug = fnMesh.findPlug( "ieMeshInterpolation", &st );
if ( !st )
{
return false;
}
}
st = interpPlug.setValue( interpolationValue );
if ( !st )
{
return false;
}
return true;
}
