public static MDagPath CreateJoint(string jtName)
{
MFnIkJoint joint = new MFnIkJoint();
MObject jtObject = joint.create();
return(MDagPath.getAPathTo(jtObject));
}
public static MFnBlendShapeDeformer GetBlendShape(MObject targetObject = null)
{
if (targetObject == null)
{
targetObject = BasicFunc.GetSelectedObject(0);
}
MDagPath dag_target = MDagPath.getAPathTo(targetObject);
MFnDependencyNode node_target = new MFnDependencyNode(targetObject);
MPlug plug = node_target.findPlug("inMesh");
Debug.Log("node_target:" + node_target.name + " plug:" + plug.name);
MItDependencyGraph mit = new MItDependencyGraph(plug, MFn.Type.kBlendShape, MItDependencyGraph.Direction.kUpstream);
//MDagPath dagPath = new MDagPath();
//MItDependencyNodes mitnode = new MItDependencyNodes(MFn.Type.kBlendShape);
while (!mit.isDone)
{
MObject mo = mit.currentItem();
MFnDependencyNode dnode = new MFnDependencyNode(mo);
Debug.Log("moing:" + dnode.absoluteName);
if (mo.hasFn(MFn.Type.kBlendShape))
{
Debug.Log("find blendshape");
return(new MFnBlendShapeDeformer(mo));
}
mit.next();
}
return(null);
}
/// <summary>
/// Get for each vertex the weights for all influence objects, including zero weights.
/// </summary>
/// <param name="vertexWeights"></param>
/// <param name="influenceObjects"></param>
/// <param name="meshPath"></param>
private static void GetMeshWeightData(List <MDoubleArray> vertexWeights, MDagPathArray influenceObjects, MDagPath meshPath)
{
var fnMesh = new MFnMesh(meshPath);
// Get any attached skin cluster
var hasSkinCluster = false;
// Search the skin cluster affecting this geometry
var kDepNodeIt = new MItDependencyNodes(MFn.Type.kSkinClusterFilter);
// Go through each skin cluster in the scene until we find the one connected to this mesh
while (!kDepNodeIt.isDone && !hasSkinCluster)
{
MGlobal.displayInfo("Processing skin cluster...");
var kObject = kDepNodeIt.thisNode;
var kSkinClusterFn = new MFnSkinCluster(kObject);
var uiNumGeometries = kSkinClusterFn.numOutputConnections;
kSkinClusterFn.influenceObjects(influenceObjects);
MGlobal.displayInfo("\t uiNumGeometries : " + uiNumGeometries);
MGlobal.displayInfo("\t influenceOBjects number : " + influenceObjects.Count);
// Go through each connection on the skin cluster until we get the one connecting to this mesh
MGlobal.displayInfo("Mesh we are looking for : " + fnMesh.fullPathName);
for (uint uiGeometry = 0; uiGeometry < uiNumGeometries && !hasSkinCluster; uiGeometry++)
{
var uiIndex = kSkinClusterFn.indexForOutputConnection(uiGeometry);
var kInputObject = kSkinClusterFn.inputShapeAtIndex(uiIndex);
var kOutputObject = kSkinClusterFn.outputShapeAtIndex(uiIndex);
if (!kOutputObject.hasFn(MFn.Type.kMesh))
{
continue;
}
var fnOutput = new MFnMesh(MDagPath.getAPathTo(kOutputObject));
MGlobal.displayInfo("Output object : " + fnOutput.fullPathName);
if (fnOutput.fullPathName != fnMesh.fullPathName)
{
continue;
}
hasSkinCluster = true;
MGlobal.displayInfo("\t==> A connected skin cluster has been found.");
// Go through each vertex (== each component) and save the weights for each one
var kGeometryIt = new MItGeometry(kInputObject);
while (!kGeometryIt.isDone)
{
var kComponent = kGeometryIt.currentItem;
var kWeightArray = new MDoubleArray();
uint uiNumInfluences = 0;
kSkinClusterFn.getWeights(meshPath, kComponent, kWeightArray, ref uiNumInfluences);
vertexWeights.Add(kWeightArray);
kGeometryIt.next();
}
}
kDepNodeIt.next();
}
}
public static bool SetJointLimit(MObject mobject, JointType jointType)
{
if (mobject.hasFn(MFn.Type.kTransform))
{
return(SetJointLimit(new MFnTransform(MDagPath.getAPathTo(mobject)), jointType));
}
else
{
return(false);
}
}
public static MDagPath AddChildCircle(MObject targetObject)
{
if (targetObject.hasFn(MFn.Type.kTransform))
{
return(AddChildCircle(MDagPath.getAPathTo(targetObject)));
}
else
{
return(null);
}
}
public static MDagPath DuplicateMesh(MDagPath targetDag)
{
if (targetDag == null)
{
return(null);
}
MFnMesh newMesh = new MFnMesh();
targetDag.extendToShape();
return(MDagPath.getAPathTo(newMesh.copy(targetDag.node)));
}
public static MDagPath AddParentCircle(MObject targetObject, bool createParallelGrp)
{
if (targetObject.hasFn(MFn.Type.kTransform))
{
return(AddParentCircle(MDagPath.getAPathTo(targetObject), createParallelGrp));
}
else
{
return(null);
}
}
public static void BeautifulPole(MDagPath middleDag = null, bool clearFlag_x = true, bool clearFlag_y = true, bool clearFlag_z = true, bool useMoveSkinJointsTool = true)
{
if (middleDag == null || middleDag.node.isNull)
{
middleDag = BasicFunc.GetSelectedDagPath(0);
if (middleDag == null || middleDag.node.isNull)
{
Debug.Log("please select middle joint");
return;
}
}
MFnTransform middleTrans = new MFnTransform(middleDag);
if (middleTrans.parentCount == 0 || middleTrans.childCount == 0)
{
return;
}
MDagPath parentDag = MDagPath.getAPathTo(middleTrans.parent(0));
MDagPath childDag = MDagPath.getAPathTo(middleTrans.child(0));
MFnTransform parentTrans = new MFnTransform(parentDag);
MFnTransform childTrans = new MFnTransform(childDag);
MVector parentWorldPos = parentTrans.getTranslation(MSpace.Space.kWorld);
MVector middleWorldPos = middleTrans.getTranslation(MSpace.Space.kWorld);
MVector childWorldPos = childTrans.getTranslation(MSpace.Space.kWorld);
//MVector vec_middleToParent = parentWorldPos - middleWorldPos;
//MVector vec_childToMiddle = middleWorldPos - childWorldPos;
//MVector verticalBack = BasicFunc.Cross(vec_middleToParent, vec_childToMiddle);
float length0 = (float)(middleWorldPos - parentWorldPos).length;
float length1 = (float)(middleWorldPos - childWorldPos).length;
MVector posByWeight = BasicFunc.Lerp(parentWorldPos, childWorldPos, length0 / (length0 + length1));
if (useMoveSkinJointsTool)
{
MoveSkinJointsTool(middleDag);
}
//middleTrans.setTranslation(posByWeight, MSpace.Space.kWorld);
if (!clearFlag_x)
{
posByWeight.x = middleWorldPos.x;
}
if (!clearFlag_y)
{
posByWeight.y = middleWorldPos.y;
}
if (!clearFlag_z)
{
posByWeight.z = middleWorldPos.z;
}
middleTrans.setTranslation(posByWeight, MSpace.Space.kWorld);
childTrans.setTranslation(childWorldPos, MSpace.Space.kWorld);
//MFnIkJoint middleJoint = new MFnIkJoint(middleDag);
}
public static MDagPath CurveToHair(ref MDagPath hairSystemDagPath, MDagPath curveDagPath = null, ConstantValue.HairPointLockType pointLock = ConstantValue.HairPointLockType.Base)
{
if (curveDagPath == null)
{
curveDagPath = BasicFunc.GetSelectedDagPath(0);
}
bool hairSystemReady = !hairSystemDagPath.node.isNull;
MSelectionList targetList = new MSelectionList();
targetList.add(curveDagPath);
if (hairSystemReady)
{
Debug.Log("hair system ready");
targetList.add(hairSystemDagPath);
}
else
{
Debug.Log("hair system need to be created!");
}
BasicFunc.Select(targetList);
string cmdStr = "cmds.MakeCurvesDynamic(0,0,0,1,0)";
string resultStr = MGlobal.executePythonCommandStringResult(cmdStr);
MDagPath result = new MDagPath();
//Debug.Log(curveDagPath.fullPathName);
MFnTransform curveTrans = new MFnTransform(curveDagPath);
if (curveTrans.parentCount > 0)
{
MDagPath follicleDagPath = MDagPath.getAPathTo(curveTrans.parent(0));
MGlobal.executeCommand(string.Format("setAttr {0}.pointLock {1}", follicleDagPath.fullPathName, (int)pointLock));
if (follicleDagPath.hasFn(MFn.Type.kFollicle))
{
Debug.Log("follicle exist!");
ConvertHairSelection(HairSelectionType.OutputCurves, follicleDagPath);
result = BasicFunc.GetSelectedDagPath(0);
new MFnDependencyNode(result.node).setName("dy_" + curveDagPath.partialPathName);
if (!hairSystemReady)
{
ConvertHairSelection(HairSelectionType.HairSystem);
hairSystemDagPath = BasicFunc.GetSelectedDagPath(0);
hairSystemReady = true;
}
}
}
return(result);
}
private static void AddChildrenToList(List <MDagPath> dagList, MFnTransform rootTrans, MFn.Type filterType = MFn.Type.kInvalid)
{
if (filterType == MFn.Type.kInvalid || rootTrans.dagPath.hasFn(filterType))
{
dagList.Add(rootTrans.dagPath);
}
if (rootTrans.childCount > 0)
{
for (int i = 0; i < rootTrans.childCount; i++)
{
MObject mo = rootTrans.child((uint)i);
MDagPath dag = MDagPath.getAPathTo(mo);
AddChildrenToList(dagList, new MFnTransform(dag), filterType);
}
}
}
// Node added to model callback.
private static void userNodeAddedCB(object sender, MNodeFunctionArgs args)
{
MObject node = args.node;
if (!node.isNull)
{
MDagPath path = new MDagPath();
try
{
MDagPath.getAPathTo(node, path);
string info = "DAG Model - Node added: ";
info += path.fullPathName;
try
{
MObject obj = path.transform;
}
catch (ArgumentException)
{
info += "(WORLD)";
}
catch (Exception)
{
}
MGlobal.displayInfo(info);
}
catch (System.Exception)
{
MGlobal.displayInfo("Error: failed to get dag path to node.");
}
}
// remove the callback
node.NodeAddedToModel -= userNodeAddedCB;
// listen for removal message
try
{
node.NodeRemovedFromModel += userNodeRemovedCB;
}
catch (System.Exception)
{
MGlobal.displayError("Failed to install node removed from model callback.\n");
}
}
public static MDagPath CreateCurve(MPointArray points, string curveName, int degree = 1, MFnNurbsCurve.Form form = MFnNurbsCurve.Form.kOpen)
{
MDoubleArray indices = new MDoubleArray();
for (int i = 0; i < points.Count; i++)
{
indices.Add(i);
}
MFnNurbsCurve nc = new MFnNurbsCurve();
MObject curveObject = nc.create(points, indices, (uint)degree, form, false, false);
MDagPath curveDagPath = MDagPath.getAPathTo(curveObject);
MFnDependencyNode dn = new MFnDependencyNode(curveObject);
dn.setName(curveName);
return(curveDagPath);
}
public static MDagPath AddRPIKPole(MDagPath middleDagPath = null)
{
if (middleDagPath == null)
{
middleDagPath = BasicFunc.GetSelectedDagPath(0);
if (middleDagPath == null)
{
Debug.Log("please select middle joint");
return(null);
}
}
MDagPath rootDagPath = new MDagPath(), endDagPath = new MDagPath();
MFnIkJoint middleJoint = new MFnIkJoint(middleDagPath);
if (middleJoint.parentCount > 0)
{
MDagPath.getAPathTo(middleJoint.parent(0), rootDagPath);
MFnIkJoint rootJoint = new MFnIkJoint(rootDagPath);
if (middleJoint.childCount > 0)
{
MDagPath.getAPathTo(middleJoint.child(0), endDagPath);
MFnIkJoint endJoint = new MFnIkJoint(endDagPath);
MVector rootPos = rootJoint.getTranslation(MSpace.Space.kWorld);
MVector middlePos = middleJoint.getTranslation(MSpace.Space.kWorld);
MVector endPos = endJoint.getTranslation(MSpace.Space.kWorld);
//double len0 = (middlePos - rootPos).length;
//double len1 = (endPos - middlePos).length;
MVector fitLinePos = (rootPos + endPos) * 0.5;
MVector direct_pole = middlePos - fitLinePos;
MVector direct_fitLine = rootPos - endPos;
MVector direct_projectPolePos = BasicFunc.VerticalProject(direct_pole, direct_fitLine).normal;
//MVector nmPos = (rootPos * len0 + endPos * len1) * (1 / (len0 + len1));
float factor = (float)((rootPos - endPos).length / 3);
MVector polePos = factor * direct_projectPolePos + middlePos;
string locName = "loc_" + rootJoint.name + "_" + endJoint.name;
return(BasicFunc.CreateLocator(polePos, locName));
}
}
return(null);
}
public static bool BindFinger(MDagPath rootJointDagPath, string fingerTag, bool useIK = false)
{
MFnIkJoint rootJoint = new MFnIkJoint(rootJointDagPath);
if (rootJoint.childCount > 0)
{
MObject middleJointObject = rootJoint.child(0);
MDagPath middleJointDagPath = MDagPath.getAPathTo(middleJointObject);
MFnIkJoint middleJoint = new MFnIkJoint(middleJointObject);
if (middleJoint.childCount > 0)
{
MObject finalJointObject = middleJoint.child(0);
MDagPath finalJointDagPath = MDagPath.getAPathTo(finalJointObject);
//MFnIkJoint finalJoint(finalJointObject);
//enough, start control
return(BindFinger(rootJointDagPath, middleJointDagPath, finalJointDagPath, fingerTag, useIK));
}
}
return(true);
}
public static List <MFnTransform> GetHierachyChainTrans(MDagPath startDag, MFn.Type filterType = MFn.Type.kInvalid, MDagPath endDag = null)
{
MFnTransform currentTrans = new MFnTransform(startDag);
//no need for trans data , so mfntransform(mobject) is used
List <MFnTransform> result = new List <MFnTransform>();
result.Add(currentTrans);
while (currentTrans.childCount > 0)
{
MObject filteredMO = new MObject();
if (filterType != MFn.Type.kInvalid)
{
bool filterOK = false;
for (int i = 0; i < currentTrans.childCount; i++)
{
filteredMO = currentTrans.child((uint)i);
if (filteredMO.hasFn(filterType))
{
filterOK = true;
break;
}
}
if (!filterOK)
{
break;
}
}
else
{
filteredMO = currentTrans.child(0);
}
MDagPath dag = MDagPath.getAPathTo(filteredMO);
currentTrans = new MFnTransform(dag);
result.Add(currentTrans);
if (endDag != null && dag.fullPathName == endDag.fullPathName)
{
break;
}
}
return(result);
}
public static MDagPath[] BindIKControl(MDagPath rootDagPath, MDagPath endDagPath, JointProcess.IKSolverType iKSolverType = JointProcess.IKSolverType.RotatePlane, MDagPath ctlDagPath = null)
{
MFnTransform endTrans = new MFnTransform(endDagPath);
MDagPath middleDagPath = MDagPath.getAPathTo(endTrans.parent(0));
if (ctlDagPath == null)
{
ctlDagPath = BasicFunc.AddChildCircle(endDagPath);
BasicFunc.UnparentTransform(ctlDagPath);
BasicFunc.FreezeTransform(new MFnTransform(ctlDagPath));
}
//string resultStr = MGlobal.executeCommandStringResult("ikHandle -sj " + rootObject.fullPathName() + " -ee " + endObject.fullPathName() + " -sol ikRPsolver -n ik_" + rootObject.partialPathName() + "_" + endObject.partialPathName(),true);
//string resultStr = MGlobal.executePythonCommandStringResult("cmds.ikHandle(sj='" + rootDagPath.fullPathName + "',ee='" + endDagPath.fullPathName + "',sol='ikRPsolver',n='ik_" + rootDagPath.partialPathName + "_" + endDagPath.partialPathName + "')");
//[u'ik_joint1_joint4', u'effector1']
string[] resultArr = JointProcess.AddIKHandle(rootDagPath, endDagPath, iKSolverType, ctlDagPath.fullPathName);
MGlobal.executeCommandStringResult("pointConstraint " + ctlDagPath.fullPathName + " " + resultArr[0]);
if (iKSolverType == JointProcess.IKSolverType.RotatePlane)
{
MDagPath locDagPath = AddRPIKPole(middleDagPath);
if (locDagPath != null)
{
BasicFunc.FreezeTransform(new MFnTransform(locDagPath));
//begin to add constriant
BasicFunc.AddConstraint(locDagPath.fullPathName, resultArr[0], ConstantValue.ConstraintType.PoleVector);
//string poleConstraintResult = MGlobal.executeCommandStringResult("poleVectorConstraint " + locDagPath.fullPathName + " " + resultArr[0]);
//Debug.Log(poleConstraintResult);
return(new MDagPath[3] {
BasicFunc.GetDagPathByName(resultArr[0]), ctlDagPath, locDagPath
});
}
}
return(new MDagPath[2] {
BasicFunc.GetDagPathByName(resultArr[0]), ctlDagPath
});
}
public static List <MDagPath> AddBonesCTL(MSelectionList jointList = null, MFnTransform parentTrans = null)
{
if (jointList == null)
{
jointList = BasicFunc.GetSelectedList();
}
if (parentTrans == null)
{
parentTrans = new MFnTransform(BasicFunc.CreateEmptyGroup("grp_bonesCTL"));
}
if (jointList.length == 0)
{
return(null);
}
List <MDagPath> jointDags = new List <MDagPath>();
for (int i = 0; i < jointList.length; i++)
{
MDagPath dag = new MDagPath();
jointList.getDagPath((uint)i, dag);
jointDags.Add(dag);
}
int count = jointDags.Count;
MFnTransform[] jointTrans = new MFnTransform[count];
MFnTransform[] jointParentTrans = new MFnTransform[count];
for (int i = 0; i < jointDags.Count; i++)
{
jointTrans[i] = new MFnTransform(jointDags[i]);
jointParentTrans[i] = new MFnTransform(MDagPath.getAPathTo(jointTrans[i].parent(0)));
}
MVector[] jointWorldPositions = new MVector[jointDags.Count];
MVector centerPos = MVector.zero;
for (int i = 0; i < count; i++)
{
jointWorldPositions[i] = jointTrans[i].getTranslation(MSpace.Space.kWorld);
centerPos += jointWorldPositions[i];
}
centerPos = centerPos * (1.0f / count);
double[] minDist_y = new double[count];
double[] minDist_x = new double[count];
if (count > 1)
{
for (int i = 0; i < count; i++)
{
double closestY = double.MaxValue, closestX = double.MaxValue;
//int minDistIndex = 0;
for (int j = 0; j < count; j++)
{
if (i == j)
{
continue;
}
MVector direct = jointWorldPositions[i] - jointWorldPositions[j];
direct.x = Math.Abs(direct.x);
direct.y = Math.Abs(direct.y);
if (direct.x >= direct.y)
{
if (direct.x < closestX)
{
closestX = direct.x;
//minDistIndex = j;
}
}
if (direct.y >= direct.x)
{
if (direct.y < closestY)
{
closestY = direct.y;
}
}
}
minDist_y[i] = closestY;
minDist_x[i] = closestX;
}
}
else
{
minDist_x[0] = 1;
minDist_y[0] = 1;
}
List <MDagPath> curves = new List <MDagPath>();
for (int i = 0; i < count; i++)
{
float width = (float)minDist_x[i] / 2, height = (float)minDist_y[i] / 2;
MDagPath curve = BasicFunc.CreateCTL_Square("ctl_" + jointDags[i].partialPathName, height, width);
MFnTransform curveTrans = new MFnTransform(curve);
BasicFunc.SetTransformParent(curveTrans, parentTrans);
curveTrans.setTranslation(jointWorldPositions[i] - centerPos, MSpace.Space.kTransform);
BasicFunc.FreezeTransform(curveTrans);
BasicFunc.SetTranslateLimit(curveTrans, -width / 2, -height / 2, 0, width / 2, height / 2, 0);
MPlug plug_curveTX = curveTrans.findPlug(ConstantValue.plugName_tx);
MPlug plug_curveTY = curveTrans.findPlug(ConstantValue.plugName_ty);
MPlug plug_jointRY = jointParentTrans[i].findPlug(ConstantValue.plugName_ry);
MPlug plug_jointRZ = jointParentTrans[i].findPlug(ConstantValue.plugName_rz);
BindAttr.ProjectPlug(plug_curveTX, plug_jointRY, -width / 2, width / 2, -45, 45);
BindAttr.ProjectPlug(plug_curveTY, plug_jointRZ, -height / 2, height / 2, -45, 45);
curves.Add(curve);
}
return(curves);
}
private void doSimpleSolver()
//
// Solve single joint in the x-y plane
//
// - first it calculates the angle between the handle and the end-effector.
// - then it determines which way to rotate the joint.
//
{
// Get the handle and create a function set for it
//
MIkHandleGroup handle_group = handleGroup;
if (null == handle_group)
{
throw new System.InvalidOperationException("invalid handle group.");
}
MObject handle = handle_group.handle(0);
MDagPath handlePath = MDagPath.getAPathTo(handle);
MFnIkHandle fnHandle = new MFnIkHandle(handlePath);
// Get the position of the end_effector
//
MDagPath end_effector = new MDagPath();
fnHandle.getEffector(end_effector);
MFnTransform tran = new MFnTransform(end_effector);
MPoint effector_position = tran.rotatePivot(MSpace.Space.kWorld);
// Get the position of the handle
//
MPoint handle_position = fnHandle.rotatePivot(MSpace.Space.kWorld);
// Get the start joint position
//
MDagPath start_joint = new MDagPath();
fnHandle.getStartJoint(start_joint);
MFnTransform start_transform = new MFnTransform(start_joint);
MPoint start_position = start_transform.rotatePivot(MSpace.Space.kWorld);
// Calculate the rotation angle
//
MVector v1 = start_position.minus(effector_position);
MVector v2 = start_position.minus(handle_position);
double angle = v1.angle(v2);
// -------- Figure out which way to rotate --------
//
// define two vectors U and V as follows
// U = EndEffector(E) - StartJoint(S)
// N = Normal to U passing through EndEffector
//
// Clip handle_position to half-plane U to determine the region it
// lies in. Use the region to determine the rotation direction.
//
// U
// ^ Region Rotation
// | B
// (E)---N A C-C-W
// A | B C-W
// | B
// |
// (S)
//
double rot = 0.0; // Rotation about Z-axis
// U and N define a half-plane to clip the handle against
//
MVector U = effector_position.minus(start_position);
U.normalize();
// Get a normal to U
//
MVector zAxis = new MVector(0.0, 0.0, 1.0);
MVector N = U.crossProduct(zAxis); // Cross product
N.normalize();
// P is the handle position vector
//
MVector P = handle_position.minus(effector_position);
// Determine the rotation direction
//
double PdotN = P[0] * N[0] + P[1] * N[1];
if (PdotN < 0)
{
// counter-clockwise
rot = angle;
}
else
{
// clockwise
rot = -1.0 * angle;
}
// get and set the Joint Angles
//
MDoubleArray jointAngles = new MDoubleArray();
getJointAngles(jointAngles);
jointAngles.set(jointAngles[0] + rot, 0);
setJointAngles(jointAngles);
}
public override void doSolve()
{
MIkHandleGroup handle_group = handleGroup;
if (handle_group == null)
{
throw new InvalidOperationException("Invalid handle group");
}
MObject handle = handle_group.handle(0);
MDagPath handlePath = MDagPath.getAPathTo(handle);
MFnIkHandle handleFn = new MFnIkHandle(handlePath);
//Effector
//
MDagPath effectorPath = new MDagPath();
handleFn.getEffector(effectorPath);
MFnIkEffector effectorFn = new MFnIkEffector(effectorPath);
effectorPath.pop();
MFnIkJoint midJoinFn = new MFnIkJoint(effectorPath);
// Start Joint
//
MDagPath startJointPath = new MDagPath();
handleFn.getStartJoint(startJointPath);
MFnIkJoint startJointFn = new MFnIkJoint(startJointPath);
// Preferred angles
//
double [] startJointPrefAngle = new double[3];
double[] midJointPrefAngle = new double[3];
startJointFn.getPreferedAngle(startJointPrefAngle);
midJoinFn.getPreferedAngle(midJointPrefAngle);
// Set to preferred angles
//
startJointFn.setRotation(startJointPrefAngle, startJointFn.rotationOrder);
midJoinFn.setRotation(midJointPrefAngle, midJoinFn.rotationOrder);
MPoint handlePos = handleFn.rotatePivot(MSpace.Space.kWorld);
AwPoint awHandlePos = new AwPoint(handlePos.x, handlePos.y, handlePos.z, handlePos.w);
MPoint effectorPos = effectorFn.rotatePivot(MSpace.Space.kWorld);
AwPoint awEffectorPos = new AwPoint(effectorPos.x, effectorPos.y, effectorPos.z, effectorPos.w);
MPoint midJoinPos = midJoinFn.rotatePivot(MSpace.Space.kWorld);
AwPoint awMidJoinPos = new AwPoint(midJoinPos.x, midJoinPos.y, midJoinPos.z, midJoinPos.w);
MPoint startJointPos = startJointFn.rotatePivot(MSpace.Space.kWorld);
AwPoint awStartJointPos = new AwPoint(startJointPos.x, startJointPos.y, startJointPos.z, startJointPos.w);
AwVector poleVector = poleVectorFromHandle(handlePath);
MMatrix m = handlePath.exclusiveMatrix;
AwMatrix awM = new AwMatrix();
awM.setMatrix(m);
poleVector = poleVector.mulMatrix(awM);
double twistValue = twistFromHandle(handlePath);
AwQuaternion qStart = new AwQuaternion();
AwQuaternion qMid = new AwQuaternion();
solveIK(awStartJointPos, awMidJoinPos, awEffectorPos, awHandlePos,
poleVector, twistValue, qStart, qMid);
MQuaternion mid = new MQuaternion(qMid.x, qMid.y, qMid.z, qMid.w);
MQuaternion start = new MQuaternion(qStart.x, qStart.y, qStart.z, qStart.w);
midJoinFn.rotateBy(mid, MSpace.Space.kWorld);
startJointFn.rotateBy(start, MSpace.Space.kWorld);
return;
}
public static MFnTransform GetParent(MDagPath dag, int index = 0)
{
return(new MFnTransform(MDagPath.getAPathTo(new MFnTransform(dag).parent((uint)index))));
}
/// <summary>
/// return Dynamic Output Curve
/// </summary>
/// <param name="hairSystemDagPath">exist hairsystem or container of created hairsystem</param>
/// <param name="curveList"></param>
/// <param name="pointLock">0-none, 1-base, 2-end,3-both</param>
/// <returns></returns>
public static MDagPath[] CurvesToHairs(ref MDagPath hairSystemDagPath, MSelectionList curveList = null, ConstantValue.HairPointLockType pointLock = ConstantValue.HairPointLockType.Base)
{
if (curveList == null)
{
curveList = BasicFunc.GetSelectedList();
}
bool hairSystemReady = false;
if (!hairSystemDagPath.node.isNull)
{
//Debug.Log("hairSystem node is not null:" + hairSystemDagPath.fullPathName);
curveList.add(hairSystemDagPath);
hairSystemReady = true;
}
else
{
//Debug.Log("hairsystem node is null");
}
MGlobal.setActiveSelectionList(curveList);
string cmdStr = "cmds.MakeCurvesDynamic(0,0,0,1,0)";
string resultStr = MGlobal.executePythonCommandStringResult(cmdStr);
if (hairSystemReady)
{
//Debug.Log("remove hairSystem Selection");
curveList.remove(curveList.length - 1);
}
List <MDagPath> results = new List <MDagPath>();
for (int i = 0; i < curveList.length; i++)
{
MDagPath curveDagPath = new MDagPath();
curveList.getDagPath((uint)i, curveDagPath);
//Debug.Log(curveDagPath.fullPathName);
MFnTransform curveTrans = new MFnTransform(curveDagPath);
if (curveTrans.parentCount > 0)
{
MDagPath follicleDagPath = MDagPath.getAPathTo(curveTrans.parent(0));
MGlobal.executeCommand(string.Format("setAttr {0}.pointLock {1}", follicleDagPath.fullPathName, (int)pointLock));
if (follicleDagPath.hasFn(MFn.Type.kFollicle))
{
Debug.Log("follicle exist!");
ConvertHairSelection(HairSelectionType.OutputCurves, follicleDagPath);
MDagPath result = BasicFunc.GetSelectedDagPath(0);
new MFnDependencyNode(result.node).setName("dy_" + curveDagPath.partialPathName);
results.Add(result);
if (!hairSystemReady)
{
ConvertHairSelection(HairSelectionType.HairSystem);
hairSystemDagPath = BasicFunc.GetSelectedDagPath(0);
//Debug.Log("assign hairSystem:" + hairSystemDagPath.fullPathName);
hairSystemReady = true;
}
}
}
}
//error
return(results.ToArray());
}
private static Dictionary <string, MayaM2Bone> ExtractJoints(List <MayaM2Sequence> seqList)
{
var jointMap = new Dictionary <string, MayaM2Bone>();
//Goal of iteration : Extract raw joint data and store it in intermediate object, MayaM2Bone
var processedJoints = new HashSet <string>();
for (var jointIter = new MItDag(MItDag.TraversalType.kDepthFirst, MFn.Type.kJoint); !jointIter.isDone; jointIter.next())
{
var jointPath = new MDagPath();
jointIter.getPath(jointPath);
if (processedJoints.Contains(jointPath.fullPathName))
{
continue;
}
MGlobal.displayInfo("Extracting raw data of " + jointPath.fullPathName);
var joint = new MFnIkJoint(jointPath);
var mayaBone = new MayaM2Bone();
jointMap[jointPath.fullPathName] = mayaBone;
// Hierarchy
var isRoot = joint.parentCount == 0 || !joint.parent(0).hasFn(MFn.Type.kJoint);
if (!isRoot)
{
var parentPath = new MDagPath();
MDagPath.getAPathTo(joint.parent(0), parentPath);
if (!jointMap.ContainsKey(parentPath.fullPathName))
{
MGlobal.displayError("\tParent is not referenced. Crash incoming. Path : " + parentPath.fullPathName);
}
jointMap[jointPath.fullPathName].Parent = jointMap[parentPath.fullPathName];
}
//Note : M2Bone.submesh_id is wrong in the wiki. Do not try to compute it.
// Label
jointMap[jointPath.fullPathName].Type = MGlobal.executeCommandStringResult("getAttr -asString " + joint.fullPathName + ".type");
jointMap[jointPath.fullPathName].OtherType = MGlobal.executeCommandStringResult("getAttr -asString " + joint.fullPathName + ".otherType");
jointMap[jointPath.fullPathName].Side = MGlobal.executeCommandStringResult("getAttr -asString " + joint.fullPathName + ".side");
// Base translation is used to compute position
MAnimControl.currentTime = 0;
jointMap[jointPath.fullPathName].BaseTranslation = joint.getTranslation(MSpace.Space.kTransform);
foreach (var seq in seqList)
{
var transData = new List <Tuple <uint, MVector> >();
var rotData = new List <Tuple <uint, MQuaternion> >();
var scaleData = new List <Tuple <uint, MVector> >();
for (var i = seq.Start; i < seq.End; i += 33) //TODO FIXME What if not multiple of 33 ?
{
//Get data for this joint for this frame
MAnimControl.currentTime = new MTime(i, MTime.Unit.kMilliseconds);
var translation = joint.getTranslation(MSpace.Space.kTransform);
var rotation = new MQuaternion();
joint.getRotation(rotation, MSpace.Space.kTransform);
var scaleArray = new double[3];
joint.getScale(scaleArray);
var scale = new MVector(scaleArray);
if (!translation.isEquivalent(MVector.zero, Epsilon))
{
var previousIsTheSame = transData.Count > 0 &&
transData.Last().Item2.isEquivalent(translation, Epsilon);
if (!previousIsTheSame)
{
transData.Add(new Tuple <uint, MVector>((uint)(i - seq.Start), translation));
}
}
if (!rotation.isEquivalent(MQuaternion.identity, Epsilon))
{
var previousIsTheSame = rotData.Count > 0 &&
rotData.Last().Item2.isEquivalent(rotation, Epsilon);
if (!previousIsTheSame)
{
rotData.Add(new Tuple <uint, MQuaternion>((uint)(i - seq.Start), rotation));
}
}
if (!scale.isEquivalent(MVector.one, Epsilon))
{
var previousIsTheSame = scaleData.Count > 0 &&
scaleData.Last().Item2.isEquivalent(scale, Epsilon);
if (!previousIsTheSame)
{
scaleData.Add(new Tuple <uint, MVector>((uint)(i - seq.Start), scale));
}
}
}
if (transData.Count > 0)
{
jointMap[joint.fullPathName].Translation.Add(transData);
}
if (rotData.Count > 0)
{
jointMap[joint.fullPathName].Rotation.Add(rotData);
}
if (scaleData.Count > 0)
{
jointMap[joint.fullPathName].Scale.Add(scaleData);
}
}
processedJoints.Add(jointPath.fullPathName);
}
//Goal of iteration : apply transformations to joint data & their children
processedJoints.Clear();
for (var jointIter = new MItDag(MItDag.TraversalType.kBreadthFirst, MFn.Type.kJoint);
!jointIter.isDone;
jointIter.next())
{
var jointPath = new MDagPath();
jointIter.getPath(jointPath);
if (processedJoints.Contains(jointPath.fullPathName))
{
continue;
}
MGlobal.displayInfo("Applying joint orient of " + jointPath.fullPathName);
var joint = new MFnIkJoint(jointPath);
var jointOrient = new MQuaternion();
joint.getOrientation(jointOrient);
for (uint i = 0; i < joint.childCount; i++)
{
if (!joint.child(i).hasFn(MFn.Type.kJoint))
{
continue;
}
var childFn = new MFnIkJoint(joint.child(i));
MGlobal.displayInfo("\tto " + childFn.fullPathName + ";");
jointMap[childFn.fullPathName].RotateTranslation(jointOrient);
}
processedJoints.Add(jointPath.fullPathName);
}
return(jointMap);
}
public static MFnIkJoint[] AddReverseFootBone(MDagPath rootDagPath, MDagPath middleDagPath, MDagPath endDagPath)
{
//啊啊
//*reverseBones = new MDagPath[8];
MFnIkJoint[] result = new MFnIkJoint[8];
MFnIkJoint rootJoint = new MFnIkJoint();
MVector rootPos = new MFnTransform(rootDagPath).getTranslation(MSpace.Space.kWorld);
MVector middlePos = new MFnTransform(middleDagPath).getTranslation(MSpace.Space.kWorld);
MVector endPos = new MFnTransform(endDagPath).getTranslation(MSpace.Space.kWorld);
//Debug.Log("root:" + BasicFunc.ToCMDSParamStr(rootPos) + " middle:" + BasicFunc.ToCMDSParamStr(middlePos) + " end:" + BasicFunc.ToCMDSParamStr(endPos));
MObject jt_ankle_Object = rootJoint.create();
result[0] = new MFnIkJoint(MDagPath.getAPathTo(jt_ankle_Object));
result[0].setTranslation(rootPos, MSpace.Space.kWorld);
MObject jt_heel_Object = rootJoint.create(jt_ankle_Object);
result[1] = new MFnIkJoint(MDagPath.getAPathTo(jt_heel_Object));
result[1].setTranslation(new MVector(rootPos.x, endPos.y, rootPos.z), MSpace.Space.kWorld);
MObject jt_side_Object = rootJoint.create(jt_heel_Object);
result[2] = new MFnIkJoint(MDagPath.getAPathTo(jt_side_Object));
MVector footDirect = endPos - middlePos;
MVector middleGround = new MVector(middlePos.x, endPos.y, middlePos.z);
MVector offset = BasicFunc.Cross(footDirect, new MVector(0, 0.6, 0));
offset *= Math.Sign(BasicFunc.Dot(middleGround, offset));
//float sideFactor = (float)(0.6 * (middlePos - endPos).length / Math.Abs(middlePos.z));
result[2].setTranslation(middleGround + offset, MSpace.Space.kWorld);
MObject jt_front_Object = rootJoint.create(jt_side_Object);
result[3] = new MFnIkJoint(MDagPath.getAPathTo(jt_front_Object));
result[3].setTranslation(endPos, MSpace.Space.kWorld);
MObject jt_middleF_Object = rootJoint.create(jt_front_Object);
result[4] = new MFnIkJoint(MDagPath.getAPathTo(jt_middleF_Object));
result[4].setTranslation(middlePos, MSpace.Space.kWorld);
MObject jt_middleB_Object = rootJoint.create(jt_front_Object);
result[5] = new MFnIkJoint(MDagPath.getAPathTo(jt_middleB_Object));
result[5].setTranslation(middlePos, MSpace.Space.kWorld);
MObject jt_toe_Object = rootJoint.create(jt_middleF_Object);
result[6] = new MFnIkJoint(MDagPath.getAPathTo(jt_toe_Object));
result[6].setTranslation(endPos, MSpace.Space.kWorld);
MObject jt_ankleIn_Object = rootJoint.create(jt_middleB_Object);
result[7] = new MFnIkJoint(MDagPath.getAPathTo(jt_ankleIn_Object));
result[7].setTranslation(rootPos, MSpace.Space.kWorld);
Debug.Log("create joints ok");
return(result);
}