//--------------------------------------------------- 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; }