MStatus GetAdjacency(MDagPath& pathMesh, std::vector<std::set<int> >& adjacency) {
MStatus status;
// Get mesh adjacency. The adjacency will be all vertex ids on the connected faces.
MItMeshVertex itVert(pathMesh, MObject::kNullObj, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
MFnMesh fnMesh(pathMesh, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
adjacency.resize(itVert.count());
for (; !itVert.isDone(); itVert.next()) {
MIntArray faces;
status = itVert.getConnectedFaces(faces);
CHECK_MSTATUS_AND_RETURN_IT(status);
adjacency[itVert.index()].clear();
// Put the vertex ids in a set to avoid duplicates
for (unsigned int j = 0; j < faces.length(); ++j) {
MIntArray vertices;
fnMesh.getPolygonVertices(faces[j], vertices);
for (unsigned int k = 0; k < vertices.length(); ++k) {
if (vertices[k] != itVert.index()) {
adjacency[itVert.index()].insert(vertices[k]);
}
}
}
}
return MS::kSuccess;
}
MStatus initializePlugin(MObject obj)
{
MStatus status;
MFnPlugin plugin(obj, PLUGIN_VENDOR, PLUGIN_VERSION, "Any", &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
status = plugin.registerData(ASSET_METADATA__TYPENAME,
AssetMetadataMPx::id,
AssetMetadataMPx::creator);
if (!status)
{
status.perror("registerData");
return status;
}
status = plugin.registerCommand(ASSET_METADATA__COMMAND_NAME,
AssetMetadataCmd::creator,
AssetMetadataCmd::cmdSyntax);
if (!status)
{
plugin.deregisterData(AssetMetadataMPx::id);
status.perror("registerCommand");
return status;
}
status = AssetMetadataCmd::addExtensionAttribute(obj);
CHECK_MSTATUS_AND_RETURN_IT(status);
return status;
}
MStatus GetShapeNode(MDagPath& path, bool intermediate) {
MStatus status;
if (IsShapeNode(path)) {
// Start at the transform so we can honor the intermediate flag.
path.pop();
}
if (path.hasFn(MFn::kTransform)) {
unsigned int shapeCount = path.childCount();
for (unsigned int i = 0; i < shapeCount; ++i) {
status = path.push(path.child(i));
CHECK_MSTATUS_AND_RETURN_IT(status);
if (!IsShapeNode(path)) {
path.pop();
continue;
}
MFnDagNode fnNode(path, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
if ((!fnNode.isIntermediateObject() && !intermediate) ||
(fnNode.isIntermediateObject() && intermediate)) {
return MS::kSuccess;
}
// Go to the next shape
path.pop();
}
}
// No valid shape node found.
return MS::kFailure;
}
MStatus sgCurveEditBrush_context::getShapeNode( MDagPath& path )
{
MStatus status;
if ( path.apiType() == MFn::kNurbsCurve )
{
return MS::kSuccess;
}
unsigned int numShapes;
status = path.numberOfShapesDirectlyBelow( numShapes );
CHECK_MSTATUS_AND_RETURN_IT( status );
for ( unsigned int i = 0; i < numShapes; ++i )
{
status = path.extendToShapeDirectlyBelow( i );
CHECK_MSTATUS_AND_RETURN_IT( status );
if ( !path.hasFn( MFn::kNurbsCurve ) )
{
path.pop();
continue;
}
MFnDagNode fnNode( path, &status );
CHECK_MSTATUS_AND_RETURN_IT( status );
if ( !fnNode.isIntermediateObject() )
{
return MS::kSuccess;
}
path.pop();
}
return MS::kFailure;
}
MStatus blendCurve::initialize()
{
MStatus status;
MFnNumericAttribute nAttr;
MFnTypedAttribute tAttr;
MFnCompoundAttribute cAttr;
aInputs = cAttr.create( "inputs", "inputs" );
aInputCurve = tAttr.create( "inputCurve", "inputCurve", MFnData::kNurbsCurve );
tAttr.setStorable( false );
aWeight = nAttr.create( "weight", "weight", MFnNumericData::kFloat, 1.0 );
nAttr.setMin( 0.0 );
nAttr.setMax( 1.0 );
nAttr.setKeyable( true );
aBlendPosition = nAttr.create( "blendPosition", "blendPosition", MFnNumericData::kFloat, 1.0 );
nAttr.setMin( 0.0 );
nAttr.setMax( 1.0 );
nAttr.setKeyable( true );
aBlendArea = nAttr.create( "blendArea", "blendArea", MFnNumericData::kFloat, 0.5 );
nAttr.setMin( 0.0 );
nAttr.setMax( 1.0 );
nAttr.setKeyable( true );
cAttr.addChild( aInputCurve );
cAttr.addChild( aWeight );
cAttr.addChild( aBlendPosition );
cAttr.addChild( aBlendArea );
cAttr.setArray( true );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aInputs ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aInputs, outputGeom ) );
return MS::kSuccess;
}
// The initialize method is called only once when the node is first
// registered with Maya. In general,
//
MStatus motionPathNode::initialize()
{
MFnNumericAttribute nAttr;
//====================================================================
// I N P U T A T T R I B U T E S
//====================================================================
//
offset = nAttr.create( "offset", "o",
MFnNumericData::kDouble, 4.0 );
addAttribute( offset );
wobbleRate = nAttr.create( "wobbleRate", "w",
MFnNumericData::kDouble, 10.0 );
addAttribute( wobbleRate );
//====================================================================
// A F F E C T S R E L A T I O N S H I P S
//====================================================================
//
CHECK_MSTATUS_AND_RETURN_IT( affectsOutput( offset ) );
CHECK_MSTATUS_AND_RETURN_IT( affectsOutput( wobbleRate ) );
return( MS::kSuccess );
}
MStatus TransferUV::doIt(const MArgList& args)
{
MStatus status;
// if (args.length() != 1)
// {
// MGlobal::displayError("Need 1 arg!");
// return MStatus::kFailure;
// }
MArgDatabase argData(syntax(), args);
// arg
// MString argument = args.asString(0, &status);
// if (status != MS::kSuccess) {
// return MStatus::kFailure;
// }
// CHECK_MSTATUS_AND_RETURN_IT(status);
if (argData.isFlagSet(sourceUvSetFlag)) {
status = argData.getFlagArgument(sourceUvSetFlag, 0, sourceUvSet);
CHECK_MSTATUS_AND_RETURN_IT(status);
}
if (argData.isFlagSet(targetUvSetFlag)) {
status = argData.getFlagArgument(targetUvSetFlag, 0, targetUvSet);
CHECK_MSTATUS_AND_RETURN_IT(status);
}
if (argData.isFlagSet(sourceMeshFlag)) {
status = argData.getFlagArgument(sourceMeshFlag, 0, sourceMesh);
} else {
MGlobal::displayError(
"Source mesh is not specified. -sm flag is required.");
return MS::kFailure;
}
if (argData.isFlagSet(targetMeshFlag)) {
status = argData.getFlagArgument(targetMeshFlag, 0, targetMesh);
} else {
MGlobal::displayError(
"Target mesh is not specified. -tm flag is required.");
return MS::kFailure;
}
MString info = "Copying uv from " + sourceUvSet + " to " + targetUvSet;
MGlobal::displayInfo(info);
MSelectionList mList;
mList.add(sourceMesh);
mList.add(targetMesh);
mList.getDagPath(0, sourceDagPath);
mList.getDagPath(1, targetDagPath);
return redoIt();
}
MStatus GetDagPath(MString& name, MDagPath& path) {
MStatus status;
MSelectionList list;
status = MGlobal::getSelectionListByName(name, list);
CHECK_MSTATUS_AND_RETURN_IT(status);
status = list.getDagPath(0, path);
CHECK_MSTATUS_AND_RETURN_IT(status);
return MS::kSuccess;
}
MStatus sgLockAngleMatrix::initialize()
{
MStatus status;
MFnMatrixAttribute mAttr;
MFnNumericAttribute nAttr;
MFnEnumAttribute eAttr;
aBaseMatrix = mAttr.create( "baseMatrix", "baseMatrix" );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aBaseMatrix ) );
aInputMatrix = mAttr.create( "inputMatrix", "inputMatrix" );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aInputMatrix ) );
aAngleAxis = eAttr.create( "angleAxis", "angleAxis" );
eAttr.addField( " X", 0 );eAttr.addField( " Y", 1 );eAttr.addField( " Z", 2 );
eAttr.addField( "-X", 3 );eAttr.addField( "-Y", 4 );eAttr.addField( "-Z", 5 );
eAttr.setStorable( true );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aAngleAxis ) );
aInputAngle = nAttr.create( "inputAngle", "inputAngle", MFnNumericData::kDouble, 45 );
nAttr.setStorable( true );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aInputAngle ) );
aOutputMatrix = mAttr.create( "outputMatrix", "outputMatrix" );
mAttr.setStorable( false );
CHECK_MSTATUS_AND_RETURN_IT( addAttribute( aOutputMatrix ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aBaseMatrix, aOutputMatrix ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aInputMatrix, aOutputMatrix ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aAngleAxis, aOutputMatrix ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( aInputAngle, aOutputMatrix ) );
return MS::kSuccess;
}
MStatus uninitializePlugin(MObject obj) {
MStatus status;
MFnPlugin fnPlugin(obj);
status = fnPlugin.deregisterCommand("cvJiggle");
CHECK_MSTATUS_AND_RETURN_IT(status);
status = fnPlugin.deregisterNode(cvJiggle::id);
CHECK_MSTATUS_AND_RETURN_IT(status);
return status;
}
MStatus RippleDeformer::deform(MDataBlock& dataBlock,
MItGeometry& itGeo,
const MMatrix& localToWorldMatrix,
unsigned int geomIndex)
{
MStatus status;
//get attriubtes as a datahandle
float env = dataBlock.inputValue(envelope).asFloat();
float amplitude = dataBlock.inputValue(aAmplitude).asFloat();
float displace = dataBlock.inputValue(aDisplace).asFloat();
//get the mesh
//retrieve the handle to the input attribute
MArrayDataHandle hInput = dataBlock.outputArrayValue(input, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
//get the input array index handle
status = hInput.jumpToElement(geomIndex);
//get the handle of geomIndex attribute
MDataHandle hInputElement = hInput.outputValue(&status);
//Get the MObject of the input geometry of geomindex
MObject oInputGeom = hInputElement.child(inputGeom).asMesh();
MFnMesh fnMesh(oInputGeom, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
if (oInputGeom.isNull())
{
return MS::kSuccess;
}
MFloatVectorArray normals;
fnMesh.getVertexNormals(false, normals);
MPoint pointPos;
float weight;
for (; !itGeo.isDone(); itGeo.next())
{
//get current point position
pointPos = itGeo.position();
weight = weightValue(dataBlock, geomIndex, itGeo.index());
pointPos.x = pointPos.x + sin(itGeo.index() + displace) * amplitude * normals[itGeo.index()].x * weight * env;
pointPos.y = pointPos.y + sin(itGeo.index() + displace) * amplitude * normals[itGeo.index()].y * weight * env;
pointPos.z = pointPos.z + sin(itGeo.index() + displace) * amplitude * normals[itGeo.index()].z * weight * env;
//setPosition
itGeo.setPosition(pointPos);
}
return MS::kSuccess;
}
MStatus VolumePushCollider::compute(const MPlug& plug, MDataBlock& dataBlock)
{
MStatus status;
if (plug == aOutput)
{
// inCollider
MArrayDataHandle hInCollider = dataBlock.inputArrayValue(aInCollider);
// inVolume
MArrayDataHandle hInVolume = dataBlock.inputArrayValue(aInVolume);
// output
MArrayDataHandle hOutput = dataBlock.inputArrayValue(aOutput);
MDoubleArray daValues(hInVolume.elementCount());
for (unsigned int c=0; c<hInCollider.elementCount(); c++)
{
// Calculate the total of every collider value for each volume
status = hInCollider.jumpToArrayElement(c);
CHECK_MSTATUS_AND_RETURN_IT(status);
MMatrix mInCollider = hInCollider.inputValue().asMatrix();
MTransformationMatrix tmInCollider(mInCollider);
MPoint pInCollider = tmInCollider.getTranslation(MSpace::kWorld, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
for (unsigned int v=0; v<hInVolume.elementCount(); v++)
{
// pointMatrixMult
status = hInVolume.jumpToArrayElement(v);
CHECK_MSTATUS_AND_RETURN_IT(status);
MMatrix mInVolume = hInVolume.inputValue().asMatrix();
MVector vVolCollider = pInCollider * mInVolume;
// condition
if (vVolCollider.length() <= 1.0)
{
// reverse
daValues[v] += abs(1.0 - vVolCollider.length());
}
}
}
for (unsigned int i=0; i<hInVolume.elementCount(); i++)
{
// set outputs
status = hOutput.jumpToArrayElement(i);
CHECK_MSTATUS_AND_RETURN_IT(status);
hOutput.outputValue().set(daValues[i]);
}
dataBlock.setClean(plug);
}
return MS::kSuccess;
}
MStatus initializePlugin(MObject obj) {
MStatus status;
MFnPlugin fnPlugin(obj, "Derek Williams", "1.1", "Any");
status = fnPlugin.registerNode("cvJiggle", cvJiggle::id, cvJiggle::creator,
cvJiggle::initialize, MPxNode::kDeformerNode);
CHECK_MSTATUS_AND_RETURN_IT(status);
status = fnPlugin.registerCommand("cvJiggle",
cvJiggleCmd::creator,
cvJiggleCmd::newSyntax);
CHECK_MSTATUS_AND_RETURN_IT(status);
return status;
}
MStatus initializePlugin(MObject obj)
{
MFnPlugin plugin(obj, "IS", "1.0", "Any");
MStatus status = plugin.registerCommand(COMMAND, RayTracer::creator, RayTracer::newSyntax);
CHECK_MSTATUS_AND_RETURN_IT(status);
return status;
}
MStatus uninitializePlugin(MObject obj)
{
MFnPlugin plugin(obj);
MStatus status = plugin.deregisterCommand(COMMAND);
CHECK_MSTATUS_AND_RETURN_IT(status);
return status;
}
MStatus uninitializePlugin( MObject obj)
{
MStatus status;
MFnPlugin plugin( obj );
status = plugin.deregisterNode( blendAndFixedShape::id );
CHECK_MSTATUS_AND_RETURN_IT( status );
status = plugin.deregisterNode( inverseSkinCluster::id );
CHECK_MSTATUS_AND_RETURN_IT( status );
status = plugin.deregisterCommand( "deleteBlendMeshInfo" );
CHECK_MSTATUS_AND_RETURN_IT( status );
status = plugin.deregisterCommand( "assignBlendMeshInfo" );
CHECK_MSTATUS_AND_RETURN_IT( status );
status = plugin.deregisterCommand( "addMirrorBlendMeshInfos" );
CHECK_MSTATUS_AND_RETURN_IT( status );
status = plugin.deregisterCommand( "buildSkinMesh" );
CHECK_MSTATUS_AND_RETURN_IT( status );
status = plugin.deregisterNode( vectorWeight::id );
CHECK_MSTATUS_AND_RETURN_IT( status );
/*
status = plugin.deregisterNode( angleDriver::id );
CHECK_MSTATUS_AND_RETURN_IT( status );
*/
return status;
}
MStatus initializePlugin(MObject obj) {
MStatus status;
MFnPlugin fnPlugin(obj, "Chad Vernon", "1.0", "Any");
status = fnPlugin.registerCommand(SampleCmd::kName,
SampleCmd::creator);
CHECK_MSTATUS_AND_RETURN_IT(status);
return MS::kSuccess;
}
MStatus initializePlugin(MObject mobject){
MStatus status;
MFnPlugin mfnPlugin(mobject, "Ryan Wang", "1.0","Any");
status = mfnPlugin.registerNode("jiggleDeformer", jiggleDeformer::nodeID, jiggleDeformer::nodeCreator,
jiggleDeformer::nodeInitialize,MPxNode::kDeformerNode);
CHECK_MSTATUS_AND_RETURN_IT(status);
return status;
}
MStatus uninitializePlugin(MObject mobject){
MStatus status;
MFnPlugin mfnPlugin(mobject);
status = mfnPlugin.deregisterNode(jiggleDeformer::nodeID);
CHECK_MSTATUS_AND_RETURN_IT(status);
return status;
}
// The unitializePlugin is called when Maya needs to unload the plugin.
// It does the opposite of initialize.
//
MStatus uninitializePlugin( MObject obj)
{
MStatus status;
MFnPlugin plugin( obj );
CHECK_MSTATUS_AND_RETURN_IT(plugin.deregisterNode( stringFormat::id ));
return status;
}
MStatus uninitializePlugin(MObject obj) {
MStatus status;
MFnPlugin fnPlugin(obj);
status = fnPlugin.deregisterCommand(SampleCmd::kName);
CHECK_MSTATUS_AND_RETURN_IT(status);
return MS::kSuccess;
}
MStatus DeleteIntermediateObjects(MDagPath& path) {
MStatus status;
MDagPath pathMesh(path);
while (GetShapeNode(pathMesh, true) == MS::kSuccess) {
status = MGlobal::executeCommand("delete " + pathMesh.partialPathName());
CHECK_MSTATUS_AND_RETURN_IT(status);
pathMesh = MDagPath(path);
}
return MS::kSuccess;
}
MStatus DrawPolygonContextCommand::appendSyntax()
{
MStatus status;
MSyntax mSyntax = syntax();
status = mSyntax.addFlag( LENGTH_FLAG, LENGTH_FLAG_LONG, MSyntax::kDouble );
CHECK_MSTATUS_AND_RETURN_IT( status );
return MS::kSuccess;
}
MStatus uninitializePlugin( MObject obj )
{
MStatus status;
MFnPlugin plugin( obj );
status = plugin.deregisterNode( MainNode::id );
CHECK_MSTATUS_AND_RETURN_IT( status );
status = plugin.deregisterCommand( "psdJointBase_addIndex" );
CHECK_MSTATUS_AND_RETURN_IT( status );
status = plugin.deregisterCommand( "psdJointBase_deleteIndex" );
CHECK_MSTATUS_AND_RETURN_IT( status );
status = plugin.deregisterCommand( "psdJointBase_addShape" );
CHECK_MSTATUS_AND_RETURN_IT( status );
return status;
}
MStatus sphericalBlendShapeVisualizer::initialize()
{
MStatus status;
MFnMatrixAttribute mAttr;
MFnEnumAttribute eAttr;
aSpaceMatrix = mAttr.create("spaceMatrix", "spaceMatrix", MFnMatrixAttribute::kDouble, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
aPoleAxis = eAttr.create("poleAxis", "poleAxis", 1, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
eAttr.addField("+X", 0);
eAttr.addField("+Y", 1);
eAttr.addField("+Z", 2);
eAttr.addField("-X", 3);
eAttr.addField("-Y", 4);
eAttr.addField("-Z", 5);
eAttr.setDefault(1);
eAttr.setKeyable(true);
eAttr.setStorable(true);
eAttr.setWritable(true);
aSeamAxis = eAttr.create("seamAxis", "seamAxis", 0, &status);
CHECK_MSTATUS_AND_RETURN_IT(status);
eAttr.addField("+X", 0);
eAttr.addField("+Y", 1);
eAttr.addField("+Z", 2);
eAttr.addField("-X", 3);
eAttr.addField("-Y", 4);
eAttr.addField("-Z", 5);
eAttr.setDefault(0);
eAttr.setKeyable(true);
eAttr.setStorable(true);
eAttr.setWritable(true);
addAttribute(aSpaceMatrix);
addAttribute(aPoleAxis);
addAttribute(aSeamAxis);
return MS::kSuccess;
}
MStatus motionPathNode::affectsOutput( MObject& attr )
{
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( attr, rotate ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( attr, rotateX ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( attr, rotateY ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( attr, rotateZ ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( attr, allCoordinates ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( attr, xCoordinate ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( attr, yCoordinate ) );
CHECK_MSTATUS_AND_RETURN_IT( attributeAffects( attr, zCoordinate ) );
return( MS::kSuccess );
}
MStatus uninitializePlugin( MObject obj) {
MStatus status;
MFnPlugin plugin(obj);
#if MAYA_API_VERSION >= 201600
status = MGPUDeformerRegistry::deregisterGPUDeformerCreator(CVWrap::kName, "cvWrapOverride");
CHECK_MSTATUS_AND_RETURN_IT(status);
#endif
status = plugin.deregisterCommand(CVWrapCmd::kName);
CHECK_MSTATUS_AND_RETURN_IT(status);
status = plugin.deregisterNode(CVWrap::id);
CHECK_MSTATUS_AND_RETURN_IT(status);
if (MGlobal::mayaState() == MGlobal::kInteractive) {
MGlobal::executePythonCommandOnIdle("import cvwrap.menu");
MGlobal::executePythonCommandOnIdle("cvwrap.menu.destroy_menuitems()");
}
return status;
}
MStatus
uninitializePlugin(MObject plugin)
{
//MStatus status;
MFnPlugin pluginFn(plugin);
// Deregister elements here
MStatus status = pluginFn.deregisterCommand("helix");
CHECK_MSTATUS_AND_RETURN_IT(status);
return status;
}
MStatus initializePlugin( MObject obj )
{
MStatus status;
MFnPlugin plugin( obj, "Locus", "2014", "Any");
status = plugin.registerNode( "psdJointBase", MainNode::id,
MainNode::creator, MainNode::initialize, MainNode::kDeformerNode );
CHECK_MSTATUS_AND_RETURN_IT( status );
status = plugin.registerCommand( "psdJointBase_addIndex", AddIndex::creator, AddIndex::newSyntax );
CHECK_MSTATUS_AND_RETURN_IT( status );
status = plugin.registerCommand( "psdJointBase_deleteIndex", DeleteIndex::creator, DeleteIndex::newSyntax );
CHECK_MSTATUS_AND_RETURN_IT( status );
status = plugin.registerCommand( "psdJointBase_addShape", AddShape::creator, AddShape::newSyntax );
CHECK_MSTATUS_AND_RETURN_IT( status );
return status;
}
MStatus
initializePlugin(MObject plugin)
{
//MStatus status;
MFnPlugin pluginFn(plugin, "Gary Tse", "1.0.0", "Any"); // object, author, plugin version, Maya version required
// Register elements here
MStatus status = pluginFn.registerCommand("helix", DoHelix::creator);
CHECK_MSTATUS_AND_RETURN_IT(status);
return status;
}
