MStatus InstanceCallbackCmd::doIt( const MArgList& args )
{
MStatus status = MS::kSuccess;
// Draw a circle and get its dagPath
// using an iterator
MGlobal::executeCommand("circle");
MFnNurbsCurve circle;
MDagPath dagPath;
MItDependencyNodes iter( MFn::kNurbsCurve , &status);
for(iter.reset(); !iter.isDone() ; iter.next())
{
MObject item = iter.item();
if(item.hasFn(MFn::kNurbsCurve))
{
circle.setObject(item);
circle.getPath(dagPath);
MGlobal::displayInfo("DAG_PATH is " + dagPath.fullPathName());
if(dagPath.isValid())
{
// register callback for instance add AND remove
//
MDagMessage::addInstanceAddedCallback ( dagPath,addCallbackFunc, NULL, &status);
MDagMessage::addInstanceRemovedCallback ( dagPath,remCallbackFunc, NULL, &status);
MGlobal::displayInfo("CALLBACK ADDED FOR INSTANCE ADD/REMOVE");
}
}
}
if (status != MS::kSuccess)
{
MGlobal::displayInfo("STATUS RETURNED IS NOT SUCCESS");
}
return status;
}
MStatus Posts1Cmd::doIt ( const MArgList & )
{
const int nPosts = 5;
const double radius = 0.5;
const double height = 5.0;
// Get a list of currently selected objects
MSelectionList selection;
MGlobal::getActiveSelectionList( selection );
MDagPath dagPath;
MFnNurbsCurve curveFn;
double heightRatio = height / radius;
// Iterate over the nurbs curves
MItSelectionList iter( selection, MFn::kNurbsCurve );
for ( ; !iter.isDone(); iter.next() )
{
// Get the curve and attach it to the function set
iter.getDagPath( dagPath );
curveFn.setObject( dagPath );
// Get the domain of the curve, i.e. its start and end parametric values
double tStart, tEnd;
curveFn.getKnotDomain( tStart, tEnd );
MPoint pt;
int i;
double t;
double tIncr = (tEnd - tStart) / (nPosts - 1);
for( i=0, t=tStart; i < nPosts; i++, t += tIncr )
{
// Get point along curve at parametric position t
curveFn.getPointAtParam( t, pt, MSpace::kWorld );
pt.y += 0.5 * height;
MGlobal::executeCommand( MString( "cylinder -pivot ") + pt.x + " " + pt.y + " " + pt.z
+ " -radius " + radius + " -axis 0 1 0 -heightRatio " + heightRatio );
}
}
return MS::kSuccess;
}
void MayaNurbsCurveWriter::write()
{
Alembic::AbcGeom::OCurvesSchema::Sample samp;
samp.setBasis(Alembic::AbcGeom::kBsplineBasis);
MStatus stat;
mCVCount = 0;
// if inheritTransform is on and the curve group is animated,
// bake the cv positions in the world space
MMatrix exclusiveMatrixInv = mRootDagPath.exclusiveMatrixInverse(&stat);
std::size_t numCurves = 1;
if (mIsCurveGrp)
numCurves = mNurbsCurves.length();
std::vector<Alembic::Util::int32_t> nVertices(numCurves);
std::vector<float> points;
std::vector<float> width;
std::vector<float> knots;
std::vector<Alembic::Util::uint8_t> orders(numCurves);
MMatrix transformMatrix;
bool useConstWidth = false;
MFnDependencyNode dep(mRootDagPath.transform());
MPlug constWidthPlug = dep.findPlug("width");
if (!constWidthPlug.isNull())
{
useConstWidth = true;
width.push_back(constWidthPlug.asFloat());
}
for (unsigned int i = 0; i < numCurves; i++)
{
MFnNurbsCurve curve;
if (mIsCurveGrp)
{
curve.setObject(mNurbsCurves[i]);
MMatrix inclusiveMatrix = mNurbsCurves[i].inclusiveMatrix(&stat);
transformMatrix = inclusiveMatrix*exclusiveMatrixInv;
}
else
{
curve.setObject(mRootDagPath.node());
}
if (i == 0)
{
if (curve.form() == MFnNurbsCurve::kOpen)
{
samp.setWrap(Alembic::AbcGeom::kNonPeriodic);
}
else
{
samp.setWrap(Alembic::AbcGeom::kPeriodic);
}
if (curve.degree() == 3)
{
samp.setType(Alembic::AbcGeom::kCubic);
}
else if (curve.degree() == 1)
{
samp.setType(Alembic::AbcGeom::kLinear);
}
else
{
samp.setType(Alembic::AbcGeom::kVariableOrder);
}
}
else
{
if (curve.form() == MFnNurbsCurve::kOpen)
{
samp.setWrap(Alembic::AbcGeom::kNonPeriodic);
}
if ((samp.getType() == Alembic::AbcGeom::kCubic &&
curve.degree() != 3) ||
(samp.getType() == Alembic::AbcGeom::kLinear &&
curve.degree() != 1))
{
samp.setType(Alembic::AbcGeom::kVariableOrder);
}
}
orders[i] = static_cast<Alembic::Util::uint8_t>(curve.degree() + 1);
Alembic::Util::int32_t numCVs = curve.numCVs(&stat);
MPointArray cvArray;
stat = curve.getCVs(cvArray, MSpace::kObject);
mCVCount += numCVs;
nVertices[i] = numCVs;
for (Alembic::Util::int32_t j = 0; j < numCVs; j++)
{
MPoint transformdPt;
if (mIsCurveGrp)
{
transformdPt = cvArray[j]*transformMatrix;
}
else
{
transformdPt = cvArray[j];
}
points.push_back(static_cast<float>(transformdPt.x));
points.push_back(static_cast<float>(transformdPt.y));
points.push_back(static_cast<float>(transformdPt.z));
}
MDoubleArray knotsArray;
curve.getKnots(knotsArray);
knots.reserve(knotsArray.length() + 2);
// need to add a knot to the start and end (M + 2N + 1)
if (knotsArray.length() > 1)
{
unsigned int knotsLength = knotsArray.length();
if (knotsArray[0] == knotsArray[knotsLength - 1] ||
knotsArray[0] == knotsArray[1])
{
knots.push_back(knotsArray[0]);
}
else
{
knots.push_back(2 * knotsArray[0] - knotsArray[1]);
}
for (unsigned int j = 0; j < knotsLength; ++j)
{
knots.push_back(knotsArray[j]);
}
if (knotsArray[0] == knotsArray[knotsLength - 1] ||
knotsArray[knotsLength - 1] == knotsArray[knotsLength - 2])
{
knots.push_back(knotsArray[knotsLength - 1]);
}
else
{
knots.push_back(2 * knotsArray[knotsLength - 1] -
knotsArray[knotsLength - 2]);
}
}
// width
MPlug widthPlug = curve.findPlug("width");
if (!useConstWidth && !widthPlug.isNull())
{
MObject widthObj;
MStatus status = widthPlug.getValue(widthObj);
MFnDoubleArrayData fnDoubleArrayData(widthObj, &status);
MDoubleArray doubleArrayData = fnDoubleArrayData.array();
Alembic::Util::int32_t arraySum = doubleArrayData.length();
if (arraySum == numCVs)
{
for (Alembic::Util::int32_t i = 0; i < arraySum; i++)
{
width.push_back(static_cast<float>(doubleArrayData[i]));
}
}
else if (status == MS::kSuccess)
{
MString msg = "Curve ";
msg += curve.partialPathName();
msg += " has incorrect size for the width vector.";
msg += "\nUsing default constant width of 0.1.";
MGlobal::displayWarning(msg);
width.clear();
width.push_back(0.1f);
useConstWidth = true;
}
else
{
width.push_back(widthPlug.asFloat());
useConstWidth = true;
}
}
else if (!useConstWidth)
{
// pick a default value
width.clear();
width.push_back(0.1f);
useConstWidth = true;
}
}
Alembic::AbcGeom::GeometryScope scope = Alembic::AbcGeom::kVertexScope;
if (useConstWidth)
scope = Alembic::AbcGeom::kConstantScope;
samp.setCurvesNumVertices(Alembic::Abc::Int32ArraySample(nVertices));
samp.setPositions(Alembic::Abc::V3fArraySample(
(const Imath::V3f *)&points.front(), points.size() / 3 ));
samp.setWidths(Alembic::AbcGeom::OFloatGeomParam::Sample(
Alembic::Abc::FloatArraySample(width), scope) );
if (samp.getType() == Alembic::AbcGeom::kVariableOrder)
{
samp.setOrders(Alembic::Abc::UcharArraySample(orders));
}
if (!knots.empty())
{
samp.setKnots(Alembic::Abc::FloatArraySample(knots));
}
mSchema.set(samp);
}
MStatus splineSolverNode::preSolve()
{
MStatus stat;
setRotatePlane(false);
setSingleChainOnly(true);
setPositionOnly(false);
//Get Handle
MIkHandleGroup * handle_group = handleGroup();
if (NULL == handle_group) {
return MS::kFailure;
}
MObject handle = handle_group->handle( 0 );
MDagPath handlePath = MDagPath::getAPathTo( handle );
fnHandle.setObject( handlePath );
//Get Curve
MPlug inCurvePlug = fnHandle.findPlug( "inCurve" );
MDataHandle curveHandle = inCurvePlug.asMDataHandle();
MObject inputCurveObject = curveHandle.asNurbsCurveTransformed();
curveFn.setObject( inputCurveObject );
float initCurveLength = curveFn.length();
MVector initNormal = curveFn.normal(0);
MVector initTangent = curveFn.tangent(0);
float stretchRatio = 1;
// Get the position of the end_effector
//
MDagPath effectorPath;
fnHandle.getEffector(effectorPath);
tran.setObject( effectorPath );
// Get the start joint position
//
MDagPath startJointPath;
fnHandle.getStartJoint( startJointPath );
joints.clear();
//Get Joints
while (true)
{
effectorPath.pop();
joints.push_back( effectorPath );
if (effectorPath == startJointPath)
break;
}
std::reverse(joints.begin(), joints.end());
if (!fnHandle.hasAttribute("str"))
{
//Add Custom Attributes to Handle
MFnNumericAttribute fnAttr;
MObject attr = fnAttr.create("stretchRatio", "str", MFnNumericData::kDouble, stretchRatio);
fnAttr.setKeyable(1);
fnAttr.setWritable(1);
fnAttr.setMin(0);
fnAttr.setMax(1);
fnAttr.setHidden(0);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("anchorPosition", "ancp", MFnNumericData::kDouble, 0.0);
fnAttr.setKeyable(1);
fnAttr.setWritable(1);
fnAttr.setMin(0);
fnAttr.setMax(1);
fnAttr.setHidden(0);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("curveLength", "cvLen", MFnNumericData::kDouble, initCurveLength);
fnAttr.setKeyable(0);
fnAttr.setWritable(1);
fnAttr.setHidden(1);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("initNormal", "norm", MFnNumericData::k3Double);
fnAttr.setDefault(initNormal.x, initNormal.y, initNormal.z);
fnAttr.setKeyable(0);
fnAttr.setWritable(1);
fnAttr.setHidden(1);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("initTangent", "tang", MFnNumericData::k3Double);
fnAttr.setDefault(initTangent.x, initTangent.y, initTangent.z);
fnAttr.setKeyable(0);
fnAttr.setWritable(1);
fnAttr.setHidden(1);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("jointsLength", "jsLen", MFnNumericData::kDouble, getJointsTotalLenght());
fnAttr.setKeyable(0);
fnAttr.setWritable(1);
fnAttr.setHidden(1);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("startTwist", "strtw", MFnNumericData::kDouble, 0.0);
fnAttr.setKeyable(1);
fnAttr.setWritable(1);
fnAttr.setHidden(0);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
attr = fnAttr.create("endTwist", "endtw", MFnNumericData::kDouble, 0.0);
fnAttr.setKeyable(1);
fnAttr.setWritable(1);
fnAttr.setHidden(0);
fnAttr.setStorable(1);
fnAttr.setReadable(1);
fnHandle.addAttribute(attr, MFnDependencyNode::kLocalDynamicAttr);
MObject twistRamp = MRampAttribute::createCurveRamp("twistRamp", "twr");
fnHandle.addAttribute(twistRamp, MFnDependencyNode::kLocalDynamicAttr);
MObject scaleRamp = MRampAttribute::createCurveRamp("scaleRamp", "scr");
fnHandle.addAttribute(scaleRamp, MFnDependencyNode::kLocalDynamicAttr);
} else
{
MPlug strPlug = fnHandle.findPlug("str");
stretchRatio = strPlug.asDouble();
}
return MS::kSuccess;
}
