protected override bool connectObjectAndConstraint(MDGModifier modifier)
{
MObject transform = transformObject();
if ( transform.isNull )
{
throw new InvalidOperationException("Failed to get transformObject()");
}
MFnTransform transformFn = new MFnTransform(transform);
MVector translate = transformFn.getTranslation(MSpace.Space.kTransform);
MPlug translatePlug = transformFn.findPlug("translate");
if (MPlug.FreeToChangeState.kFreeToChange == translatePlug.isFreeToChange())
{
MFnNumericData nd = new MFnNumericData();
MObject translateData = nd.create(MFnNumericData.Type.k3Double);
nd.setData3Double(translate.x, translate.y, translate.z);
modifier.newPlugValue(translatePlug, translateData);
connectObjectAttribute(MPxTransform.geometry, GeometrySurfaceConstraint.constraintGeometry, false);
}
connectObjectAttribute(MPxTransform.parentInverseMatrix, GeometrySurfaceConstraint.constraintParentInverseMatrix, true, true);
return true;
}
public override bool doRelease(M3dView view)
{
// Scale nodes on the selection list.
// Simple implementation that does not
// support undo.
MSelectionList list = new MSelectionList();
MGlobal.getActiveSelectionList(list);
MObject node = new MObject();
for (MItSelectionList iter = new MItSelectionList(list); !iter.isDone; iter.next())
{
iter.getDependNode(node);
MFnTransform xform;
try
{
xform = new MFnTransform(node);
}
catch (System.Exception)
{
continue;
}
double[] newScale = new double[3];
newScale[0] = mousePointGlName.x + 1;
newScale[1] = mousePointGlName.y + 1;
newScale[2] = mousePointGlName.z + 1;
xform.setScale(newScale);
}
return(true);
}
public static MDagPath AddParentCircle(MDagPath targetDagPath, bool createParallelGrp)
{
string ctlName = "ctl_" + targetDagPath.partialPathName;
MDagPath ctlDagPath = BasicFunc.CreateCircle(ctlName);
ctlName = ctlDagPath.fullPathName;
MFnTransform targetTrans = new MFnTransform(targetDagPath);
if (createParallelGrp)
{
MFnTransform parellelGrpTrans = new MFnTransform(AddEmptyGroup(new MFnTransform(targetTrans.parent(0))));
parellelGrpTrans.setTranslation(targetTrans.getTranslation(MSpace.Space.kTransform), MSpace.Space.kTransform);
//Debug.Log("finalLocalPos:"+BasicFunc.ToCMDSParamStr(parellelGrpTrans.getTranslation(MSpace.kTransform)));
MEulerRotation rot = new MEulerRotation();
targetTrans.getRotation(rot);
parellelGrpTrans.setRotation(rot);
SetTransformParent(ctlName, parellelGrpTrans.fullPathName);
}
MFnTransform circleTransform = new MFnTransform(ctlDagPath);
circleTransform.setTranslation(new MVector(0, 0, 0), MSpace.Space.kTransform);
circleTransform.setRotation(new MEulerRotation(0, 90 / ConstantValue.DPR, 0));
FreezeTransform(circleTransform);
return(ctlDagPath);
}
public static MDagPath CreateJointsCurve(MSelectionList jointDagPathList)
{
int count = (int)jointDagPathList.length;
string curveName = "curve_";
MVector[] vectors = new MVector[count];
for (int i = 0; i < count; i++)
{
MDagPath dagPath = new MDagPath();
jointDagPathList.getDagPath((uint)i, dagPath);
if (i == 0)
{
curveName += dagPath.partialPathName + "_";
}
else if (i == count - 1)
{
curveName += dagPath.partialPathName;
}
MFnTransform ptTrans = new MFnTransform(dagPath);
vectors[i] = ptTrans.getTranslation(MSpace.Space.kWorld);
//MGlobal.displayInfo(BasicFunc::ToCMDSParamStr(vectors[i]));
}
MDagPath curveDagPath = BasicFunc.CreateCurve(vectors, curveName);
//MGlobal.displayInfo("create Finish");
return(curveDagPath);
}
public static void SaveDagsHierachyNamesToFile(MFnTransform rootTrans, string filePath, bool overwrite = false)
{
string result = "";
IterateHierachy(rootTrans, 0, ref result);
//test debug
Debug.Log(result);
if (File.Exists(filePath))
{
if (!overwrite)
{
Debug.Log("文件已存在，请选择覆盖模式或者切换目标路径");
return;
}
}
else
{
string targetFolderName = Path.GetDirectoryName(filePath);
if (!Directory.Exists(targetFolderName))
{
Directory.CreateDirectory(targetFolderName);
}
}
File.WriteAllText(filePath, result);
}
public static bool SetLimit(MFnTransform mfnTrans, float rxMin, float ryMin, float rzMin, float rxMax, float ryMax, float rzMax, bool inRadian)
{
if (!inRadian)
{
rxMin /= ConstantValue.DPR;
ryMin /= ConstantValue.DPR;
rzMin /= ConstantValue.DPR;
rxMax /= ConstantValue.DPR;
ryMax /= ConstantValue.DPR;
rzMax /= ConstantValue.DPR;
}
mfnTrans.setLimit(MFnTransform.LimitType.kRotateMinX, rxMin);
mfnTrans.setLimit(MFnTransform.LimitType.kRotateMinY, ryMin);
mfnTrans.setLimit(MFnTransform.LimitType.kRotateMinZ, rzMin);
mfnTrans.setLimit(MFnTransform.LimitType.kRotateMaxX, rxMax);
mfnTrans.setLimit(MFnTransform.LimitType.kRotateMaxY, ryMax);
mfnTrans.setLimit(MFnTransform.LimitType.kRotateMaxZ, rzMax);
mfnTrans.enableLimit(MFnTransform.LimitType.kRotateMinX, true);
mfnTrans.enableLimit(MFnTransform.LimitType.kRotateMinY, true);
mfnTrans.enableLimit(MFnTransform.LimitType.kRotateMinZ, true);
mfnTrans.enableLimit(MFnTransform.LimitType.kRotateMaxX, true);
mfnTrans.enableLimit(MFnTransform.LimitType.kRotateMaxY, true);
mfnTrans.enableLimit(MFnTransform.LimitType.kRotateMaxZ, true);
return(true);
}
private void GetTransform(MFnTransform mFnTransform, ref float[] position, ref float[] rotationQuaternion, ref float[] rotation, ref BabylonVector3.EulerRotationOrder rotationOrder, ref float[] scaling)
{
var transformationMatrix = new MTransformationMatrix(mFnTransform.transformationMatrix);
var mayaRotationOrder = 0;
MGlobal.executeCommand($"getAttr {mFnTransform.fullPathName}.rotateOrder", out mayaRotationOrder);
rotationOrder = Tools.ConvertMayaRotationOrder((MEulerRotation.RotationOrder)mayaRotationOrder);
position = transformationMatrix.getTranslation();
rotationQuaternion = transformationMatrix.getRotationQuaternion();
rotation = transformationMatrix.getRotation();
scaling = transformationMatrix.getScale();
// Switch coordinate system at object level
position[2] *= -1;
rotationQuaternion[0] *= -1;
rotationQuaternion[1] *= -1;
rotation[0] *= -1;
rotation[1] *= -1;
rotationOrder = Tools.InvertRotationOrder(rotationOrder);
// Apply unit conversion factor to meter
position[0] *= scaleFactorToMeters;
position[1] *= scaleFactorToMeters;
position[2] *= scaleFactorToMeters;
}
protected override bool connectObjectAndConstraint(MDGModifier modifier)
{
MObject transform = transformObject();
if (transform.isNull)
{
throw new InvalidOperationException("Failed to get transformObject()");
}
MFnTransform transformFn = new MFnTransform(transform);
MVector translate = transformFn.getTranslation(MSpace.Space.kTransform);
MPlug translatePlug = transformFn.findPlug("translate");
if (MPlug.FreeToChangeState.kFreeToChange == translatePlug.isFreeToChange())
{
MFnNumericData nd = new MFnNumericData();
MObject translateData = nd.create(MFnNumericData.Type.k3Double);
nd.setData3Double(translate.x, translate.y, translate.z);
modifier.newPlugValue(translatePlug, translateData);
connectObjectAttribute(MPxTransform.geometry, GeometrySurfaceConstraint.constraintGeometry, false);
}
connectObjectAttribute(MPxTransform.parentInverseMatrix, GeometrySurfaceConstraint.constraintParentInverseMatrix, true, true);
return(true);
}
public static List <Curve> getSmothMeshEdges(MFnMesh mayaMesh, bool createInMaya = false)
{
//MCommandResult result = new MCommandResult();
int ne = mayaMesh.numEdges;
MFnTransform group = new MFnTransform();
List <Curve> curveObjects = new List <Curve>(ne);
MStringArray resultStr = new MStringArray();
var fullName = mayaMesh.fullPathName.Split('|');
string transformName = fullName[fullName.Length - 2];
if (createInMaya)
{
for (int i = 0; i < ne; i++)
{
using (MCommandResult result = new MCommandResult())
{
MGlobal.executeCommand(
$"polyToCurve -name {transformName}Curves -form 2 -degree 3 -conformToSmoothMeshPreview 1 {transformName}.e[{i}]",
result);
result.getResult(resultStr);
curveObjects.Add(
DMCurve.CurveFromMfnNurbsCurveFromName(resultStr[0],
MSpace.Space.kPostTransform.ToString()));
}
}
}
else
{
//Parallel.For(0, ne, i => {
for (int i = 0; i < ne; i++)
{
using (MCommandResult result = new MCommandResult())
{
MGlobal.executeCommand(
$"polyToCurve -name deleteMe11232204332AA -form 2 -degree 3 -conformToSmoothMeshPreview 1 {transformName}.e[{i}]",
result);
result.getResult(resultStr);
curveObjects.Add(
DMCurve.CurveFromMfnNurbsCurveFromName(resultStr[0],
MSpace.Space.kPostTransform.ToString()));
try
{
MGlobal.deleteNode(DMInterop.getDependNode(resultStr[0]));
}
catch
{
MGlobal.displayWarning("getSmothMeshEdges: unable to delete temp object");
}
}
}
// });
}
return(curveObjects);
}
public static void CreateRelativeCurve(MSelectionList selected = null, ConstantValue.SampleType st = ConstantValue.SampleType.ObjectTrans, bool reOrder = true, bool closedArc = true, string ctlName = null)
{
if (selected == null)
{
selected = BasicFunc.GetSelectedList();
}
List <MVector> positions = new List <MVector>();
switch (st)
{
case ConstantValue.SampleType.Vert:
{
MItSelectionList it_selectionList = new MItSelectionList(selected);
MVector totalWeight = MVector.zero;
for (; !it_selectionList.isDone; it_selectionList.next())
{
MObject component = new MObject();
MDagPath item = new MDagPath();
it_selectionList.getDagPath(item, component);
MItMeshVertex it_verts = new MItMeshVertex(item, component);
for (; !it_verts.isDone; it_verts.next())
{
//Debug.Log(it_verts.index().ToString());
MPoint point = it_verts.position(MSpace.Space.kWorld);
MVector pos = new MVector(point.x, point.y, point.z);
//BasicFunc.CreateLocator(pos, "vert_" + it_verts.index());
positions.Add(pos);
totalWeight += pos;
}
}
break;
}
case ConstantValue.SampleType.Edge:
{
break;
}
case ConstantValue.SampleType.Poly:
{
break;
}
case ConstantValue.SampleType.ObjectTrans:
{
foreach (MDagPath dag in selected.DagPaths())
{
MFnTransform trans = new MFnTransform(dag);
positions.Add(trans.getTranslation(MSpace.Space.kWorld));
}
break;
}
}
if (ctlName == null)
{
ctlName = "samplerCurve_00";
}
CreateLoopCircleByPos(positions, reOrder, closedArc, ctlName);
}
public Dictionary <string, object> ExportCustomAttributeFromTransform(MFnTransform mfnTransform)
{
var baseObject = new BaseObject();
baseObject.mFnTransform = mfnTransform;
baseObject.babylonMaterial = null;
return(_ExportCustomUserAttributes(baseObject));
}
/// <summary>
/// Return the bones to export.
/// </summary>
/// <param name="skin">the skin to export</param>
/// <returns>Array of BabylonBone to export</returns>
private BabylonBone[] ExportBones(MFnSkinCluster skin)
{
int logRank = 1;
int skinIndex = GetSkeletonIndex(skin);
List <BabylonBone> bones = new List <BabylonBone>();
Dictionary <string, int> indexByFullPathName = GetIndexByFullPathNameDictionary(skin);
List <MObject> revelantNodes = GetRevelantNodes(skin);
progressBoneStep = progressSkinStep / revelantNodes.Count;
foreach (MObject node in revelantNodes)
{
MFnDagNode dagNode = new MFnDagNode(node);
MFnTransform currentNodeTransform = new MFnTransform(node);
string currentFullPathName = dagNode.fullPathName;
int index = indexByFullPathName[currentFullPathName];
int parentIndex = -1;
string parentId = null;
// find the parent node to get its index
if (!dagNode.parent(0).hasFn(MFn.Type.kWorld))
{
MFnTransform firstParentTransform = new MFnTransform(dagNode.parent(0));
parentId = firstParentTransform.uuid().asString();
parentIndex = indexByFullPathName[firstParentTransform.fullPathName];
}
string boneId = currentNodeTransform.uuid().asString();
// create the bone
BabylonBone bone = new BabylonBone()
{
id = (!isBabylonExported)?boneId:boneId + "-bone",// the suffix "-bone" is added in babylon export format to assure the uniqueness of IDs
parentNodeId = parentId,
name = dagNode.name,
index = indexByFullPathName[currentFullPathName],
parentBoneIndex = parentIndex,
matrix = GetBabylonMatrix(currentNodeTransform, frameBySkeletonID[skinIndex]).m,
animation = GetAnimationsFrameByFrameMatrix(currentNodeTransform)
};
bones.Add(bone);
RaiseVerbose($"Bone: name={bone.name}, index={bone.index}, parentBoneIndex={bone.parentBoneIndex}, matrix={string.Join(" ", bone.matrix)}", logRank + 1);
// Progress bar
progressSkin += progressBoneStep;
ReportProgressChanged(progressSkin);
CheckCancelled();
}
// sort
List <BabylonBone> sorted = new List <BabylonBone>();
sorted = bones.OrderBy(bone => bone.index).ToList();
bones = sorted;
RaiseMessage($"{bones.Count} bone(s) exported", logRank + 1);
return(bones.ToArray());
}
private void GetTransform(MFnTransform mFnTransform, ref float[] position)
{
var transformationMatrix = new MTransformationMatrix(mFnTransform.transformationMatrix);
position = transformationMatrix.getTranslation();
// Switch coordinate system at object level
position[2] *= -1;
}
private BabylonAnimation GetAnimationsFrameByFrameMatrix(MFnTransform mFnTransform)
{
int start = GetMinTime()[0];
int end = GetMaxTime()[0];
BabylonAnimation animation = null;
// get keys
List <BabylonAnimationKey> keys = new List <BabylonAnimationKey>();
for (int currentFrame = start; currentFrame <= end; currentFrame++)
{
// Set the animation key
BabylonAnimationKey key = new BabylonAnimationKey()
{
frame = currentFrame,
values = GetBabylonMatrix(mFnTransform, currentFrame).m.ToArray()
};
keys.Add(key);
}
// Optimization
OptimizeAnimations(keys, false); // Do not remove linear animation keys for bones
// Ensure animation has at least 2 frames
if (keys.Count > 1)
{
var animationPresent = true;
// Ensure animation has at least 2 non equal frames
if (keys.Count == 2)
{
if (keys[0].values.IsEqualTo(keys[1].values))
{
animationPresent = false;
}
}
if (animationPresent)
{
// Create BabylonAnimation
// Animations
animation = new BabylonAnimation()
{
name = mFnTransform.name + "Animation", // override default animation name
dataType = (int)BabylonAnimation.DataType.Matrix,
loopBehavior = (int)BabylonAnimation.LoopBehavior.Cycle,
framePerSecond = GetFPS(),
keys = keys.ToArray(),
property = "_matrix"
};
}
}
return(animation);
}
public static List <MFnTransform> GetHierachyAllTrans(MDagPath startDag, MFn.Type filterType = MFn.Type.kInvalid)
{
MFnTransform currentTrans = new MFnTransform(startDag);
//no need for trans data , so mfntransform(mobject) is used
List <MFnTransform> result = new List <MFnTransform>();
AddChildrenToList(result, currentTrans, filterType);
return(result);
}
private void getXformData(MayaXform xform)
{
// Get the maya transform node to get data from.
MFnTransform mayaXform = new MFnTransform(xform.mayaObjectPath);
// Get the matrix.
MMatrix mayaMatrix = mayaXform.transformationMatrix;
mayaMatrix.get(xform.matrix);
}
private MMatrix GetMMatrix(MFnTransform mFnTransform, double currentFrame = 0)
{
// get transformation matrix at this frame
MDoubleArray mDoubleMatrix = new MDoubleArray();
MGlobal.executeCommand($"getAttr -t {currentFrame} {mFnTransform.fullPathName}.matrix", mDoubleMatrix);
mDoubleMatrix.get(out float[] localMatrix);
return(new MMatrix(localMatrix));
}
private void ExportNode(BabylonAbstractMesh babylonAbstractMesh, MFnTransform mFnTransform, BabylonScene babylonScene)
{
RaiseVerbose("BabylonExporter.Mesh | ExportNode", 2);
// Position / rotation / scaling
ExportTransform(babylonAbstractMesh, mFnTransform);
// Hierarchy
ExportHierarchy(babylonAbstractMesh, mFnTransform);
}
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);
}
/// <summary>
/// Return the bones to export.
/// </summary>
/// <param name="skin">the skin to export</param>
/// <returns>Array of BabylonBone to export</returns>
private BabylonBone[] ExportBones(MFnSkinCluster skin)
{
int logRank = 1;
int skinIndex = GetSkeletonIndex(skin);
List <BabylonBone> bones = new List <BabylonBone>();
Dictionary <string, int> indexByFullPathName = GetIndexByFullPathNameDictionary(skin);
List <MObject> revelantNodes = GetRevelantNodes(skin);
progressBoneStep = progressSkinStep / revelantNodes.Count;
foreach (MObject node in revelantNodes)
{
MFnDagNode dagNode = new MFnDagNode(node);
MFnTransform currentNodeTransform = new MFnTransform(node);
string currentFullPathName = dagNode.fullPathName;
int index = indexByFullPathName[currentFullPathName];
int parentIndex = -1;
// find the parent node to get its index
if (!dagNode.parent(0).hasFn(MFn.Type.kWorld))
{
MFnTransform firstParentTransform = new MFnTransform(dagNode.parent(0));
parentIndex = indexByFullPathName[firstParentTransform.fullPathName];
}
// create the bone
BabylonBone bone = new BabylonBone()
{
name = currentFullPathName,
index = indexByFullPathName[currentFullPathName],
parentBoneIndex = parentIndex,
matrix = ConvertMayaToBabylonMatrix(currentNodeTransform.transformationMatrix).m.ToArray(),
animation = GetAnimationsFrameByFrameMatrix(currentNodeTransform)
};
bones.Add(bone);
RaiseMessage($"Bone: name={bone.name}, index={bone.index}, parentBoneIndex={bone.parentBoneIndex}, matrix={string.Join(" ", bone.matrix)}", logRank + 1);
// Progress bar
progressSkin += progressBoneStep;
ReportProgressChanged(progressSkin);
CheckCancelled();
}
// sort
List <BabylonBone> sorted = new List <BabylonBone>();
sorted = bones.OrderBy(bone => bone.index).ToList();
bones = sorted;
RaiseMessage($"{bones.Count} bone(s) exported", logRank + 1);
return(bones.ToArray());
}
public static void IterateHierachy(MFnTransform rootTrans, int rootLevel, ref string resultStr)
{
for (int i = 0; i < rootLevel; i++)
{
resultStr += "\t";
}
resultStr += rootTrans.name + "\n";
for (int i = 0; i < rootTrans.childCount; i++)
{
IterateHierachy(new MFnTransform(rootTrans.child((uint)i)), rootLevel + 1, ref resultStr);
}
}
public static MDagPath CreateLocator(MVector worldPos, string locatorName)
{
string cmdStr = "cmds.spaceLocator(n='" + locatorName + "')";
locatorName = SubUShell(MGlobal.executePythonCommandStringResult(cmdStr));
MDagPath locDagPath = BasicFunc.GetDagPathByName(locatorName);
MFnTransform locatorTrans = new MFnTransform(locDagPath);
//Debug.Log(locatorName+"dag:"+locDagPath.fullPathName);
locatorTrans.setTranslation(worldPos, MSpace.Space.kWorld);
return(locDagPath);
}
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);
}
public static MDagPath AddChildCircle(MDagPath targetDagPath)
{
string ctlName = "ctl_" + targetDagPath.partialPathName;
MDagPath ctlDagPath = BasicFunc.CreateCircle(ctlName);
ctlName = ctlDagPath.fullPathName;
SetTransformParent(ctlName, targetDagPath.fullPathName);
MFnTransform circleTransform = new MFnTransform(ctlDagPath);
circleTransform.setTranslation(new MVector(0, 0, 0), MSpace.Space.kObject);
circleTransform.setRotation(new MEulerRotation(0, 90 / ConstantValue.DPR, 0));
FreezeTransform(circleTransform);
return(ctlDagPath);
}
public static MDagPath AddEmptyGroup(string grpName, string parentName)
{
string resultGrpName = MGlobal.executeCommandStringResult("group -em -n " + grpName);
MDagPath resultGrpDagPath = GetDagPathByName(resultGrpName);
if (parentName.Length > 0)
{
MFnTransform resultGrpTrans = new MFnTransform(resultGrpDagPath);
SetTransformParent(resultGrpName, parentName);
ClearTransform(resultGrpTrans);
FreezeTransform(resultGrpTrans);
}
return(resultGrpDagPath);
}
public static void ClearTransform(MFnTransform targetTransform, bool clearPos = true, bool clearPivotRot = true, bool clearPivotScale = true)
{
if (clearPos)
{
targetTransform.setTranslation(MVector.zero, MSpace.Space.kObject);
}
if (clearPivotRot)
{
targetTransform.setRotatePivotTranslation(MVector.zero, MSpace.Space.kObject);
}
if (clearPivotScale)
{
targetTransform.setScalePivotTranslation(MVector.one, MSpace.Space.kObject);
}
}
private void ExportHierarchy(BabylonNode babylonNode, MFnTransform mFnTransform)
{
if (mFnTransform.parentCount != 0)
{
RaiseVerbose("BabylonExporter.Node | Hierarchy", 2);
MObject parentMObject = mFnTransform.parent(0);
// Children of World node don't have parent in Babylon
if (parentMObject.apiType != MFn.Type.kWorld)
{
MFnDagNode mFnTransformParent = new MFnDagNode(parentMObject);
babylonNode.parentId = mFnTransformParent.uuid().asString();
}
}
}
public static void SetRotationLimit(MFnTransform mfnTrans, float minX, float minY, float minZ, float maxX, float maxY, float maxZ)
{
mfnTrans.enableLimit(MFnTransform.LimitType.kRotateMinX, true);
mfnTrans.enableLimit(MFnTransform.LimitType.kRotateMinY, true);
mfnTrans.enableLimit(MFnTransform.LimitType.kRotateMinZ, true);
mfnTrans.enableLimit(MFnTransform.LimitType.kRotateMaxX, true);
mfnTrans.enableLimit(MFnTransform.LimitType.kRotateMaxY, true);
mfnTrans.enableLimit(MFnTransform.LimitType.kRotateMaxZ, true);
mfnTrans.setLimit(MFnTransform.LimitType.kRotateMinX, minX);
mfnTrans.setLimit(MFnTransform.LimitType.kRotateMinY, minY);
mfnTrans.setLimit(MFnTransform.LimitType.kRotateMinZ, minZ);
mfnTrans.setLimit(MFnTransform.LimitType.kRotateMaxX, maxX);
mfnTrans.setLimit(MFnTransform.LimitType.kRotateMaxY, maxY);
mfnTrans.setLimit(MFnTransform.LimitType.kRotateMaxZ, maxZ);
}
/// <summary>
/// Init the dictionary of the skin. This dictionary represents the skeleton. It contains the node names and their index.
/// And add it to skinDictionary
/// </summary>
/// <param name="skin">the skin cluster</param>
/// <returns>
/// The dictionary that represents the skin skeleton
/// </returns>
private Dictionary <string, int> GetIndexByFullPathNameDictionary(MFnSkinCluster skin)
{
if (skinDictionary.ContainsKey(skin.name))
{
return(skinDictionary[skin.name]);
}
Dictionary <string, int> indexByFullPathName = new Dictionary <string, int>();
List <MObject> revelantNodes = GetRevelantNodes(skin);
// get the root node
MObject rootNode = GetRootNode(skin);
// Travel the DAG
MItDag dagIterator = new MItDag(MItDag.TraversalType.kDepthFirst);
dagIterator.reset(rootNode);
int index = 0;
while (!dagIterator.isDone)
{
// current node
MDagPath mDagPath = new MDagPath();
dagIterator.getPath(mDagPath);
MObject currentNode = mDagPath.node;
try
{
if (revelantNodes.Count(node => Equals(node, currentNode)) > 0)
{
MFnTransform currentNodeTransform = new MFnTransform(currentNode);
string currentFullPathName = currentNodeTransform.fullPathName;
indexByFullPathName.Add(currentFullPathName, index);
index++;
}
}
catch // When it's not a kTransform or kJoint node. For exemple a kLocator, kNurbsCurve.
{
RaiseError($"{currentNode.apiType} is not supported. It will not be exported: {mDagPath.fullPathName}", 3);
return(null);
}
dagIterator.next();
}
skinDictionary.Add(skin.name, indexByFullPathName);
return(indexByFullPathName);
}
private void GetTransform(MFnTransform mFnTransform, ref float[] position, ref float[] rotationQuaternion, ref float[] rotation, ref float[] scaling)
{
var transformationMatrix = new MTransformationMatrix(mFnTransform.transformationMatrix);
position = transformationMatrix.getTranslation();
rotationQuaternion = transformationMatrix.getRotationQuaternion();
rotation = transformationMatrix.getRotation();
scaling = transformationMatrix.getScale();
// Switch coordinate system at object level
position[2] *= -1;
rotationQuaternion[0] *= -1;
rotationQuaternion[1] *= -1;
rotation[0] *= -1;
rotation[1] *= -1;
}
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);
}
}
}
protected void __action (MoveToolAction flag) {
//- Do the actual work here to move the objects by vector
MVector vector = __delta;
if ( flag == MoveToolAction.kUndoIt ) {
vector =-vector ;
} else {
// all other cases identical
}
//- Create a selection list iterator
MSelectionList slist = MGlobal.activeSelectionList;
foreach (MDagPath mdagPath in slist.DagPaths())
{
MObject mComponent = mdagPath.node;
try {
MFnTransform transFn =new MFnTransform(mdagPath);
try {
transFn.translateBy (vector, MSpace.Space.kWorld) ;
continue ;
} catch (Exception) {
MGlobal.displayInfo("Error doing translate on transform");
}
} catch (Exception) {
//- Not a transform
}
try
{
var CVs = new MCCurveCV(mdagPath, mComponent);
try
{
foreach (MItCurveCV cvFn2 in CVs)
cvFn2.translateBy(vector, MSpace.Space.kWorld);
CVs.iter.updateCurve();
}
catch (System.Exception)
{
MGlobal.displayInfo("Error setting Curve CV");
}
}
catch (System.Exception )
{
//- No Curve CV
}
try {
MItSurfaceCV sCvFn =new MItSurfaceCV (mdagPath, mComponent, true) ;
try {
while ( !sCvFn.isDone ) {
while ( !sCvFn.isRowDone ) {
sCvFn.translateBy (vector, MSpace.Space.kWorld) ;
sCvFn.next () ;
}
sCvFn.nextRow () ;
}
sCvFn.updateSurface () ;
} catch (Exception) {
MGlobal.displayInfo("Error setting Surface CV");
}
} catch (Exception) {
//- No Surface CV
}
try {
var meshVertexEnum = new MCMeshVertex(mdagPath, mComponent);
try {
foreach (MItMeshVertex vtxFn in meshVertexEnum)
vtxFn.translateBy(vector, MSpace.Space.kWorld);
meshVertexEnum.iter.updateSurface();
}
catch (Exception)
{
MGlobal.displayInfo("Error setting Mesh Vertex");
}
} catch (Exception) {
//- No Mesh Vertex
}
}
}
public override bool doRelease(M3dView view)
{
// Scale nodes on the selection list.
// Simple implementation that does not
// support undo.
MSelectionList list = new MSelectionList();
MGlobal.getActiveSelectionList(list);
MObject node = new MObject();
for (MItSelectionList iter = new MItSelectionList(list); !iter.isDone; iter.next())
{
iter.getDependNode(node);
MFnTransform xform;
try
{
xform = new MFnTransform(node);
}
catch (System.Exception)
{
continue;
}
double[] newScale = new double[3];
newScale[0] = mousePointGlName.x + 1;
newScale[1] = mousePointGlName.y + 1;
newScale[2] = mousePointGlName.z + 1;
xform.setScale(newScale);
}
return true;
}
private void getXformData( MayaXform xform )
{
// Get the maya transform node to get data from.
MFnTransform mayaXform = new MFnTransform(xform.mayaObjectPath);
// Get the matrix.
MMatrix mayaMatrix = mayaXform.transformationMatrix;
mayaMatrix.get(xform.matrix);
}
public MFnMesh GetFirstMesh()
{
var selected = GetFirstSelectedMesh();
MFnMesh mesh=null;
// The reason why there might not be a selection is if some tool isn't closed
// and prevent the previous selection command from going through
if (selected != null)
{
if (selected.node.apiTypeStr == "kMesh")
{
mesh = new MFnMesh(selected);
}
if (selected.node.apiTypeStr == "kTransform")
{
MFnTransform trans = new MFnTransform(selected);
mesh = new MFnMesh(trans.child(0));
}
}
return mesh;
}
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 );
}
